public QrCodeController(QrCodeService qrCodeservice, BusService busService, UserService userService, RidesService ridesService)
{
this.qrCodeService = qrCodeservice;
this.busService = busService;
this.userService = userService;
this.ridesService = ridesService;
}
public override async Task OnInitializing()
{
Items = await RidesService.GetUserRides(refresher : Refresh);
await base.OnInitializing();
if (Items != null && Items.Length > 0)
{
var Item = Items[0];
await MapView.Add(new Map.Annotation
{
Title = Item.From,
Location = new Zebble.Services.GeoLocation(Item.FromStation.Latitude, Item.FromStation.Longitude)
});
await MapView.Add(new Map.Annotation
{
Title = Item.To,
Location = new Zebble.Services.GeoLocation(Item.ToStation.Latitude, Item.ToStation.Longitude)
});
MapView.Center = new Zebble.Services.GeoLocation(((Item.ToStation.Latitude + Item.FromStation.Latitude) / 2), ((Item.ToStation.Longitude + Item.FromStation.Longitude) / 2));
}
else
{
await MapView.Add(new Map.Annotation
{
Title = GlobalSettings.City,
Location = new Zebble.Services.GeoLocation(GlobalSettings.EventLatitude, GlobalSettings.EventLongitude)
});
}
}
public async Task CreateAsync_WithNonExistentCar_ReturnsNull()
{
// Arrange
var testCarId = Guid.NewGuid().ToString();
var context = new PoolItDbContext(new DbContextOptionsBuilder <PoolItDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString())
.Options);
var serviceModel = new RideServiceModel
{
Title = "Test Ride",
CarId = testCarId,
From = "Test From",
To = "Test To",
Date = DateTime.UtcNow,
AvailableSeats = 2
};
var ridesService = new RidesService(new EfRepository <Ride>(context), null, new EfRepository <Car>(context), null);
// Act
var result = await ridesService.CreateAsync(serviceModel);
// Assert
Assert.Null(result);
var dbModel = await context.Rides.AnyAsync();
Assert.False(dbModel);
}
public async Task CreateAsync_WithValidModel_WorksCorrectly()
{
// Arrange
var context = new PoolItDbContext(new DbContextOptionsBuilder <PoolItDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString())
.Options);
var user = new PoolItUser
{
UserName = "******"
};
var car = new Car
{
Model = new CarModel
{
Model = "Test Model",
Manufacturer = new CarManufacturer()
},
Owner = user,
Colour = "TestColour"
};
await context.Cars.AddAsync(car);
await context.SaveChangesAsync();
var serviceModel = new RideServiceModel
{
Title = "Test Ride",
CarId = car.Id,
From = "Test From",
To = "Test To",
Date = DateTime.UtcNow,
AvailableSeats = 2
};
var ridesService = new RidesService(new EfRepository <Ride>(context), null, new EfRepository <Car>(context), null);
// Act
var result = await ridesService.CreateAsync(serviceModel);
// Assert
Assert.NotNull(result);
var dbModel = await context.Rides.SingleOrDefaultAsync();
Assert.NotNull(dbModel);
// - Check correct id is returned
Assert.Equal(dbModel.Id, result);
// - Check Conversation is created
Assert.NotNull(dbModel.Conversation);
// - Check organiser is added as participant
var userRideExists = await context.UserRides.AnyAsync(u => u.UserId == user.Id && u.RideId == dbModel.Id);
Assert.True(userRideExists);
}
public void IsUserParticipant_WithUserNotParticipant_ReturnsFalse()
{
// Arrange
const string testUser = "******";
var ride = new RideServiceModel
{
Participants = new[]
{
new UserRideServiceModel
{
User = new PoolItUserServiceModel
{
UserName = "******"
}
}
}
};
var ridesService = new RidesService(null, null, null, null);
// Act
var result = ridesService.IsUserParticipant(ride, testUser);
// Assert
Assert.False(result);
}
public void CanUserAccessRide_WithUserNotParticipant_ReturnsFalse()
{
// Arrange
const string testUser = "******";
var ride = new RideServiceModel
{
Date = DateTime.UtcNow.AddDays(-1),
Participants = new[]
{
new UserRideServiceModel
{
User = new PoolItUserServiceModel
{
UserName = "******"
}
}
}
};
var ridesService = new RidesService(null, null, null, null);
// Act
var result = ridesService.CanUserAccessRide(ride, testUser);
// Assert
Assert.False(result);
}
public ActionResult Post([FromBody] PhoneRideRequest request)
{
RidesService ridesService = new RidesService();
return(ridesService.Post(request));
// if (request.dropoffs == null || request.passengers == null || request.firstName == null ||
// request.homeAddress == null || request.pickupLocation == null || request.cellPhoneNumber == null)
// {
// return BadRequest();
// }
// var convertedRideRequest = new RideRequest()
// {
// Pickup = request.pickupLocation,
// PhoneNumber = request.cellPhoneNumber,
// NumberOfPeople = request.passengers,
// Destination = request.homeAddress,
// PatronName = request.firstName
// };
// try
// {
// DBConnector db = new DBConnector();
// db.InsertRide(convertedRideRequest);
// }
// catch (Exception ex)
// {
// Console.WriteLine(ex);
// return StatusCode(500);
// }
// return Ok();
}
public async Task UpdateAsync_WithOtherDataChanged_DoesNotUpdate()
{
// Arrange
var context = new PoolItDbContext(new DbContextOptionsBuilder <PoolItDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString())
.Options);
var ride = new Ride
{
Title = "Initial Title",
PhoneNumber = "0000000000",
Notes = "Initial Notes",
Car = new Car(),
Date = DateTime.UtcNow,
AvailableSeats = 2,
From = "Test From",
To = "Test To"
};
await context.Rides.AddAsync(ride);
var car = new Car();
await context.Cars.AddAsync(car);
await context.SaveChangesAsync();
var ridesService = new RidesService(new EfRepository <Ride>(context), null, null, null);
var serviceModel = new RideServiceModel()
{
Id = ride.Id,
Title = ride.Title,
PhoneNumber = ride.PhoneNumber,
Notes = ride.Notes,
CarId = car.Id,
AvailableSeats = 1,
From = "Updated From",
To = "Updated To"
};
var initialDate = ride.Date;
var initialSeats = ride.AvailableSeats;
var initialFrom = ride.From;
var initialTo = ride.To;
// Act
await ridesService.UpdateAsync(serviceModel);
// Assert
var dbModel = await context.Rides.SingleAsync();
Assert.Equal(initialDate, dbModel.Date);
Assert.Equal(initialSeats, dbModel.AvailableSeats);
Assert.Equal(initialFrom, dbModel.From);
Assert.Equal(initialTo, dbModel.To);
}
private async Task TSelectionChanged()
{
var selected = (CustomPin)ToItemPicker.SelectedValue;
var station = await RidesService.GetStation(selected.Id);
RouteSelected.Visible = true;
ToPS.Visible = true;
ToText.Text = selected.Label;
ToPSText.Text = $"Empty bike docks {station.EmptyDocks} Avilable bikes {station.Occupied}";
}
public async Task GetAllAsync_WithRides_WorksCorrectly()
{
// Arrange
const int expectedCount = 2;
var context = new PoolItDbContext(new DbContextOptionsBuilder <PoolItDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString())
.Options);
var car = new Car
{
Model = new CarModel
{
Model = "Test Model",
Manufacturer = new CarManufacturer()
},
Owner = new PoolItUser
{
UserName = "******"
}
};
await context.Cars.AddAsync(car);
await context.Rides.AddRangeAsync(
new Ride
{
Date = DateTime.UtcNow.AddDays(1),
AvailableSeats = 1,
Car = car,
Conversation = new Conversation()
},
new Ride
{
Date = DateTime.UtcNow.AddDays(-1),
AvailableSeats = 1,
Car = car,
Conversation = new Conversation()
}
);
await context.SaveChangesAsync();
var ridesService = new RidesService(new EfRepository <Ride>(context), null, null, null);
// Act
var actualCount = (await ridesService.GetAllAsync()).Count();
// Assert
Assert.Equal(expectedCount, actualCount);
}
public async Task BookClicked()
{
var fromStation = await RidesService.GetStation(From.Id);
var toStation = await RidesService.GetStation(To.Id);
var booking = await RidesService.RequestBikeBooking(fromStation, toStation);
if (booking != null)
{
// FindParent<MainMenu>().UpcomingRideButton.Enabled = true;
await Nav.Go <BookingDetail>(new { ShowThanks = true, Booking = booking });
}
}
public async Task UpdateAsync_WithValidModel_WorksCorrectly()
{
// Arrange
var context = new PoolItDbContext(new DbContextOptionsBuilder <PoolItDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString())
.Options);
var ride = new Ride
{
Title = "Initial Title",
PhoneNumber = "0000000000",
Notes = "Initial Notes",
Car = new Car(),
Date = DateTime.UtcNow,
AvailableSeats = 1,
From = "Test From",
To = "Test To"
};
await context.Rides.AddAsync(ride);
await context.SaveChangesAsync();
var ridesService = new RidesService(new EfRepository <Ride>(context), null, null, null);
var serviceModel = new RideServiceModel()
{
Id = ride.Id,
Title = "Updated Title",
PhoneNumber = "0000000001",
Notes = "Updated Notes",
CarId = ride.CarId,
AvailableSeats = ride.AvailableSeats,
From = ride.From,
To = ride.To
};
// Act
var result = await ridesService.UpdateAsync(serviceModel);
// Assert
Assert.True(result);
var dbModel = await context.Rides.SingleAsync();
Assert.Equal(serviceModel.Title, dbModel.Title);
Assert.Equal(serviceModel.PhoneNumber, dbModel.PhoneNumber);
Assert.Equal(serviceModel.Notes, dbModel.Notes);
}
public async Task DeleteAsync_WithNullRequestId_ReturnsFalse()
{
// Arrange
var context = new PoolItDbContext(new DbContextOptionsBuilder <PoolItDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString())
.Options);
var ridesService = new RidesService(new EfRepository <Ride>(context), null, null, new EfRepository <Conversation>(context));
// Act
var result = await ridesService.DeleteAsync(null);
// Assert
Assert.False(result);
}
public async Task GetAsync_WithNullId_ReturnsNull()
{
// Arrange
var context = new PoolItDbContext(new DbContextOptionsBuilder <PoolItDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString())
.Options);
var ridesService = new RidesService(new EfRepository <Ride>(context), null, null, null);
// Act
var result = await ridesService.GetAsync(null);
// Assert
Assert.Null(result);
}
private static async Task AddUserAndBikeIdsToIssue(ReportedIssue issue)
{
if (Settings.UserId == 0)
{
throw new InvalidOperationException("UserId is not saved");
}
if (Settings.CurrentBookingId == 0)
{
throw new InvalidOperationException("CurrentBookingId is not saved");
}
var currentBooking = await RidesService.GetBooking(Settings.CurrentBookingId);
issue.BikeId = currentBooking.BikeId;
issue.UserId = Settings.UserId;
}
public void CanUserAccessRide_WithNullUser_ReturnsFalse()
{
// Arrange
var ride = new RideServiceModel
{
Date = DateTime.UtcNow.AddDays(-1)
};
var ridesService = new RidesService(null, null, null, null);
// Act
var result = ridesService.CanUserAccessRide(ride, null);
// Assert
Assert.False(result);
}
public void CanUserAccessRide_WithUpcomingRide_ReturnsTrue()
{
// Arrange
var ride = new RideServiceModel
{
Date = DateTime.UtcNow.AddDays(1)
};
var ridesService = new RidesService(null, null, null, null);
// Act
var result = ridesService.CanUserAccessRide(ride, null);
// Assert
Assert.True(result);
}
public async Task GetAllAsync_WithNoRides_ReturnsEmptyCollection()
{
// Arrange
const int expectedCount = 0;
var context = new PoolItDbContext(new DbContextOptionsBuilder <PoolItDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString())
.Options);
var ridesService = new RidesService(new EfRepository <Ride>(context), null, null, null);
// Act
var actualCount = (await ridesService.GetAllAsync()).Count();
// Assert
Assert.Equal(expectedCount, actualCount);
}
public async Task GetAllPastForUserAsync_WithNonExistentUser_ReturnsNull()
{
// Arrange
const string testUser = "******";
var context = new PoolItDbContext(new DbContextOptionsBuilder <PoolItDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString())
.Options);
var ridesService = new RidesService(new EfRepository <Ride>(context), new EfRepository <PoolItUser>(context), null, null);
// Act
var result = await ridesService.GetAllPastForUserAsync(testUser);
// Assert
Assert.Null(result);
}
public async Task UpdateAsync_WithNonExistentId_ReturnsFalse()
{
// Arrange
var testRideId = Guid.NewGuid().ToString();
var context = new PoolItDbContext(new DbContextOptionsBuilder <PoolItDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString())
.Options);
var ride = new Ride
{
Title = "Initial Title",
PhoneNumber = "0000000000",
Notes = "Initial Notes",
Car = new Car(),
Date = DateTime.UtcNow,
AvailableSeats = 1,
From = "Test From",
To = "Test To"
};
await context.Rides.AddAsync(ride);
await context.SaveChangesAsync();
var ridesService = new RidesService(new EfRepository <Ride>(context), null, null, null);
var serviceModel = new RideServiceModel()
{
Id = testRideId,
Title = "Updated Title",
PhoneNumber = "0000000001",
Notes = "Updated Notes",
CarId = ride.CarId,
AvailableSeats = ride.AvailableSeats,
From = ride.From,
To = ride.To
};
// Act
var result = await ridesService.UpdateAsync(serviceModel);
// Assert
Assert.False(result);
}
public override async Task OnInitializing()
{
bookRequest = Nav.Param <Booking>("Booking");
if (bookRequest == null)
{
var userRides = await RidesService.GetUserRides();
if (userRides != null)
{
var ride = userRides.Where(rec => rec.Start > LocalTime.Now).OrderBy(rec => rec.Start).FirstOrDefault();
if (ride != null)
{
bookRequest = new Booking
{
BikeId = ride.BikeId,
DueDate = ride.Start.AddMinutes(ride.Duration),
EventId = ride.EventId,
FromStation = ride.FromStation,
Id = ride.Id,
RegistrationDate = ride.Start,
RideType = ride.RideType,
ToStation = ride.ToStation
};
}
}
}
if (bookRequest == null)
{
await Alert.Show("Alert", "There is no available ride");
return;
}
await base.OnInitializing();
BookModule.From = new CustomPin {
Label = bookRequest.FromStation.Name
};
BookModule.To = new CustomPin {
Label = bookRequest.ToStation.Name
};
timerControl = new Timer(CounterFunc, null, 1, 1000);
}
public async Task CreateAsync_WithInvalidModel_ReturnsNull()
{
// Arrange
var context = new PoolItDbContext(new DbContextOptionsBuilder <PoolItDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString())
.Options);
var car = new Car
{
Model = new CarModel
{
Model = "Test Model",
Manufacturer = new CarManufacturer()
},
Owner = new PoolItUser
{
UserName = "******"
},
Colour = "TestColour"
};
await context.Cars.AddAsync(car);
await context.SaveChangesAsync();
var serviceModel = new RideServiceModel
{
Title = "Test Ride",
CarId = car.Id
};
var ridesService = new RidesService(new EfRepository <Ride>(context), null, new EfRepository <Car>(context), null);
// Act
var result = await ridesService.CreateAsync(serviceModel);
// Assert
Assert.Null(result);
var dbModel = await context.Rides.AnyAsync();
Assert.False(dbModel);
}
public async Task DeleteAsync_WithCorrectId_WorksCorrectly()
{
// Arrange
var context = new PoolItDbContext(new DbContextOptionsBuilder <PoolItDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString())
.Options);
var ride = new Ride
{
Title = "Ride Title",
PhoneNumber = "0000000000",
Notes = "Ride Notes",
Car = new Car(),
Date = DateTime.UtcNow,
AvailableSeats = 1,
From = "Test From",
To = "Test To",
Conversation = new Conversation()
};
await context.Rides.AddAsync(ride);
await context.SaveChangesAsync();
var ridesService = new RidesService(new EfRepository <Ride>(context), null, null, new EfRepository <Conversation>(context));
// Act
var result = await ridesService.DeleteAsync(ride.Id);
// Assert
Assert.True(result);
var rideExists = await context.Rides.AnyAsync();
Assert.False(rideExists);
var conversationExists = await context.Conversations.AnyAsync();
Assert.False(conversationExists);
}
public void IsUserOrganiser_WithNullUser_ReturnsFalse()
{
// Arrange
var ride = new RideServiceModel
{
Car = new CarServiceModel
{
Owner = new PoolItUserServiceModel
{
UserName = "******"
}
}
};
var ridesService = new RidesService(null, null, null, null);
// Act
var result = ridesService.IsUserOrganiser(ride, null);
// Assert
Assert.False(result);
}
public async Task GetAsync_WithCorrectId_WorksCorrectly()
{
// Arrange
var context = new PoolItDbContext(new DbContextOptionsBuilder <PoolItDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString())
.Options);
var ride = new Ride
{
Title = "TestRide",
Car = new Car
{
Model = new CarModel
{
Model = "Test Model",
Manufacturer = new CarManufacturer()
},
Owner = new PoolItUser
{
UserName = "******"
}
},
Conversation = new Conversation()
};
await context.Rides.AddAsync(ride);
await context.SaveChangesAsync();
var ridesService = new RidesService(new EfRepository <Ride>(context), null, null, null);
// Act
var result = await ridesService.GetAsync(ride.Id);
// Assert
Assert.NotNull(result);
Assert.Equal(ride.Title, result.Title);
}
public override async Task OnInitializing()
{
await base.OnInitializing();
MapView.ZoomLevel = 11;
RouteSelector.Y.Set(10);
RouteSelected.Y.Set(Root.ActualHeight - 230);
FromItemPicker.SelectionChanged.Handle(FSelectionChanged);
ToItemPicker.SelectionChanged.Handle(TSelectionChanged);
var nearestStations = await RidesService.GetNearestStations();
if (nearestStations != null)
{
await MapView.Add(new Map.Annotation
{
Title = nearestStations[0].Name,
Location = new Zebble.Services.GeoLocation(nearestStations[0].Latitude, nearestStations[0].Longitude)
});
InitializePinsFromStations(await RidesService.GetNearestStations());
FromItemPicker.DataSource = CustomPins.ToList();
ToItemPicker.DataSource = CustomPins.ToList();
}
}
public void IsUserOrganiser_WithUserOrganiser_ReturnsTrue()
{
// Arrange
const string testUser = "******";
var ride = new RideServiceModel
{
Car = new CarServiceModel
{
Owner = new PoolItUserServiceModel
{
UserName = testUser
}
}
};
var ridesService = new RidesService(null, null, null, null);
// Act
var result = ridesService.IsUserOrganiser(ride, testUser);
// Assert
Assert.True(result);
}
public RidesController(RidesService ridesService)
{
this.ridesService = ridesService;
}
public async Task GetAllPastForUserAsync_WithRides_WorksCorrectly()
{
// Arrange
var expectedResult = new[] { "Ride1", "Ride2" };
const string testUser = "******";
var context = new PoolItDbContext(new DbContextOptionsBuilder <PoolItDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString())
.Options);
var user = new PoolItUser
{
UserName = testUser
};
await context.Users.AddAsync(user);
var car = new Car
{
Model = new CarModel
{
Model = "Test Model",
Manufacturer = new CarManufacturer()
},
Owner = new PoolItUser
{
UserName = "******"
}
};
await context.Cars.AddAsync(car);
await context.Rides.AddRangeAsync(
new Ride
{
Title = "Ride1",
Date = DateTime.UtcNow.AddDays(-1),
Participants = new[]
{
new UserRide
{
User = user
}
},
Car = car,
Conversation = new Conversation()
},
new Ride
{
Title = "Ride2",
Date = DateTime.UtcNow.AddDays(-2),
Participants = new[]
{
new UserRide
{
User = user
}
},
Car = car,
Conversation = new Conversation()
},
new Ride
{
Title = "OtherRide1",
Date = DateTime.UtcNow.AddDays(1),
Participants = new[]
{
new UserRide
{
User = user
}
},
Car = car,
Conversation = new Conversation()
},
new Ride
{
Title = "OtherRide2",
Date = DateTime.UtcNow.AddDays(-1),
Participants = new[]
{
new UserRide
{
User = new PoolItUser
{
UserName = "******"
}
}
},
Car = car,
Conversation = new Conversation()
}
);
await context.SaveChangesAsync();
var ridesService = new RidesService(new EfRepository <Ride>(context), new EfRepository <PoolItUser>(context), null, null);
// Act
var actualResult = (await ridesService.GetAllPastForUserAsync(testUser)).Select(r => r.Title);
// Assert
Assert.Equal(expectedResult, actualResult);
}
public override async Task OnInitializing()
{
Items = await RidesService.GetSuggestions();
await base.OnInitializing();
}
