public DataTable GetBookigsForSecurity(ParkingLot parkingLot, DateTime initialHour)
{
DataTable dataTable = new DataTable();
try
{
//open database connection
SqlConnection connection = ManageDatabaseConnection("Open");
SqlCommand sqlCommand = new SqlCommand("Get_BookingsForSecurity", connection);
sqlCommand.CommandType = CommandType.StoredProcedure;
using (SqlDataAdapter sqlDataAdapter = new SqlDataAdapter())
{
sqlDataAdapter.SelectCommand = sqlCommand;
sqlCommand.Parameters.AddWithValue("@IdParking", parkingLot.Id);
sqlCommand.Parameters.AddWithValue("@InitialHour", initialHour);
sqlDataAdapter.Fill(dataTable);
}
ManageDatabaseConnection("Close");
}
catch (SqlException sqlException)
{
throw sqlException;
}
return dataTable;
}
public ParkingLot GetDimensions(ParkingLot parkingToTable)
{
ParkingLotData parkingLotData = new ParkingLotData();
parkingToTable = parkingLotData.GetParkingTable(parkingToTable);
return parkingToTable;
}
public ParkingLot GetParkingTable(ParkingLot parkingToTable)
{
try
{
using (SqlCommand sqlCommand = new SqlCommand("Get_ParkingDimension", ManageDatabaseConnection("Open")))
{
sqlCommand.CommandType = CommandType.StoredProcedure;
sqlCommand.Parameters.AddWithValue("@Id", parkingToTable.Id);
using (SqlDataReader sqlReader = sqlCommand.ExecuteReader())
{
if (sqlReader.Read())
{
parkingToTable.DimensionX = (int)sqlReader["DimensionX"];
parkingToTable.DimensionY = (int)sqlReader["DimensionY"];
}
}
}
ManageDatabaseConnection("Close");
}
catch (SqlException sqlException)
{
throw sqlException;
}
return parkingToTable;
}
public int DeleteParking(ParkingLot parkingToDelete)
{
ParkingLotData parkingLotData = new ParkingLotData();
int insertResult = parkingLotData.Delete(parkingToDelete);
return insertResult;
}
public int AddParking(ParkingLot parkingToAdd)
{
ParkingLotData parkingLotData = new ParkingLotData();
int insertResult = parkingLotData.Insert(parkingToAdd);
return insertResult;
}
void should_park_the_car_in_the_first_parking_lot_when_the_first_one_is_not_full()
{
var firstParkingLot = new ParkingLot(1);
var secondParkingLot = new ParkingLot(1);
var parkingBoy = new ParkingBoy(new List <ParkingLot> {
firstParkingLot, secondParkingLot
});
const string carId = "ABC123";
var car = new Car(carId);
parkingBoy.Park(car);
Car pickedCar = firstParkingLot.Pick(carId);
Assert.Same(car, pickedCar);
}
// Update is called once per frame
void Update()
{
bool highlightedNode = false;
foreach (NodeScript node in parkingLots)
{
if (node.GetHighlighted())
{
highlightedNode = node.GetHighlighted();
currentLot = node.GetComponentInParent <ParkingLot>();
break;
}
}
panel.SetActive(highlightedNode);
}
public void should_park_car_to_A_when_parking_bot_to_parking_car_with_bot_manage_A_and_B_without_C()
{
var parkingLots = new List <ParkingLot>();
var parkingLotA = new ParkingLot(20);
var parkingLotB = new ParkingLot(20);
var parkingLotC = new ParkingLot(20);
parkingLots.Add(parkingLotA);
parkingLots.Add(parkingLotB);
var parkingBot = new ParkingBot(parkingLots);
parkingBot.Park(new Car());
Assert.Single(parkingLotA.ticketToCars);
}
private void Run()
{
var parkingLot = new ParkingLot();
var random = new Random();
while (true)
{
foreach (var car in testCars)
{
var actor = new Actor(parkingLot, car, random.Next(2000, 9000));
var thread = new Thread(actor.Run);
thread.Start();
Thread.Sleep(1500);
}
}
}
public async Task Story1_AC5_Should_update_parkingLot_capacity()
{
// given
var parkingLot = new ParkingLot("Lot1", 10, "location1");
var updateModel = new ParkingLotUpdateModel(20);
// when
var name = await service.AddParkingLot(parkingLot);
await service.UpdateParkingLot(name, updateModel);
var lot = await service.GetParkingLotByName(name);
// then
Assert.Equal(updateModel.Capacity, lot.Capacity);
}
public void should_not_park_a_car_into_a_parking_lot_which_has_no_space()
{
var parkingBot = new ParkingLot(_capacity);
for (var i = 0; i < 20; i++)
{
parkingBot.Park(new Car());
}
var list = new List <ParkingLot> {
parkingBot
};
var parkingBoy = new ParkingBoy(list);
Assert.Throws <Exception>(() => parkingBoy.Park(new Car()));
}
public void should_keep_order_when_make_park_boy_park_a_car_given_boy_own_two_parking_lot_first_parking_lot_has_two_spaces()
{
var firsLot = new ParkingLot(2);
var secondLot = new ParkingLot(0);
var lots = new List <ParkingLot>
{
firsLot, secondLot
};
var boy = new ParkingBoy(lots);
boy.Park(new Car());
boy.Park(new Car());
Assert.Equal(2, firsLot.CurrentCount());
Assert.Equal(0, secondLot.CurrentCount());
}
public void ErrorMessage_Should_be_provided_When_no_ticket_is_given()
{
//given
var parkingLot = new ParkingLot();
var parkingBoy = new ParkingBoy();
//when
var numberPlate = "XX2345";
var parkingTicket = parkingBoy.Park(numberPlate, parkingLot);
parkingBoy.Fetch(null, parkingLot);
var actual = parkingBoy.ErrorMessage;
var expect = "Please provide your parking ticket.";
//then
Assert.Equal(expect, actual);
}
public void should_park_car_to_parking_lot_with_higher_free_rate()
{
var lowerFreeRateParkingLot = new ParkingLot(2);
lowerFreeRateParkingLot.Park(new Car());
var higherFreeRateParkingLot = new ParkingLot(2);
var superParkingBoy = new SuperParkingBoy(new List <ParkingLot> {
lowerFreeRateParkingLot, higherFreeRateParkingLot
});
var car = new Car();
var ticket = superParkingBoy.Park(car);
Assert.Null(lowerFreeRateParkingLot.Pick(ticket));
Assert.Equal(car, higherFreeRateParkingLot.Pick(ticket));
}
public bool Remove(int id)
{
bool parkingLotExists = _unitOfWork.ParkingLotRepository.ParkingLotExists(id);
if (parkingLotExists)
{
ParkingLot model = _unitOfWork.ParkingLotRepository.Get(id);
_unitOfWork.ParkingLotRepository.Remove(model);
_unitOfWork.SaveChanges();
return(true);
}
return(false);
}
private static void ManageParking(int vehicleNumber, ref ParkingLot parkingLot)
{
if (vehicleNumber == 1)
{
Motorcycle objMotorcycle = new Motorcycle();
objMotorcycle.ManageParking(ref parkingLot);
WriteOutput(objMotorcycle.IsParkingAvailable, Convert.ToString(objMotorcycle.VehicleName), objMotorcycle.VehicleParkingInformation);
}
else if (vehicleNumber == 2)
{
}
else if (vehicleNumber == 3)
{
}
}
public void should_return_ticket_when_let_boy_to_parking_car_with_manager_parking_lot_A_and_B_order_A_first()
{
var parkingLots = new List <ParkingLot>();
var parkingLotA = new ParkingLot(parkingSize);
var parkingLotB = new ParkingLot(parkingSize);
parkingLots.Add(parkingLotA);
parkingLots.Add(parkingLotB);
var packingBoy = new ParkingBoy(parkingLots);
var ticket = packingBoy.Park(_car);
Assert.NotNull(ticket);
Assert.Single(parkingLotA.ticketToCars);
Assert.Empty(parkingLotB.ticketToCars);
}
public void should_get_message_when_parking_boy_to_get_car_with_a_invalid_ticket_with_A_and_B_parking()
{
var parkingLots = new List <ParkingLot>();
var parkingLotA = new ParkingLot(parkingSize);
var parkingLotB = new ParkingLot(parkingSize);
parkingLots.Add(parkingLotA);
parkingLots.Add(parkingLotB);
var packingBoy = new ParkingBoy(parkingLots);
var invalidTicket = new object();
var exception = Assert.Throws <Exception>(() => { packingBoy.GetCar(invalidTicket); });
Assert.Equal("Invalid ticket!", exception.Message);
}
public void should_get_ticket_when_parking_boy_to_parking_car_and_A_and_B_is_manager_and_C_not_manager()
{
var parkingLots = new List <ParkingLot>();
var parkingLotA = new ParkingLot(parkingSize);
var parkingLotB = new ParkingLot(parkingSize);
parkingLots.Add(parkingLotA);
parkingLots.Add(parkingLotB);
var parkingLotNotManager = new ParkingLot(parkingSize);
var packingBoy = new ParkingBoy(parkingLots);
var ticket = packingBoy.Park(_car);
Assert.NotNull(ticket);
Assert.Single(parkingLotA.ticketToCars);
Assert.Empty(parkingLotNotManager.ticketToCars);
}
public void GetRegistrationNumbersFromColor_Success(string color)
{
ParkingLot lot = new ParkingLot(2);
int num1 = lot.Park(new Car {
Color = "White", RegistrationNumber = "KA-01-HH-1234"
});
int num2 = lot.Park(new Car {
Color = "White", RegistrationNumber = "KA-01-HH-9999"
});
var response = lot.GetRegistrationNumbers(color);
Assert.Equal(new List <string> {
"KA-01-HH-1234", "KA-01-HH-9999"
}, response);
}
public void ParkingLot_Should_Throw_GetFlor_If_Not_In_Range()
{
//arrange
int floorsCount = 3;
int width = 4;
int height = 5;
var parkingLot = new ParkingLot(floorsCount, width, height);
//act
Action actHigher = () => parkingLot.GetFloor(floorsCount);
Action actLower = () => parkingLot.GetFloor(-1);
//assert
actHigher.ShouldThrow <ArgumentOutOfRangeException>();
actLower.ShouldThrow <ArgumentOutOfRangeException>();
}
public void ErrorMessage_Should_be_provided_When_wrong_ticket_is_given()
{
//given
var parkingLot = new ParkingLot();
var parkingBoy = new ParkingBoy();
//when
var numberPlate = "XX2345";
var parkingTicket = parkingBoy.Park(numberPlate, parkingLot);
parkingBoy.Fetch("111111", parkingLot);
var actual = parkingBoy.ErrorMessage;
var expect = "Unrecognized parking ticket";
//then
Assert.Equal(expect, actual);
}
public void Should_Park_The_Car_To_Mutiple_Parking_Lots_Sequentially()
{
//given
var parkingLot1 = new ParkingLot(1);
var parkingBoy = new ParkingBoy(new List <ParkingLot>()
{
parkingLot1, new ParkingLot(2)
});
//when
var ticket = parkingBoy.Park(new Car("car"), out _);
//then
Assert.Contains(ticket.TicketNumber, parkingLot1.Tickets);
}
public void CalculateParkingFee_ShouldBeZero()
{
List <IParkingSpace> parkingSpaces = new List <IParkingSpace>();
parkingSpaces.Add(new ParkingSpace());
parkingSpaces.Add(new ParkingSpace());
parkingSpaces.Add(new ParkingSpace());
List <IParkingFee> parkingFees = new List <IParkingFee>();
parkingFees.Add(new ParkingFee(2, 4, 5));
IParkingLot sut = new ParkingLot(parkingSpaces, parkingFees);
ParkingSlip parkingSlip = new ParkingSlip(DateTime.UtcNow.AddHours(-1));
parkingSlip.SetExitDateTime(DateTime.UtcNow);
Assert.That(sut.CalculateParkingFee(parkingSlip).GetCost(), Is.EqualTo(0));
}
public void GetAvailableParkingSpaces_ShouldBeThree()
{
List <IParkingSpace> parkingSpaces = new List <IParkingSpace>();
parkingSpaces.Add(new ParkingSpace());
parkingSpaces.Add(new ParkingSpace());
parkingSpaces.Add(new ParkingSpace());
List <IParkingFee> parkingFees = new List <IParkingFee>();
parkingFees.Add(new ParkingFee(0, 2, 5));
parkingFees.Add(new ParkingFee(2, 10, 10));
parkingFees.Add(new ParkingFee(10, Double.MaxValue, 15));
IParkingLot sut = new ParkingLot(parkingSpaces, parkingFees);
Assert.That(sut.GetAvailableParkingSpaces().Count, Is.EqualTo(3));
}
public string UpdateParking(ParkingLot parkingToUpdate)
{
ParkingLotData parkingLotData = new ParkingLotData();
int insertResult = parkingLotData.Update(parkingToUpdate);
string failuretext = null;
if (insertResult != 0)
{
failuretext = "No se pudo actualizar";
}
else
{
failuretext = "Se actualizo de manera exitosa";
}
return failuretext;
}
public void 剩余车位量_取一辆车()
{
//given
var p = new ParkingLot();
var car = new Car();
p.DepositCar(car);
var capacity = p.Capacity;
//when
p.WithDrawCar(car);
//then
var lastestCapacity = p.Capacity;
Assert.Equal(capacity + 1, lastestCapacity);
}
public async Task Story1_AC4_Should_get_parkingLot_by_id()
{
// given
var parkingLot1 = new ParkingLot("Lot1", 10, "location1");
var parkingLot2 = new ParkingLot("Lot2", 10, "location1");
// when
await service.AddParkingLot(parkingLot1);
var name = await service.AddParkingLot(parkingLot2);
var lot = service.GetParkingLotByName(name);
// then
Assert.Equal(parkingLot2, lot.Result);
}
void should_throw_error_when_give_parking_boy_used_ticket_parked_by_driver()
{
var parkingLot = new ParkingLot(parkingLotSize);
var parkingBoy = new ParkingBoy(new List <ParkingLot>
{
parkingLot
});
var car = new Car();
var ticket = parkingLot.Park(car);
Assert.NotNull(ticket);
Assert.NotNull(parkingLot.GetCar(ticket));
var error = Assert.Throws <Exception>(() => parkingBoy.GetCar(ticket));
Assert.Equal("Invalid ticket!", error.Message);
}
void should_park_a_car_to_second_parking_lot_when_the_second_one_has_more_parking_space()
{
var firstParkingLot = new ParkingLot(4);
var secondParkingLot = new ParkingLot(4);
var smartParkingBoy = new SmartParkingBoy(new List <ParkingLot> {
firstParkingLot, secondParkingLot
});
firstParkingLot.Park(new Car("notcare"));
const string carId = "123";
var car = new Car(carId);
smartParkingBoy.Park(car);
Assert.Same(car, secondParkingLot.Pick(carId));
}
public ParkingLotDTO_Return FromParkingLotToParkingLotDTOReturn(ParkingLot parkingLot)
{
ParkingLotDTO_Return parkingLotDTOReturn = new ParkingLotDTO_Return
{
ParkingLotID = parkingLot.ParkingLotID,
Buildingtype = parkingLot.BuildingType,
Capacity = parkingLot.Capacity,
ContactPerson = _contactPersonMapper.FromContactPersonTOContactPersonDTO(parkingLot.ContactPerson),
DivisionID = parkingLot.DivisionID,
Name = parkingLot.Name,
PricePerHour = parkingLot.PricePerHour,
Address = _adressMappers.AddressToDTO(parkingLot.Address)
};
return(parkingLotDTOReturn);
}
public void Normal_ParkingBoy_Should_Fetch_Null_Given_Used_Ticket()
{
//given
var car = new Car("car_1");
var newCustomer = new Customer("customer_1", car);
var parkingLot = new ParkingLot("parkingLot_1", 3);
var parkingBoy = new NormalParkingBoy("parkingBoy_1", parkingLot);
//when
newCustomer.PassCarToParkingBoy(parkingBoy);
newCustomer.FetchCarFromParkingBoy(parkingBoy, newCustomer.GetTicket(0));
var secondFetchResult = newCustomer.FetchCarFromParkingBoy(parkingBoy, newCustomer.GetTicket(0));
//then
Assert.Null(secondFetchResult);
}
public void should_park_successfully_when_one_parking_lot_is_full_but_another_is_not_full()
{
var oneParkingLot = new ParkingLotBuilder()
.WithCapacity(1)
.WithOccupiedParkingSpace(1)
.Create();
var anotherParkingLot = new ParkingLot(1);
var parkingBoy = new ParkingBoy(oneParkingLot, anotherParkingLot);
var car = new Car();
var token = parkingBoy.Park(car);
var pickedCar = anotherParkingLot.Pick(token);
pickedCar.Should().BeSameAs(car);
}
public void Clever_ParkingBoy_Should_Return_Null_Given_No_Ticket_Or_Wrong_Ticket()
{
//given
var car = new Car("car_1");
var newCustomer = new Customer("customer_1", car);
var parkingLot = new ParkingLot("parkingLot_1", 3);
var parkingBoy = new CleverParkingBoy("parkingBoy_1", parkingLot);
//when
newCustomer.PassCarToParkingBoy(parkingBoy);
var resultOfNoTicket = parkingBoy.FetchCar(null, out _);
var resultOfWrongTicket = parkingBoy.FetchCar(new ParkingTicket("another_parkingBoy", "new_Car", "new_Customer", "another_ParkingLot"), out _);
//then
Assert.Null(resultOfNoTicket);
Assert.Null(resultOfWrongTicket);
}
public void Clever_ParkingBoy_Should_Return_NullTicket_When_Over_Capacity()
{
//given
var car_1 = new Car("car_1");
var newCustomer_1 = new Customer("customer_1", car_1);
var car_2 = new Car("car_2");
var newCustomer_2 = new Customer("customer_2", car_2);
var parkingLot = new ParkingLot("parkingLot_1", 1);
var parkingBoy = new CleverParkingBoy("parkingBoy_1", parkingLot);
//when
newCustomer_1.PassCarToParkingBoy(parkingBoy);
newCustomer_2.PassCarToParkingBoy(parkingBoy);
//then
Assert.Null(newCustomer_2.GetTicket(0));
}
public ActionResult DeleteConfirmed(int id)
{
ParkingLot parkingLot = db.ParkingLots.Find(id);
db.ParkingLots.Remove(parkingLot);
try
{
db.SaveChanges();
return(RedirectToAction("Index"));
}
catch (System.Data.Entity.Infrastructure.DbUpdateException)
{
TempData["Error"] = " You must delete reservation first!";
}
return(RedirectToAction("ReservationException"));
}
public int Delete(ParkingLot newParkingLot)
{
int insertResult = 0;
try
{
using (SqlCommand sqlCommand = new SqlCommand("Delete_ParkingLot", ManageDatabaseConnection("Open")))
{
sqlCommand.CommandType = CommandType.StoredProcedure;
sqlCommand.Parameters.AddWithValue("@Name", newParkingLot.Name);
sqlCommand.ExecuteNonQuery();
}
ManageDatabaseConnection("Close");
}
catch (SqlException sqlException)
{
throw sqlException;
}
return insertResult;
}
public Table VerifySpots(ParkingLot parkingTable, Table bookingTable, DateTime lowerLimit, DateTime upperLimit)
{
BookingData bookingData = new BookingData();
return bookingData.VerifyReserve(parkingTable, bookingTable, lowerLimit, upperLimit);
}
public DataTable GetReportForSecurity(ParkingLot parkingLot, DateTime initialHour)
{
BookingData bookingData = new BookingData();
return bookingData.GetBookigsForSecurity(parkingLot, initialHour);
}
protected void btnBookingSpot_Click(object sender, EventArgs e)
{
Booking newBooking = new Booking();
BookingBusiness bookingBusiness = new BookingBusiness();
ParkingBusiness parkingBusiness = new ParkingBusiness();
User currentUser = (User)Session["USER"];
Vehicle bookingVehicle = new Vehicle();
ParkingSpot bookingSpot = new ParkingSpot();
ParkingLot bookingParking = new ParkingLot();
bookingSpot.IdParking = Int32.Parse(DropDownListParking.SelectedValue);
bookingSpot = parkingBusiness.GetSpotForReserve(bookingSpot, (int)Session["Position"]);
newBooking.IdVehicle = bookingVehicle;
bookingParking.Name = DropDownListParking.SelectedItem.Text;
newBooking.IdUser = currentUser;
newBooking.IdParkingSpot = bookingSpot;
newBooking.IdParkingLot = bookingParking;
newBooking.EntryTime = DateTime.Parse(DropDownListInitialHour.SelectedValue);
newBooking.ExitTime = DateTime.Parse(DropDownListFinalHour.SelectedValue);
newBooking.IdVehicle.Id = DropDownListVehicleFormUser.SelectedValue.Trim();
newBooking.Date = DateTime.Today;
newBooking.IdParkingSpot.Id = bookingSpot.Id;
newBooking.IdParkingLot.Id = Int32.Parse(DropDownListParking.SelectedValue);
if (bookingSpot.Id == 0)
{
}
else
{
bookingBusiness.InsertBooking(newBooking);
Session["BOOKING"] = newBooking;
bookingParking = parkingBusiness.GetDimensions(bookingParking);
selectedPosition = -1;
bookingParking = removeSelected(Int32.Parse(DropDownListParking.SelectedValue));
Session["BOOKINGALERT"] = SendMail(newBooking);
TableDesignOfNewParking = bookingBusiness.VerifySpots(bookingParking, TableDesignOfNewParking, DateTime.Parse(DropDownListInitialHour.SelectedValue), DateTime.Parse(DropDownListFinalHour.SelectedValue));
Response.Redirect("bookingdone.aspx");
}
}
public int Insert(ParkingLot newParkingLot)
{
int insertResult = -1;
try
{
using (SqlCommand sqlCommand = new SqlCommand("Insert_Parkinglot", ManageDatabaseConnection("Open")))
{
sqlCommand.CommandType = CommandType.StoredProcedure;
sqlCommand.Parameters.AddWithValue("@Name", newParkingLot.Name);
sqlCommand.Parameters.AddWithValue("@Location", newParkingLot.Location);
sqlCommand.Parameters.AddWithValue("@DimensionX", newParkingLot.DimensionX);
sqlCommand.Parameters.AddWithValue("@DimensionY", newParkingLot.DimensionY);
insertResult = Convert.ToInt32(sqlCommand.ExecuteScalar());
}
ManageDatabaseConnection("Close");
}
catch (SqlException sqlException)
{
throw sqlException;
}
return insertResult;
}
public void FillTableDesignOfNewParking(int parkingName)
{
TableDesignOfNewParking.Rows.Clear();
ParkingBusiness parkingBusiness = new ParkingBusiness();
BookingBusiness bookingBusiness = new BookingBusiness();
ParkingLot parkingspotTable = new ParkingLot();
ParkingSpot parking = new ParkingSpot();
int counter = 0;
parkingspotTable.Id = parkingName;
parkingspotTable = parkingBusiness.GetDimensions(parkingspotTable);
TableDesignOfNewParking = parkingBusiness.GetSpotData(parkingspotTable, TableDesignOfNewParking);
for (int counterRow = 0; counterRow < parkingspotTable.DimensionX; counterRow++)
{
for (int counterColumn = 0; counterColumn < parkingspotTable.DimensionY; counterColumn++)
{
TableDesignOfNewParking.Rows[counterRow].Cells[counterColumn].Controls.Add(addButton(counter));
counter++;
}
}
TableDesignOfNewParking = bookingBusiness.VerifySpots(parkingspotTable, TableDesignOfNewParking, DateTime.Parse(DropDownListInitialHour.SelectedValue), DateTime.Parse(DropDownListFinalHour.SelectedValue));
for (int counterRow = 0; counterRow < parkingspotTable.DimensionX; counterRow++)
{
for (int counterColumn = 0; counterColumn < parkingspotTable.DimensionY; counterColumn++)
{
if (TableDesignOfNewParking.Rows[counterRow].Cells[counterColumn].BackColor == Color.Red)
{
TableDesignOfNewParking.Rows[counterRow].Cells[counterColumn].Enabled = true;
}
else
{
TableDesignOfNewParking.Rows[counterRow].Cells[counterColumn].Enabled = false;
}
}
}
}
public Table VerifyReserve(ParkingLot parkingTable, Table bookingTable, DateTime lowerLimit, DateTime upperLimit)
{
Booking bookingToVerify = new Booking();
ParkingSpot parkingSpot = new ParkingSpot();
parkingSpot.IdParking = parkingTable.Id;
bookingToVerify.IdParkingLot = parkingTable;
bookingToVerify.IdParkingSpot = parkingSpot;
try
{
string statement = "SELECT * FROM Booking WHERE IdParking = @ParkingId AND Validated = @Validated";
using (SqlCommand sqlCommand = new SqlCommand(statement, ManageDatabaseConnection("Open")))
{
sqlCommand.Parameters.AddWithValue("@ParkingId", bookingToVerify.IdParkingLot.Id);
sqlCommand.Parameters.AddWithValue("@Validated", true);
using (SqlDataReader reader = sqlCommand.ExecuteReader())
{
while (reader.Read())
{
bookingToVerify.IdParkingSpot.Id = (int)reader["IdParkingSpot"];
bookingToVerify.EntryTime = (DateTime)reader["EntryTime"];
bookingToVerify.ExitTime = (DateTime)reader["ExitTime"];
if (bookingToVerify.EntryTime >= lowerLimit && bookingToVerify.EntryTime < upperLimit || bookingToVerify.ExitTime > lowerLimit && bookingToVerify.ExitTime <= upperLimit || bookingToVerify.EntryTime <= lowerLimit && bookingToVerify.ExitTime >= upperLimit)
{
string secondStatement = "SELECT * FROM ParkingLotSpots WHERE Id = @SpotId";
using (SqlCommand sqlCommandSecond = new SqlCommand(secondStatement, ManageDatabaseConnection("Open")))
{
sqlCommandSecond.Parameters.AddWithValue("@SpotId", bookingToVerify.IdParkingSpot.Id);
using (SqlDataReader secondReader = sqlCommandSecond.ExecuteReader())
{
if (secondReader.Read())
{
bookingToVerify.IdParkingSpot.Position = (int)secondReader["Position"];
}
}
int counter = 0;
for (int counterRow = 0; counterRow < parkingTable.DimensionX; counterRow++)
{
for (int counterColumn = 0; counterColumn < parkingTable.DimensionY; counterColumn++)
{
if (bookingToVerify.IdParkingSpot.Position == counter)
{
bookingTable.Rows[counterRow].Cells[counterColumn].BackColor = Color.Red;
bookingTable.Rows[counterRow].Cells[counterColumn].Enabled = false;
}
counter++;
}
}
}
}
else
{
string secondStatement = "SELECT * FROM ParkingLotSpots WHERE Id = @SpotId";
using (SqlCommand sqlCommandSecond = new SqlCommand(secondStatement, ManageDatabaseConnection("Open")))
{
sqlCommandSecond.Parameters.AddWithValue("@SpotId", bookingToVerify.IdParkingSpot.Id);
using (SqlDataReader secondReader = sqlCommandSecond.ExecuteReader())
{
if (secondReader.Read())
{
bookingToVerify.IdParkingSpot.Position = (int)secondReader["Position"];
bookingToVerify.IdParkingSpot.SpotType = secondReader["Spottype"].ToString().Trim();
}
}
int counter = 0;
for (int counterRow = 0; counterRow < parkingTable.DimensionX; counterRow++)
{
for (int counterColumn = 0; counterColumn < parkingTable.DimensionY; counterColumn++)
{
if (bookingToVerify.IdParkingSpot.Position == counter)
{
if (bookingTable.Rows[counterRow].Cells[counterColumn].BackColor == Color.Red)
{
switch (parkingSpot.SpotType)
{
case "Normal Spot":
bookingTable.Rows[counterRow].Cells[counterColumn].Enabled = true;
bookingTable.Rows[counterRow].Cells[counterColumn].BackColor = Color.Transparent;
break;
case "Motorcycle Spot":
bookingTable.Rows[counterRow].Cells[counterColumn].Enabled = true;
bookingTable.Rows[counterRow].Cells[counterColumn].BackColor = Color.Yellow;
break;
}
}
}
counter++;
}
}
}
}
}
}
}
ManageDatabaseConnection("Close");
}
catch (SqlException sqlException)
{
throw sqlException;
}
return bookingTable;
}
public int VerifyParking(ParkingLot parkingToAdd)
{
ParkingLotData parkingLotData = new ParkingLotData();
int insertResult = parkingLotData.VerifyName(parkingToAdd);
return insertResult;
}
public void Insert(Table parkingToAddSpots, ParkingLot currentParking)
{
ParkingSpot parkingSpot = new ParkingSpot();
parkingSpot.IdParking = currentParking.Id;
try
{
string statement = "INSERT INTO dbo.ParkingLotSpots(ParkingId, Spottype, Position) VALUES(@IdParking, @Spottype, @Position)";
SqlCommand sqlCommand = new SqlCommand(statement, ManageDatabaseConnection("Open"));
{
int counter = 0;
sqlCommand.Parameters.Add("@Spottype", SqlDbType.NChar, 25);
sqlCommand.Parameters.Add("@IdParking", SqlDbType.Int);
sqlCommand.Parameters.Add("@Position", SqlDbType.Int);
for (int counterRow = 0; counterRow < currentParking.DimensionY; counterRow++)
{
for (int counterColumn = 0; counterColumn < currentParking.DimensionY; counterColumn++)
{
switch (parkingToAddSpots.Rows[counterRow].Cells[counterColumn].BackColor.Name)
{
case "Transparent":
parkingSpot.SpotType = "Normal Spot";
parkingSpot.Position = counter;
sqlCommand.Parameters["@Spottype"].Value= parkingSpot.SpotType;
sqlCommand.Parameters["@IdParking"].Value = parkingSpot.IdParking;
sqlCommand.Parameters["@Position"].Value = parkingSpot.Position;
break;
case "DarkGray":
parkingSpot.SpotType = "Road Spot";
parkingSpot.Position = counter;
sqlCommand.Parameters["@Spottype"].Value= parkingSpot.SpotType;
sqlCommand.Parameters["@IdParking"].Value = parkingSpot.IdParking;
sqlCommand.Parameters["@Position"].Value = parkingSpot.Position;
break;
case "Blue":
parkingSpot.SpotType = "Handicap Spot";
parkingSpot.Position = counter;
sqlCommand.Parameters["@Spottype"].Value= parkingSpot.SpotType;
sqlCommand.Parameters["@IdParking"].Value = parkingSpot.IdParking;
sqlCommand.Parameters["@Position"].Value = parkingSpot.Position;
break;
case "Yellow":
parkingSpot.SpotType = "Motorcycle Spot";
parkingSpot.Position = counter;
sqlCommand.Parameters["@Spottype"].Value= parkingSpot.SpotType;
sqlCommand.Parameters["@IdParking"].Value = parkingSpot.IdParking;
sqlCommand.Parameters["@Position"].Value = parkingSpot.Position;
break;
default:
parkingSpot.SpotType = "Normal Spot";
parkingSpot.Position = counter;
sqlCommand.Parameters["@Spottype"].Value= parkingSpot.SpotType;
sqlCommand.Parameters["@IdParking"].Value = parkingSpot.IdParking;
sqlCommand.Parameters["@Position"].Value = parkingSpot.Position;
break;
}
counter++;
sqlCommand.ExecuteNonQuery();
}
}
}
ManageDatabaseConnection("Close");
}
catch (SqlException sqlException)
{
throw sqlException;
}
}
protected void btnDelete_Click(object sender, EventArgs e)
{
ParkingLot parkingTable = new ParkingLot();
Button btn = (Button)sender;
int counter = 0;
selectedPosition = Int32.Parse(btn.ID);
Session["Position"] = selectedPosition;
parkingTable = removeSelected(Int32.Parse(DropDownListParking.SelectedValue));
for (int counterRow = 0; counterRow < parkingTable.DimensionX; counterRow++)
{
for (int counterColumn = 0; counterColumn < parkingTable.DimensionY; counterColumn++)
{
if (selectedPosition == counter)
{
Session["BackColor"] = TableDesignOfNewParking.Rows[counterRow].Cells[counterColumn].BackColor;
TableDesignOfNewParking.Rows[counterRow].Cells[counterColumn].BackColor = Color.Black;
}
counter++;
}
}
}
protected void btnDeleteReserve_Click(object sender, EventArgs e)
{
Booking newBooking = new Booking();
BookingBusiness bookingBusiness = new BookingBusiness();
ParkingBusiness parkingBusiness = new ParkingBusiness();
User currentUser = (User)Session["USER"];
Vehicle bookingVehicle = new Vehicle();
ParkingSpot bookingSpot = new ParkingSpot();
ParkingLot bookingParking = new ParkingLot();
bookingSpot.IdParking = Int32.Parse(DropDownListParking.SelectedValue);
bookingSpot = parkingBusiness.GetSpotForReserve(bookingSpot, (int)Session["Position"]);
newBooking.IdVehicle = bookingVehicle;
newBooking.IdUser = currentUser;
newBooking.IdParkingSpot = bookingSpot;
newBooking.IdParkingLot = bookingParking;
newBooking.EntryTime = DateTime.Parse(DropDownListInitialHour.SelectedValue);
newBooking.ExitTime = DateTime.Parse(DropDownListFinalHour.SelectedValue);
newBooking.IdVehicle.Id = DropDownListVehicleFormUser.SelectedValue.Trim();
newBooking.Date = DateTime.Today;
newBooking.IdParkingSpot.Id = bookingSpot.Id;
newBooking.IdParkingLot.Id = Int32.Parse(DropDownListParking.SelectedValue);
if (bookingSpot.Id == 0)
{
//Return error here
}
else
{
bookingBusiness.DenyBooking(newBooking, newBooking.EntryTime, newBooking.ExitTime);
bookingParking = parkingBusiness.GetDimensions(bookingParking);
selectedPosition = -1;
bookingParking = removeSelected(Int32.Parse(DropDownListParking.SelectedValue));
FillTableDesignOfNewParking(newBooking.IdParkingLot.Id);
}
}
public ParkingLot removeSelected(int parkingName)
{
ParkingLot parkingTable = new ParkingLot();
ParkingBusiness parkingBusiness = new ParkingBusiness();
parkingTable.Id = parkingName;
parkingTable = parkingBusiness.GetDimensions(parkingTable);
for (int counterRow = 0; counterRow < parkingTable.DimensionX; counterRow++)
{
for (int counterColumn = 0; counterColumn < parkingTable.DimensionY; counterColumn++)
{
if (TableDesignOfNewParking.Rows[counterRow].Cells[counterColumn].BackColor == Color.Green)
{
TableDesignOfNewParking.Rows[counterRow].Cells[counterColumn].BackColor = (Color)Session["BackColor"];
}
}
}
return parkingTable;
}
public void AddParkingSpot(Table parkingTable, ParkingLot currentParking)
{
ParkingSpotData parkingSpotData = new ParkingSpotData();
parkingSpotData.Insert(parkingTable, currentParking);
}
public Table GetSpotData(ParkingLot parkingLot, Table bookingTable)
{
ParkingSpotData parkingSpotData = new ParkingSpotData();
bookingTable = parkingSpotData.GetSpot(parkingLot, bookingTable);
return bookingTable;
}
public Table GetSpot(ParkingLot parkingTable, Table bookingTable)
{
ParkingSpot parkingSpot = new ParkingSpot();
parkingSpot.IdParking = parkingTable.Id;
try
{
string statement = "SELECT Id, Spottype FROM ParkingLotSpots WHERE ParkingId = @ParkingId AND Position = @Position";
using (SqlCommand sqlCommand = new SqlCommand(statement, ManageDatabaseConnection("Open")))
{
sqlCommand.Parameters.AddWithValue("@ParkingId", parkingSpot.IdParking);
sqlCommand.Parameters.Add("@Position", SqlDbType.Int);
int counter = 0;
for (int counterRow = 0; counterRow < parkingTable.DimensionX; counterRow++)
{
TableRow tableRow = new TableRow();
for (int counterColumn = 0; counterColumn < parkingTable.DimensionY; counterColumn++)
{
TableCell tableCell = new TableCell();
tableCell.CssClass = "btn-error";
parkingSpot.Position = counter;
sqlCommand.Parameters["@Position"].Value = parkingSpot.Position;
sqlCommand.ExecuteNonQuery();
using (SqlDataReader reader = sqlCommand.ExecuteReader())
{
if (reader.Read())
{
parkingSpot.Id = (int)reader["Id"];
parkingSpot.SpotType = reader["Spottype"].ToString().Trim();
}
}
switch (parkingSpot.SpotType)
{
case "Normal Spot":
tableCell.BackColor = Color.Transparent;
break;
case "Road Spot":
tableCell.BackColor = Color.DarkGray;
tableCell.Enabled = false;
break;
case "Handicap Spot":
tableCell.BackColor = Color.Blue;
tableCell.Enabled = false;
break;
case "Motorcycle Spot":
tableCell.BackColor = Color.Yellow;
break;
}
tableRow.Cells.Add(tableCell);
counter++;
}
bookingTable.Rows.Add(tableRow);
}
}
ManageDatabaseConnection("Close");
}
catch (SqlException sqlException)
{
throw sqlException;
}
return bookingTable;
}
