public void Create_RentalDetails(int rentalID, int equipmentID)
{
using (var context = new eToolsContext())
{
RentalEquipment equipment = context.RentalEquipments.Where(x => x.RentalEquipmentID.Equals(equipmentID)).Select(x => x).FirstOrDefault();
RentalDetail exists = context.RentalDetails.Where(x => x.RentalEquipmentID.Equals(equipmentID) && x.RentalID.Equals(rentalID)).Select(x => x).FirstOrDefault();
if (exists != null)//equipmnet already in there
{
throw new BusinessRuleException("Already Renting This Equipment", "This piece of equipment is already on this rental");
}
else
{
RentalDetail detail = new RentalDetail();
detail.RentalID = rentalID;
detail.RentalEquipment = equipment;
detail.ConditionOut = equipment.Condition;
detail.ConditionIn = equipment.Condition;
context.RentalDetails.Add(detail);
context.SaveChanges();
}
}
}
public int Return_Update(ReturnForm rtn)
{
using (var context = new eToolsContext())
{
//RentalDetail item = context.RentalDetails.Where(x => (x.RentalDetailID == rtn.ID)).FirstOrDefault();
//RentalDetail item2 = new RentalDetail();
//item2 = item;
//item2.Comments = rtn.CustomerCommets == null ? "" : rtn.CustomerCommets; //can be null
//item2.ConditionIn = rtn.CoditionCommets == null ? "" : rtn.CoditionCommets;
RentalDetail rdptr = context.RentalDetails.Where(x => (x.RentalDetailID == rtn.ID)).FirstOrDefault();
RentalDetail item = new RentalDetail();
if (rdptr == null)
{
throw new BusinessRuleException("No such rental exists!", logger);
}
else
{
item.RentalDetailID = rtn.ID;
item.RentalID = rdptr.RentalID;
item.RentalEquipmentID = rdptr.RentalEquipmentID;
item.Days = rdptr.Days;
item.DailyRate = rdptr.DailyRate;
item.ConditionOut = rdptr.ConditionOut;
item.ConditionIn = string.IsNullOrEmpty(rtn.CoditionCommets) ? "" : rtn.CoditionCommets;
item.DamageRepairCost = rdptr.DamageRepairCost;
item.Comments = string.IsNullOrEmpty(rtn.CustomerCommets) ? "" : rtn.CustomerCommets;
}
context.Entry(item).State = System.Data.Entity.EntityState.Modified;
return(context.SaveChanges());
}
}
public void removeRentalEquipment(int rentalId, int equitmentid)
{
using (var context = new eToolsContext())
{
//Return equipment
RentalEquipment checkoutEquipment = context.RentalEquipments
.Where(x => (x.RentalEquipmentID == equitmentid)).FirstOrDefault();
//Update availability
checkoutEquipment.Available = true;
//COMMIT UPDATE***
context.Entry(checkoutEquipment).State = EntityState.Modified;
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//retrive rentaldetails table that will destoryed
RentalDetail existingRentalEquipment = context.RentalDetails
.Where(x => ((x.RentalID == rentalId) &&
(x.RentalEquipmentID == equitmentid))).FirstOrDefault();
//COMMIT DELETE***
context.Entry(existingRentalEquipment).State = EntityState.Deleted;
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//Finalize Transaction!
context.SaveChanges();
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
}
}
public void deleteRental(int rentalid)
{
using (var context = new eToolsContext())
{
//.FirstOrDefault() is added in Visual Studio not in LINQ, as it does NOT AUTO. CONVERT!!
Rental rental = context.Rentals.Where(x => (x.RentalID == rentalid)).FirstOrDefault();
//A return of 1 means an EXACT MATCH
//either there is a value or not; 1 or 0
if (rental == null)
{
throw new BusinessRuleException("No such rental exists!", logger);
}
else
{
//Heavy Query!
DELETE_RentalDetailsTable_UPDATE_RentalEquipmentTable removeList = context.Rentals.Where(x => (x.RentalID == rentalid))
.Select(x =>
new DELETE_RentalDetailsTable_UPDATE_RentalEquipmentTable()
{
deleteSet = x.RentalDetails.Select(y =>
new SingleEquipmentPairWithRentalDetailDelete()
{
_RentalDetailTable = y,
_RentalEquipmentTable = y.RentalEquipment
})
}).FirstOrDefault();
//The.find(...) returns an entity based on...ID
//DTO
foreach (var remove in removeList.deleteSet)
{
//I not sure if this returns or mods anything
//ii._RentalEquipmentTable.Available = true;
//better way... not this, but use above query
// ...== ii._RentalEquipmentTable.RentalEquipmentID)... id the equipment
//RentalEquipment updatedEquipment = context.RentalEquipments
// .Where(x => (x.RentalEquipmentID == ii._RentalEquipmentTable.RentalEquipmentID)).FirstOrDefault();
RentalEquipment updatedEquipment = remove._RentalEquipmentTable;
updatedEquipment.Available = true;
context.Entry(updatedEquipment).State = EntityState.Modified; //Update Equipment ....Available = true; aka returned
RentalDetail deletedRentalDetail = remove._RentalDetailTable;
context.Entry(deletedRentalDetail).State = EntityState.Deleted; //Delete RentalDetails
}
//Delete Rental
context.Entry(rental).State = EntityState.Deleted;
}
//Commit Transaction
context.SaveChanges();
}
}
public void UpdateRentalTotals(int rentalID)
{
using (var context = new eToolsContext())
{
RentalDetail detail = new RentalDetail();
//get the rental details and pull the prices out of it
Rental update = new Rental();
List <RentalDetail> rentalDetails = Get_RentalDetailsByRentalID(rentalID);
}
}//method
public IActionResult Update(RentalDetail rental)
{
var result = _rentaldetailService.UpdateToSystem(rental);
if (result.Success)
{
return(Ok(result));
}
return(BadRequest(result));
}
public IResult AddToSystem(RentalDetail rentalDetail)
{
//var result = _rentaldal.GetRentalDetails(r => r.CarId == rentalDetail.CarId && r.ReturnDate == null);
//if (result != null)
//{
// return new ErrorResult(Messages.RentalError);
//}
_rentaldal.Add(rentalDetail);
return(new SuccessResult(Messages.RentalAdded));
}
public static RentalDetail CreateRentalDetail(TestContext ctx, int bikeId, int rentalId, int rentalTypeId, DateTime startDate, DateTime endDate, int numberOfUnits)
{
RentalDetail rentalDetail = new RentalDetail();
rentalDetail.BikeId = bikeId;
rentalDetail.RentalId = rentalId;
rentalDetail.RentalTypeId = rentalTypeId;
rentalDetail.RentalType = ctx.RentalTypes.Where(x => x.RentalTypeId == rentalTypeId).FirstOrDefault();
rentalDetail.StartDate = startDate;
rentalDetail.EndDate = endDate;
rentalDetail.NumberOfUnits = numberOfUnits;
ctx.RentalDetails.Add(rentalDetail);
return(rentalDetail);
}
public void addRentalEquipment(int rentalId, int equitmentid)
{
using (var context = new eToolsContext())
{
//Checkout equipment
RentalEquipment checkoutEquipment = context.RentalEquipments
.Where(x => (x.RentalEquipmentID == equitmentid)).FirstOrDefault();
//Update
checkoutEquipment.Available = false;
//COMMIT UPDATE***
context.Entry(checkoutEquipment).State = EntityState.Modified;
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//create Rental Details
RentalDetail newRentalEquipment = new RentalDetail();
//Recived values
newRentalEquipment.RentalID = rentalId;
newRentalEquipment.RentalEquipmentID = equitmentid;
//unmutatble Values
newRentalEquipment.DailyRate = context.RentalEquipments
.Where(x => (x.RentalEquipmentID == equitmentid))
.Select(x => x.DailyRate).FirstOrDefault();
newRentalEquipment.ConditionOut = context.RentalEquipments
.Where(x => (x.RentalEquipmentID == equitmentid))
.Select(x => x.Condition).FirstOrDefault();
//Pending return
//Set to default values
newRentalEquipment.Days = 1; //bussiness rule!
newRentalEquipment.ConditionIn = "Has not been returned";
newRentalEquipment.DamageRepairCost = 0.0m;
newRentalEquipment.Comments = "";
//COMMIT ADD***
context.Entry(newRentalEquipment).State = EntityState.Added;
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//Finalize Transaction!
context.SaveChanges();
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
}
}
public IHttpActionResult Get(int id, int stuId)
{
IHttpActionResult ret = null;
RentalDetail rentalDetail = new RentalDetail();
rentalDetail = db.RentalDetails.SingleOrDefault(r => r.CallNumber == id && r.StudentId == stuId);
if (rentalDetail == null)
{
ret = NotFound();
}
else
{
ret = Ok(rentalDetail);
}
return(ret);
}
public IHttpActionResult Post(RentalDetail rentaldetail)
{
IHttpActionResult ret = null;
rentaldetail = db.RentalDetails.Add(rentaldetail);
db.SaveChanges();
if (rentaldetail != null)
{
ret = Created <RentalDetail>(Request.RequestUri +
rentaldetail.CallNumber.ToString() + rentaldetail.StudentId.ToString(), rentaldetail);
}
else
{
ret = NotFound();
}
return(ret);
}
public void Add_RentalDetail_toRental(Rental record, int rentalequipmentid)
{
List <string> reasons = new List <string>();
using (var context = new eToolsContext())
{
Rental exists = context.Rentals
.Where(x => x.CustomerID.Equals(record.CustomerID) && x.EmployeeID.Equals(record.EmployeeID) && x.RentalDate == record.RentalDate)
.Select(x => x).FirstOrDefault();
RentalDetail newRentalDetailRecord = null;
newRentalDetailRecord.RentalEquipmentID = rentalequipmentid;
exists.RentalDetails.Add(newRentalDetailRecord);
context.SaveChanges();
}
}
public void Cancel_Rental(int rentalID)
{
using (var context = new eToolsContext())
{
//remove the details then the rental
var exists = (from x in context.Rentals
where x.RentalID.Equals(rentalID)
select x).FirstOrDefault();
if (exists != null)
{
var detailExists = (from x in context.RentalDetails
where x.RentalID.Equals(rentalID)
select x).FirstOrDefault();
if (detailExists != null)
{
//delete all details
RentalDetail detail = null;
List <int> detailsIDs = (from x in context.RentalDetails
where x.RentalID.Equals(rentalID)
select x.RentalDetailID).ToList();
foreach (var detailstoDelet in detailsIDs)
{
detail = exists.RentalDetails.
Where(x => x.RentalID == rentalID).
FirstOrDefault();
if (detail != null)
{
exists.RentalDetails.Remove(detail);
}
}
}
var rentaltoremove = (from x in context.Employees
where x.Rentals.Equals(rentalID)
select x).FirstOrDefault();
rentaltoremove.Rentals.Remove(exists);
}
context.SaveChanges();
}
}
public IHttpActionResult Put(int id, int stuId,
RentalDetail rentaldetail)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != rentaldetail.CallNumber && stuId != rentaldetail.StudentId)
{
return(BadRequest());
}
db.Entry(rentaldetail).State = EntityState.Modified;
try
{
db.SaveChanges();
}
catch (DbUpdateConcurrencyException)
{
return(NotFound());
}
return(StatusCode(HttpStatusCode.NoContent));
}
/// <summary>
/// Rent function
/// </summary>
/// <param name="member">member</param>
/// <param name="vehicle"vehicle></param>
/// <param name="days">dayys</param>
/// <returns>detail</returns>
public RentalDetail Rent(Member member, Vehicle vehicle, int days)
{
if (vehicle.Available)
{
//check for expiry membership
var sd = member.StartDate;
var ed = 0;
switch (member.Membership)
{
case Membership.NonMember:
throw new Exception("Membership is not valid.");
case Membership.Silver:
ed = 180;
break;
case Membership.Gold:
ed = 360;
break;
case Membership.Platinum:
ed = 360;
break;
}
var expiryDate = sd.AddDays(ed);
if (expiryDate > DateTime.Now)
{
//check return date
var today = DateTime.Now;
var rd = today.AddDays(days);
if (expiryDate > rd)
{
RentalDetail d = new RentalDetail();
d.Member = member;
d.Vehicle = vehicle;
d.StartDate = DateTime.Now;
d.EndDate = d.StartDate.AddDays(days);
if (member.Membership == Membership.Silver)
{
d.Price = CalculatePriceSilver(d.Vehicle, days);
}
else if (member.Membership == Membership.Gold)
{
d.Price = CalculatePriceGold(d.Vehicle, days);
}
else if (member.Membership == Membership.Platinum)
{
d.Price = CalculatePricePlatimun(d.Vehicle, days);
}
else
{
throw new Exception("Membership is not valid.");
}
vehicle.Available = false;
return(d);
}
else
{
throw new Exception("Membership is going to be expired when returning vehicle. Please renew your membership.");
}
}
else
{
throw new Exception("Membership is already expired.");
}
}
else
{
throw new Exception("Vehicle is not available.");
}
}
public IResult UpdateToSystem(RentalDetail rentalDetail)
{
_rentaldal.Update(rentalDetail);
return(new SuccessResult(Messages.RentalDetailUpdated));
}
public async Task <IActionResult> Checkout(string Discount = null)
{
List <CartViewModel> lstCart = HttpContext.Session.Get <List <CartViewModel> >("ShoppingCartSession");
List <CartViewModel> lstCart2 = HttpContext.Session.Get <List <CartViewModel> >("ShoppingCartSession2");
List <CartViewModel> cartViewModels = new List <CartViewModel>();
List <CartViewModel> cartViewModels1 = new List <CartViewModel>();
foreach (var product in lstCart)
{
var studio = await _db.Studios.Where(u => u.ID == product.Game.StudioID).FirstOrDefaultAsync();
product.Studio = studio;
cartViewModels.Add(product);
}
foreach (var product in lstCart2)
{
var studio = await _db.Studios.Where(u => u.ID == product.Game.StudioID).FirstOrDefaultAsync();
product.Studio = studio;
cartViewModels1.Add(product);
}
SuperCartViewModel cartViewModel = new SuperCartViewModel()
{
CartVM1 = cartViewModels,
CartVM2 = cartViewModels1
};
var user = await _db.ApplicationUsers.Where(u => u.Email == User.Identity.Name).FirstOrDefaultAsync();
var sum1 = lstCart.Sum(u => u.Amount * u.Game.Price);
var sum2 = lstCart.Sum(u => u.Amount * (u.Game.Price * 0.1));
if (user.Balance >= (sum1 + sum2))
{
Order order = new Order()
{
ApplicationUserID = user.Id,
Total = sum1,
PurchasedDate = DateTime.Now,
};
_db.Add(order);
_db.SaveChanges();
foreach (var product in lstCart)
{
var code = await _db.Codes.Where(u => u.GameID == product.Game.ID && u.Available == true).FirstOrDefaultAsync();
code.Available = false;
var game = await _db.Games.Where(u => u.ID == product.Game.ID).FirstOrDefaultAsync();
game.AvailableCode -= 1;
OrderDetail orderDetail = new OrderDetail()
{
OrderID = order.ID,
CodeID = code.ID
};
_db.Add(orderDetail);
_db.SaveChanges();
}
RentalHistory rentalHistory = new RentalHistory()
{
ApplicationUserID = user.Id,
Total = sum2
};
_db.Add(rentalHistory);
_db.SaveChanges();
foreach (var product in lstCart2)
{
var gameAccount = await _db.GameAccounts.Where(u => u.GameID == product.Game.ID && u.Available == true).FirstOrDefaultAsync();
gameAccount.Available = false;
var game = await _db.Games.Where(u => u.ID == product.Game.ID).FirstOrDefaultAsync();
game.AvailableAccount -= 1;
RentalDetail rentalDetail = new RentalDetail()
{
RentalHistoryID = rentalHistory.ID,
GameAccountID = gameAccount.ID,
StartDate = DateTime.Now,
EndDate = DateTime.Now.AddHours(product.Amount),
OnGoing = true
};
_db.Add(rentalDetail);
_db.SaveChanges();
}
user.Balance -= (sum1 + sum2);
await _db.SaveChangesAsync();
}
cartViewModel.Total = sum1 + sum2;
return(View(cartViewModel));
}
