public async void Post_Update()
{
var mocks = new Mocks();
var submittedModel = new RentalModel {
Id = 1
};
mocks._repository.Setup(m => m.GetAsync(1, null)).Returns(
Task.FromResult <RentalModel>(
new RentalModel {
Id = 1
}
)
);
mocks._repository.Setup(m => m.Update(submittedModel));
var _controller = NewRentalController(mocks);
var result = await _controller.Post(null, new RentalModel { Id = 1 });
Assert.IsType <OkObjectResult>(result);
var value = (result as OkObjectResult).Value as RentalModel;
Assert.Equal(1, value.Id);
}
public IHttpActionResult CreateNewRentals(NewRentalDto newRental)
{
var customer = _context.Customers.Single(
c => c.Id == newRental.CustomerId);
var games = _context.Games.Where(
g => newRental.GameIds.Contains(g.Id)).ToList();
foreach (var game in games)
{
if (game.NumberAvailable == 0)
{
return(BadRequest("Game is not available"));
}
game.NumberAvailable--;
var rental = new RentalModel
{
Customer = customer,
Game = game,
DateRented = DateTime.Now
};
_context.Rentals.Add(rental);
}
_context.SaveChanges();
return(Ok());
}
public async Task <IActionResult> Put(RentalModel rental)
{
try
{
_logger.LogInformation($"Updating a rental @ {rental}...");
var selectedRental = await _unitOfWork.Rental.SelectAsync(rental.Id);
if (selectedRental == null)
{
throw new KeyNotFoundException("The given id was not found.");
}
else
{
_unitOfWork.Rental.Update(selectedRental);
await _unitOfWork.CommitAsync();
_logger.LogInformation($"Successfully updated a rental @ {selectedRental}.");
return(Accepted(selectedRental));
}
}
catch (NullReferenceException e)
{
_logger.LogInformation($"Failed to update a rental @ {rental}. Caught: {e}.");
return(NotFound(rental));
}
catch (KeyNotFoundException e)
{
_logger.LogInformation($"Could not find rental @ id = {rental.Id}. Caught: {e.Message}");
return(NotFound(rental.Id));
}
}
public async Task <IActionResult> Put(RentalModel rental)
{
_unitOfWork.Rental.Update(rental);
await _unitOfWork.CommitAsync();
return(Accepted(rental));
}
internal async Task <RentalModel> getOpenByVehicleNumber(int vehicleID)
{
RentalModel model = new RentalModel();
await Task.Run(() =>
{
Rental rental = new Rental();
rental = DBase.Rentals.FirstOrDefault(rent => rent.Vehicle_ID == vehicleID && rent.Returned_Date == null);
try
{
if (rental != null)
{
model = ConverRentalToModel(rental);
}
else
{
model = null;
}
}
catch (Exception a)
{
throw a;
}
});
if (model != null)
{
return(model);
}
else
{
return(null);
}
}
internal int?CalculateTotalSum(Vehicle_Types vehicle, RentalModel rental)
{
var car = vehicle;
int total;
double daysRented = rental.Returned_Date.Value.Subtract(rental.Start_Date).TotalDays;
double daysIntended = rental.Return_Date.Subtract(rental.Start_Date).TotalDays;
if (daysRented > 0)
{
int days = (int)daysIntended - (int)daysRented;
if ((int)daysIntended >= (int)daysRented)
{
total = (int)daysRented * car.Daily_Rate;
}
else
{
total = (int)(((daysRented - daysIntended) * (car.Penalty_Rate + car.Daily_Rate)) + (daysRented * car.Daily_Rate));
}
}
else
{
total = 0;
}
return(total);
}
public void Test_Create_RentalModel(RentalModel rental)
{
var validationContext = new ValidationContext(rental);
var actual = Validator.TryValidateObject(rental, validationContext, null, true);
Assert.True(actual);
}
public async Task <IActionResult> Put(RentalModel rental)
{
try
{
_logger.LogInformation($"Updating a rental @ {rental}...");
var selectedRental = (await _unitOfWork.Rental.SelectAsync(e => e.EntityId == rental.EntityId)).FirstOrDefault();
_unitOfWork.Rental.Update(selectedRental);
await _unitOfWork.CommitAsync();
_logger.LogInformation($"Successfully updated a rental @ {selectedRental}.");
return(Accepted(selectedRental));
}
catch (NullReferenceException e)
{
_logger.LogInformation(e, "Caught: {e}. Given rental parameter was null.", e);
return(NotFound(rental));
}
catch (KeyNotFoundException e)
{
_logger.LogInformation(e, "Caught: {e.Message}. Id = {rental.Id}", e, rental);
return(NotFound(rental.EntityId));
}
}
internal async Task <Tuple <Status, List <RentalModel>, string> > GetUsersRentals(int userId)
{
List <RentalModel> returnList = new List <RentalModel>();
IEnumerable <Rental> usersRentals = DBase.Rentals.Where(rent => rent.User_ID == userId);
if (usersRentals != null)
{
foreach (Rental rental in usersRentals)
{
RentalModel model = new RentalModel();
model = ConverRentalToModel(rental);
if (rental.Returned_Date != null)
{
model.Total_Price = CalculateTotalSum(await DBase.Vehicle_Types.FindAsync(rental.Vehicle.Vehicle_Type_ID), model);
}
else
{
model.Total_Price = CalculateCurrentTotalSum(await DBase.Vehicle_Types.FindAsync(rental.Vehicle.Vehicle_Type_ID), model);// model.Vehicle_ID
}
returnList.Add(model);
}
return(new Tuple <Status, List <RentalModel>, string>(Status.Success, returnList, "Rental List"));
}
else
{
return(new Tuple <Status, List <RentalModel>, string>(Status.Success, null, "No Rentals Found For This User"));
}
}
public async void Test_Seed_HasRentals()
{
var dbOptions = await NewDb();
var rental = new RentalModel()
{
Id = 1
};
using (var ctx = new LodgingContext(dbOptions))
{
await ctx.Database.EnsureCreatedAsync();
await ctx.Rentals.AddAsync(rental);
await ctx.SaveChangesAsync();
// Setup for seeding the database
Seed.SeedDatabase(ctx);
}
using (var ctx = new LodgingContext(dbOptions))
{
// Add Asserts here.
Assert.False(ctx.Lodgings.Count() > 0);
Assert.True(ctx.Rentals.Count() > 0);
Assert.False(ctx.Reviews.Count() > 0);
}
}
public void ShouldMapRentalModelToDbRental()
{
var rentalModel = new RentalModel()
{
Customer = new UserModel()
{
Id = 1,
FirstName = "FirstName"
},
Game = new GameModel()
{
Id = 2,
Name = "Game"
}
};
var config = new MapperConfiguration(c => c.AddProfile(new MapperProfile()));
var mapper = config.CreateMapper();
var rental = mapper.Map <RentalModel, Rental>(rentalModel);
Assert.Equal(rentalModel.Customer.Id, rental.UserId);
Assert.Equal(rentalModel.Game.Id, rental.GameId);
Assert.Null(rental.User);
Assert.Null(rental.Game);
}
public async Task <IHttpActionResult> Rent(RentalModel _rental)
{
string userContext = RequestContext.Principal.Identity.GetUserId();
int ID = int.Parse(userContext);
if (userContext != null)
{
Rental returnRental = new Rental();
Tuple <string, Vehicle> vehicleAndDate = store.getVehicle(_rental);
if (vehicleAndDate.Item2.Available)
{
returnRental = await store.rentVehicle(ID, _rental, vehicleAndDate.Item2);
return(Ok(returnRental));
}
else
{
if (vehicleAndDate == null)
{
return(Content(HttpStatusCode.Forbidden, "Vehicle is not available"));
}
else
{
return(Content(HttpStatusCode.Forbidden, vehicleAndDate.Item1));
}
}
}
else
{
return(BadRequest("Unknown User"));
}
}
internal int?CalculateCurrentTotalSum(Vehicle_Types vehicle, RentalModel rental)
{
var car = vehicle;
int total;
int daysInRental = (int)rental.Return_Date.Subtract(rental.Start_Date).TotalDays;
int daysRented = (int)DateTime.Now.Subtract(rental.Start_Date).TotalDays;
if (daysRented > 0)
{
if (daysRented > daysInRental)
{
total = ((daysRented - daysInRental) * (car.Penalty_Rate + car.Daily_Rate)) + (daysInRental * car.Daily_Rate);
}
else
{
total = daysRented * car.Daily_Rate;
}
}
else
{
total = 0;
}
return(total);
}
public async Task <IActionResult> Post(RentalModel rental)
{
if (rental == null)
{
return(BadRequest());
}
var ExistingEntry = await _unitOfWork.Rental.GetAsync(rental.Id);
if (ExistingEntry == null)
{
var obj = await _unitOfWork.Rental.InsertAsync(rental);
await _unitOfWork.CommitAsync();
return(Ok(obj));
}
else
{
_unitOfWork.Rental.Update(rental);
await _unitOfWork.CommitAsync();
return(Ok(rental));
}
}
public IHttpActionResult CreateRentals(NewRentalDto newRental)
{
var customer = _context.Customers.Single(c => c.Id == newRental.CustomerId);
var movies = _context.Movies.Where(m => newRental.MovieIds.Contains(m.Id)).ToList();
foreach (var movie in movies)
{
if (movie.NumberAvailable == 0)
{
return(BadRequest("Movie is not available at the moment."));
}
else
{
movie.NumberAvailable--;
}
var rental = new RentalModel
{
Customer = customer,
Movie = movie,
DateRented = DateTime.Now
};
_context.Rentals.Add(rental);
}
_context.SaveChanges();
return(Ok());
}
// GET: Rental
public ActionResult List()
{
DataTable dtList = objRentalEquipmentDAL.GetRentalEquipmentList();
List <RentalModel> objListRentalModel = new List <RentalModel>();
if (dtList != null)
{
foreach (DataRow item in dtList.Rows)
{
RentalModel objRentalModel = new RentalModel();
objRentalModel.RentalID = Convert.ToInt16(item["RentalID"].ToString());
objRentalModel.EquipmentType = item["EquipmentType"].ToString();
objRentalModel.FromDate = DateTime.ParseExact(Convert.ToDateTime(item["FromDate"].ToString()).ToShortDateString(), "M/d/yyyy", CultureInfo.InvariantCulture).ToString("dd/MM/yyyy");
objRentalModel.ToDate = DateTime.ParseExact(Convert.ToDateTime(item["ToDate"].ToString()).ToShortDateString(), "M/d/yyyy", CultureInfo.InvariantCulture).ToString("dd/MM/yyyy");
objRentalModel.ContactNumber = item["ContactNumber"].ToString();
objRentalModel.EmailID = item["EmailID"].ToString();
objRentalModel.Price = item["Price"].ToString();
objRentalModel.Location = item["Location"].ToString();
if (Convert.ToString(item["Comments"]) != "")
{
objRentalModel.Comments = item["Comments"].ToString();
}
objListRentalModel.Add(objRentalModel);
}
}
return(View(objListRentalModel));
}
public async Task <ActionResult> Post(RentalModel model)
{
if (!ModelState.IsValid)
{
return(this.BadRequest(this.GetErrorJsonFromModelState()));
}
var dto = new RentalDto
{
BookId = model.BookId,
CustomerId = model.CustomerId,
RentDate = DateTime.UtcNow,
ReturnDate = model.ReturnDate,
};
this.PopulateAuditFieldsOnCreate(dto);
var response = await this._rentalService.InsertAsync(new GenericRequest <RentalDto>
{
Data = dto
});
if (response.IsError())
{
return(this.BadRequest(this.GetErrorJson(response)));
}
return(this.Ok(this.GetSuccessJson(response, response.Data)));
}
public async Task <IActionResult> PostAsync(RentalModel rental)
{
await _unitOfWork.Rental.InsertAsync(rental);
await _unitOfWork.CommitAsync();
return(Created(Url.RouteUrl(rental.Id), rental.Id));
}
public ActionResult PostRental(PostRental postrental)
{
var rental = new RentalModel(postrental);
_dbContext.RentalsCollection.InsertOne(rental);
return(RedirectToAction("Index"));
}
public async Task <IActionResult> Post(RentalModel rental)
{
await _unitOfWork.Rental.InsertAsync(rental);
await _unitOfWork.CommitAsync();
return(Accepted(rental));
}
public async void Test_Repository_DeleteAsync(LodgingModel lodging, RentalModel rental, ReviewModel review)
{
await _connection.OpenAsync();
try
{
using (var ctx = new LodgingContext(_options))
{
await ctx.Database.EnsureCreatedAsync();
await ctx.Lodgings.AddAsync(lodging);
await ctx.Rentals.AddAsync(rental);
await ctx.Reviews.AddAsync(review);
await ctx.SaveChangesAsync();
}
using (var ctx = new LodgingContext(_options))
{
var lodgings = new Repository <LodgingModel>(ctx);
await lodgings.DeleteAsync(1);
await ctx.SaveChangesAsync();
Assert.Empty(await ctx.Lodgings.ToListAsync());
}
using (var ctx = new LodgingContext(_options))
{
var rentals = new Repository <RentalModel>(ctx);
await rentals.DeleteAsync(1);
await ctx.SaveChangesAsync();
Assert.Empty(await ctx.Rentals.ToListAsync());
}
using (var ctx = new LodgingContext(_options))
{
var reviews = new Repository <ReviewModel>(ctx);
await reviews.DeleteAsync(1);
await ctx.SaveChangesAsync();
Assert.Empty(await ctx.Reviews.ToListAsync());
}
}
finally
{
await _connection.CloseAsync();
}
}
public async void Test_Repository_Update(BookingModel booking, StayModel stay)
{
await _connection.OpenAsync();
try
{
using (var ctx = new BookingContext(_options))
{
await ctx.Database.EnsureCreatedAsync();
await ctx.Bookings.AddAsync(booking);
await ctx.Stays.AddAsync(stay);
await ctx.SaveChangesAsync();
}
using (var ctx = new BookingContext(_options))
{
var rentals = new List <RentalModel>();
var rental = new RentalModel {
Id = 1
};
rentals.Add(rental);
booking.Rentals = rentals;
var bookings = new Repository <BookingModel>(ctx);
var expected = await ctx.Bookings.FirstAsync();
expected.Status = "updated";
bookings.Update(expected);
await ctx.SaveChangesAsync();
var actual = await ctx.Bookings.FirstAsync();
Assert.Equal(expected, actual);
}
using (var ctx = new BookingContext(_options))
{
var stays = new Repository <StayModel>(ctx);
var expected = await ctx.Stays.FirstAsync();
expected.DateModified = DateTime.Now;
stays.Update(expected);
await ctx.SaveChangesAsync();
var actual = await ctx.Stays.FirstAsync();
Assert.Equal(expected, actual);
}
}
finally
{
_connection.Close();
}
}
public int AddRental(RentalModel newRental)
{
var rental = this.mapper.Map <RentalModel, Rental>(newRental);
this.efContext.Rentals.Add(rental);
var totalStateEntriesWritten = this.efContext.SaveChanges();
return(totalStateEntriesWritten);
}
public async Task <IActionResult> Post(RentalModel rental)
{
_logger.LogInformation($"Creating a new rental @ {rental}...");
await _unitOfWork.Rental.InsertAsync(rental);
await _unitOfWork.CommitAsync();
_logger.LogInformation($"Successfully created a new rental @ {rental}.");
return(Accepted(rental));
}
public int UpdateRental(RentalModel rentalModel)
{
var dbRental = this.efContext.Rentals.Single(rental => rental.Id == rentalModel.Id);
dbRental = this.mapper.Map <RentalModel, Rental>(rentalModel, dbRental);
var totalStateEntriesWritten = this.efContext.SaveChanges();
return(totalStateEntriesWritten);
}
public async void Test_Controller_Put()
{
RentalModel rentalmodel = await _unitOfWork.Rental.SelectAsync(2);
var resultPass = await _controller.Put(rentalmodel);
var resultFail = await _controller.Put(null);
Assert.NotNull(resultPass);
Assert.NotNull(resultFail);
}
public async void Test_Repository_Update(LodgingModel lodging, RentalModel rental, ReviewModel review)
{
using (var ctx = new LodgingContext(Options))
{
ctx.Rentals.RemoveRange(ctx.Rentals);
ctx.Lodgings.RemoveRange(ctx.Lodgings);
await ctx.Lodgings.AddAsync(lodging);
await ctx.Rentals.AddAsync(rental);
await ctx.Reviews.AddAsync(review);
await ctx.SaveChangesAsync();
}
using (var ctx = new LodgingContext(Options))
{
var lodgings = new Repository <LodgingModel>(ctx);
var lodgingToUpdate = await ctx.Lodgings.FirstAsync();
lodgingToUpdate.Name = "Name";
lodgings.Update(lodgingToUpdate);
var result = ctx.Lodgings.Find(lodging.Id);
Assert.Equal(lodgingToUpdate.Name, result.Name);
Assert.Equal(EntityState.Modified, ctx.Entry(result).State);
}
using (var ctx = new LodgingContext(Options))
{
var rentals = new Repository <RentalModel>(ctx);
var rentalToUpdate = await ctx.Rentals.FirstAsync();
rentalToUpdate.LotNumber = "4";
rentals.Update(rentalToUpdate);
var result = ctx.Rentals.Find(rental.Id);
Assert.Equal(rentalToUpdate.LotNumber, result.LotNumber);
Assert.Equal(EntityState.Modified, ctx.Entry(result).State);
}
using (var ctx = new LodgingContext(Options))
{
var reviews = new Repository <ReviewModel>(ctx);
var reviewToUpdate = await ctx.Reviews.FirstAsync();
reviewToUpdate.Comment = "Comment";
reviews.Update(reviewToUpdate);
var result = ctx.Reviews.Find(review.Id);
Assert.Equal(reviewToUpdate.Comment, result.Comment);
Assert.Equal(EntityState.Modified, ctx.Entry(result).State);
}
}
public async void TestRepositoryDeleteAsync(LodgingModel lodging, RentalModel rental, ReviewModel review, ImageModel image)
{
using (var ctx = new LodgingContext(Options))
{
ctx.Rentals.RemoveRange(ctx.Rentals);
ctx.Lodgings.RemoveRange(ctx.Lodgings);
ctx.Images.RemoveRange(ctx.Images);
await ctx.Rentals.AddAsync(rental);
await ctx.Reviews.AddAsync(review);
await ctx.Images.AddAsync(image);
await ctx.Lodgings.AddAsync(lodging);
await ctx.SaveChangesAsync();
}
using (var ctx = new LodgingContext(Options))
{
var lodgings = new Repository <LodgingModel>(ctx);
await lodgings.DeleteAsync(lodging.EntityId);
Assert.Equal(EntityState.Deleted, ctx.Entry(ctx.Lodgings.Find(lodging.EntityId)).State);
}
using (var ctx = new LodgingContext(Options))
{
var rentals = new Repository <RentalModel>(ctx);
await rentals.DeleteAsync(rental.EntityId);
Assert.Equal(EntityState.Deleted, ctx.Entry(ctx.Rentals.Find(rental.EntityId)).State);
}
using (var ctx = new LodgingContext(Options))
{
var reviews = new Repository <ReviewModel>(ctx);
await reviews.DeleteAsync(review.EntityId);
Assert.Equal(EntityState.Deleted, ctx.Entry(ctx.Reviews.Find(review.EntityId)).State);
}
using (var ctx = new LodgingContext(Options))
{
var images = new Repository <ImageModel>(ctx);
await images.DeleteAsync(image.EntityId);
Assert.Equal(EntityState.Deleted, ctx.Entry(ctx.Images.Find(image.EntityId)).State);
}
}
public IHttpActionResult CreateNewRentals(RentalDto rentalDto)
{
if (rentalDto.MovieIds.Count == 0)
{
return(BadRequest("No Movie Ids given"));
}
var customerId = rentalDto.CustomerId;
var customerInDb = _context.Customers.Single(c => c.Id == customerId);
if (customerInDb == null)
{
return(BadRequest("CustomerId is invalid"));
}
var movieIds = rentalDto.MovieIds.ToList();
var moviesInDb = _context.Movies.Where(m => movieIds.Contains(m.Id)).ToList();
// these if statement polluted the code, it's call very defensive approach for validation.
if (moviesInDb.Count != rentalDto.MovieIds.Count)
{
return(BadRequest("One or More Movie Ids are Invalid"));
}
// var rentalDetail = new RentalDto();
// var movieIdsList = new List<int>();
// rentalDetail.CustomerId = rentalDto.CustomerId;
// rentalDetail.DateRented = rentalDto.DateRented;
// rentalDetail.DateReturned = rentalDto.DateReturned;
foreach (var movie in moviesInDb)
{
if (movie.NumberAvailable == 0)
{
return(BadRequest("Movie is not available"));
}
movie.NumberAvailable--;
var rental = new RentalModel
{
Customer = customerInDb,
Movie = movie,
DateRented = DateTime.Now
};
_context.Rentals.Add(rental);
}
_context.SaveChanges();
// rentalDetail.MovieIds = movieIdsList;
// var rentals = Mapper.Map<RentalDto, RentalModel >(rentalDetail);
// _context.Rentals.Add(rentals);
return(Ok());
throw new NotImplementedException();
}
public async void Delete_UsingInvalidId()
{
var mocks = new Mocks();
RentalModel mockResult = null;
mocks._repository.Setup(m => m.DeleteAsync(1, null)).Returns(Task.FromResult(mockResult));
var _controller = NewRentalController(mocks);
var result = await _controller.Delete(null, 1);
Assert.IsType <NotFoundResult>(result);
}
