/// <summary>
/// Function For Unpark Api.
/// </summary>
/// <param name="VehicalNumber"></param>
/// <returns></returns>
public ParkingDetails Unpark(string VehicalNumber)
{
try
{
ParkingDetails vehicalExists = dBContext.ParkingDetails.Where <ParkingDetails>
(p => p.VehicalNumber.Equals(VehicalNumber)).FirstOrDefault();
if (vehicalExists != null)
{
if (vehicalExists.Status == "Parked")
{
vehicalExists.UnparkDate = DateTime.Now;
vehicalExists.TotalTime = vehicalExists.UnparkDate.Subtract(vehicalExists.ParkingDate).TotalHours;
double Amount = vehicalExists.TotalTime * RatePerHour;
vehicalExists.TotalAmount = Amount > RatePerHour ? Amount : RatePerHour;
vehicalExists.Status = "Unparked";
vehicalExists.ParkingSlot = null;
dBContext.SaveChanges();
return(vehicalExists);
}
else if (vehicalExists.Status == "Unparked")
{
vehicalExists.Status = "!Unparked";
}
return(vehicalExists);
}
else
{
return(vehicalExists = null);
}
}
catch (Exception exception)
{
throw exception;
}
}
/// <summary>
/// This method used for get details by vehicle type.
/// </summary>
/// <param name="vehicleType">Vehicle type.</param>
/// <returns>Parking details.</returns>
public List <ParkingDetails> GetDetailsByVehicleType(int vehicleType)
{
try
{
using (this.conn)
{
List <ParkingDetails> parkingData = new List <ParkingDetails>();
SqlCommand cmd = new SqlCommand("spGetVehicleByVehicleType", this.conn);
cmd.CommandType = CommandType.StoredProcedure;
cmd.Parameters.AddWithValue("@Vehicle_Type", vehicleType);
this.conn.Open();
SqlDataReader sqlDataReader = cmd.ExecuteReader();
if (sqlDataReader.HasRows)
{
while (sqlDataReader.Read())
{
ParkingDetails parkingDetails = new ParkingDetails();
parkingDetails = this.VehicleDetails(sqlDataReader);
parkingData.Add(parkingDetails);
}
this.conn.Close();
return(parkingData);
}
return(null);
}
}
catch (Exception e)
{
throw new Exception(e.Message);
}
}
/// <summary>
/// This method used for delete data from slot number.
/// </summary>
/// <param name="slotNumber">Slot number.</param>
/// <returns>Parking details.</returns>
public ParkingDetails DeleteDetailsBySlotNumber(int slotNumber)
{
try
{
using (this.conn)
{
ParkingDetails parkingDetails = new ParkingDetails();
SqlCommand cmd = new SqlCommand("spDeleteVehicleBySlotNumber", this.conn);
cmd.CommandType = CommandType.StoredProcedure;
cmd.Parameters.AddWithValue("@SlotNumber", slotNumber);
this.conn.Open();
SqlDataReader sqlDataReader = cmd.ExecuteReader();
if (sqlDataReader.HasRows)
{
while (sqlDataReader.Read())
{
parkingDetails = this.VehicleDetails(sqlDataReader);
}
this.conn.Close();
return(parkingDetails);
}
return(null);
}
}
catch (Exception e)
{
throw new Exception(e.Message);
}
}
public string PutParking(ParkingDetails p, int id)
{
try
{
var a = (from pd in es.Parking_Details where pd.Parking_ID == id select pd).SingleOrDefault();
if (p == null)
{
return("Invalid id");
}
else
{
a.Vechile_Number = p.Vechile_Number;
a.Visitor_ID = p.Visitor_ID;
var res = es.SaveChanges();
if (res > 0)
{
return("Data Updated");
}
}
return("Error in data Updating");
}
catch (Exception ex)
{
throw ex;
}
}
/// <summary>
/// This method used for get all parking vehicles data.
/// </summary>
/// <returns>All parking vehicles data.</returns>
public List <ParkingDetails> GetAllParkingVehiclesData()
{
try
{
using (this.conn)
{
List <ParkingDetails> parkingData = new List <ParkingDetails>();
SqlCommand cmd = new SqlCommand("spGetParkingVehiclesData", this.conn);
cmd.CommandType = CommandType.StoredProcedure;
this.conn.Open();
SqlDataReader sqlDataReader = cmd.ExecuteReader();
if (sqlDataReader.HasRows)
{
while (sqlDataReader.Read())
{
ParkingDetails parkingDetails = new ParkingDetails();
parkingDetails = this.VehicleDetails(sqlDataReader);
parkingData.Add(parkingDetails);
}
this.conn.Close();
return(parkingData);
}
return(null);
}
}
catch (Exception e)
{
throw new Exception(e.Message);
}
}
/// <summary>
/// database connection get specific parking details
/// </summary>
/// <param name="ParkingID">Get specific parking details</param>
/// <returns></returns>
public ParkingDetails GetspecificParkingDetails(int ParkingID)
{
try
{
ParkingDetails parking = new ParkingDetails();
SqlConnection connection = DatabaseConnection();
//for store procedure and connection to database
SqlCommand command = StoreProcedureConnection("spSpecificParkingDetails", connection);
command.Parameters.Add("@ParkingID", SqlDbType.Int).Value = ParkingID;
connection.Open();
//Read data from database
SqlDataReader Response = command.ExecuteReader();
while (Response.Read())
{
parking.ParkingID = Convert.ToInt32(Response["ParkingID"]);
parking.UserID = Convert.ToInt32(Response["UserID"]);
parking.VehicleOwnerAddress = Response["VehicleOwnerAddress"].ToString();
parking.VehicleNumber = Response["VehicleNumber"].ToString();
parking.VehicalBrand = Response["VehicalBrand"].ToString();
parking.VehicalColor = Response["VehicalColor"].ToString();
parking.ParkingSlot = Response["ParkingSlot"].ToString();
parking.ParkingUserCategory = Response["ParkingUserCategory"].ToString();
parking.ParkingStatus = Response["ParkingStatus"].ToString();
parking.Charges = Response["Charges"].ToString();
parking.EntryTime = Convert.ToDateTime(Response["EntryTime"]);
parking.ExitTime = Convert.ToDateTime(Response["ExitTime"]);
}
connection.Close();
return(parking);
}
catch (Exception e)
{
throw new Exception(e.Message);
}
}
private ParkResponse ParkedVehicleResponse(ParkingDetails parkingDetails)
{
try
{
ParkResponse responseData = new ParkResponse
{
ReceiptNumber = parkingDetails.ReceiptNumber,
OwnerName = parkingDetails.OwnerName,
VehicleNumber = parkingDetails.VehicleNumber,
VehicleBrand = parkingDetails.VehicleBrand,
Color = parkingDetails.Color,
Disability = parkingDetails.Disability,
AttendantName = parkingDetails.AttendantName,
ParkingDate = parkingDetails.ParkingDate,
ParkingSlot = parkingDetails.ParkingSlot
};
if (responseData != null)
{
return(responseData);
}
return(null);
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
private UnParkResponse UnParkedVehicleResponse(ParkingDetails unParkData, UnParkedDetails unParkedData)
{
try
{
UnParkResponse responseData = new UnParkResponse
{
ReceiptNumber = unParkData.ReceiptNumber,
OwnerName = unParkData.OwnerName,
VehicleNumber = unParkData.VehicleNumber,
VehicleBrand = unParkData.VehicleBrand,
Color = unParkData.Color,
IsParked = unParkData.IsParked,
Disability = unParkData.Disability,
AttendantName = unParkData.AttendantName,
ParkingDate = unParkData.ParkingDate,
UnParkedDate = unParkedData.UnParkedDate,
ParkingSlot = unParkData.ParkingSlot,
TotalTime = unParkedData.TotalTime,
TotalAmt = unParkedData.TotalAmt
};
if (responseData != null)
{
return(responseData);
}
return(null);
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
/// <summary>
/// This method used for park vehicle.
/// </summary>
/// <param name="parking">Parking object.</param>
/// <returns>Parking <see cref="object"/>.</returns>
public ParkingDetails ParkVehicle(Parking parking)
{
try
{
using (this.conn)
{
ParkingDetails parkingDetails = new ParkingDetails();
SqlCommand cmd = new SqlCommand("spPark", this.conn);
cmd.CommandType = CommandType.StoredProcedure;
cmd.Parameters.AddWithValue("@Slot_Number", parking.SlotNumber);
cmd.Parameters.AddWithValue("@Vehicle_Number", parking.VehicleNumber);
cmd.Parameters.AddWithValue("@Vehicle_Type", parking.VehicleType);
cmd.Parameters.AddWithValue("@Parking_Type", parking.ParkingType);
cmd.Parameters.AddWithValue("@Driver_Type", parking.DriverType);
this.conn.Open();
SqlDataReader sqlDataReader = cmd.ExecuteReader();
if (sqlDataReader.HasRows)
{
while (sqlDataReader.Read())
{
parkingDetails = this.VehicleDetails(sqlDataReader);
}
this.conn.Close();
return(parkingDetails);
}
return(null);
}
}
catch (Exception e)
{
throw new Exception(e.Message);
}
}
/// <summary>
/// Function For Parking Vehical.
/// </summary>
/// <param name="parkingDetails"></param>
/// <returns></returns>
public ParkingDetails Park(ParkingDetails parkingDetails)
{
try
{
//Checks If Vehical Is Already Parked.
var parkingDetailsExists = dBContext.ParkingDetails.Where <ParkingDetails>
(p => p.VehicalNumber.Equals(parkingDetails.VehicalNumber) && p.Brand.Equals(parkingDetails.Brand)).FirstOrDefault();
if (parkingDetailsExists == null)
{
//Assiging ParkingSlot
parkingDetails.ParkingSlot = AssignSlot(parkingDetails);
//Checking Which Parking Slot is Assigned.
if (parkingDetails.ParkingSlot == "A" || parkingDetails.ParkingSlot == "B" ||
parkingDetails.ParkingSlot == "C" || parkingDetails.ParkingSlot == "D")
{
//Setting Status and DateTime
parkingDetails.Status = "Parked";
parkingDetails.ParkingDate = DateTime.Now;
//Updating DataBase With The Data.
dBContext.ParkingDetails.Add(parkingDetails);
dBContext.SaveChanges();
}
return(parkingDetails);
}
else if (parkingDetailsExists.Status == "Unparked")
{
//Assiging ParkingSlot
parkingDetailsExists.ParkingSlot = AssignSlot(parkingDetails);
//Checking Which Parking Slot is Assigned.
if (parkingDetailsExists.ParkingSlot == "A" || parkingDetailsExists.ParkingSlot == "B" ||
parkingDetailsExists.ParkingSlot == "C" || parkingDetailsExists.ParkingSlot == "D")
{
//Setting Status and DateTime
parkingDetailsExists.Status = "Parked";
parkingDetailsExists.ParkingDate = DateTime.Now;
parkingDetailsExists.TotalTime = 0;
parkingDetailsExists.TotalAmount = 0;
parkingDetailsExists.DriverName = parkingDetails.DriverName;
//Updating DataBase With The Data.
//dBContext.ParkingDetails.Add(parkingDetails);
dBContext.SaveChanges();
}
return(parkingDetailsExists);
}
else
{
return(parkingDetailsExists = null);
}
}
catch (Exception exception)
{
throw exception;
}
}
public IActionResult Park([FromBody] ParkingDetails parkingDetails)
{
try
{
//Fetching Claim Form JWT.
var identity = HttpContext.User.Identity as ClaimsIdentity;
parkingDetails.DriverName = identity.Name;
//Throws Custom Exception If Fields are Null.
if (parkingDetails.VehicalOwnerName == null || parkingDetails.VehicalNumber == null ||
parkingDetails.Brand == null || parkingDetails.Color == null || parkingDetails.DriverName == null)
{
throw new Exception(ParkingLotExceptions.ExceptionType.NULL_FIELD_EXCEPTION.ToString());
}
//Throws Custom Exception If Fields are Empty.
if (parkingDetails.VehicalOwnerName == "" || parkingDetails.VehicalNumber == "" ||
parkingDetails.Brand == "" || parkingDetails.Color == "" || parkingDetails.DriverName == "")
{
throw new Exception(ParkingLotExceptions.ExceptionType.EMPTY_FIELD_EXCEPTION.ToString());
}
//Calling BL.
var parkResponse = this.parkingLotBL.Park(parkingDetails);
if (parkResponse != null && parkResponse.ParkingSlot != "Unavailable")
{
distributedCache.Remove("Vehicals");
//Sending Message To Azure Service Queue.
string message = "Hello " + Convert.ToString(parkResponse.VehicalOwnerName) +
" Your \n" + "Vehical " + parkResponse.Brand.ToString() + ", " +
"VehcialNumber: " + parkResponse.VehicalNumber.ToString()
+ " \nParked In " + Convert.ToString(parkResponse.ParkingSlot) +
" Slot \nBy " + Convert.ToString(parkResponse.DriverName) +
"\nAt " + parkResponse.ParkingDate.Date.ToString("d") + " & "
+ parkResponse.ParkingDate.ToString("hh:mm tt");
sender.Send(message, "Parking", parkResponse.VehicalOwnerEmail);
//Sending Response.
return(Ok(new { Success = true, Message = "Vehical Parked", Data = parkResponse }));
}
else if (parkResponse == null)
{
return(Conflict(new { Success = false, Message = "Vehical Is Already Parked" }));
}
else
{
return(NotFound(new { Success = false, Message = "Lot Is Full" }));
}
}
catch (Exception exception)
{
return(BadRequest(new { Success = false, Message = exception.Message }));
}
}
/// <summary>
/// Function For Parking Vehical.
/// </summary>
/// <param name="parkingDetails"></param>
/// <returns></returns>
public ParkingDetails Park(ParkingDetails parkingDetails)
{
try
{
return(this.parkingLotRL.Park(parkingDetails));
}
catch (Exception exception)
{
throw exception;
}
}
/// <summary>
/// This method used for for parking new vehicle in parking lot.
/// </summary>
/// <param name="parking">Parking data.</param>
/// <returns>Boolean result.</returns>
public ParkingDetails ParkVehicle(Parking parking)
{
ParkingDetails parkingDetails = this.parkingRepository.ParkVehicle(parking);
if (parkingDetails != null)
{
this.mSMQService.SendDataToQueue("Parked vehicle number: " + parkingDetails.VehicleNumber + " At time: "
+ parkingDetails.EntryTime + " Parking id:" + parkingDetails.ParkingId);
}
return(parkingDetails);
}
/// <summary>
/// This method used for for unpark in parking lot.
/// </summary>
/// <param name="slotNumber">Slot Number.</param>
/// <returns>Boolean result.</returns>
public ParkingDetails UnParkVehicle(int slotNumber)
{
ParkingDetails parkingDetails = this.parkingRepository.UnParkVehicle(slotNumber);
if (parkingDetails != null)
{
this.mSMQService.SendDataToQueue("UnParked vehicle number: " + parkingDetails.VehicleNumber + " At time: "
+ parkingDetails.ExitTime + " Total charge: " + parkingDetails.ParkingCharge);
}
return(parkingDetails);
}
/// <summary>
/// Function To Find Vehical By Number.
/// </summary>
/// <param name="vehicalNumber"></param>
/// <returns></returns>
public ParkingDetails GetVehicalByNumber(string VehicalNumber)
{
try
{
ParkingDetails vehicalExists = dBContext.ParkingDetails.Where <ParkingDetails>
(p => p.VehicalNumber.Equals(VehicalNumber)).FirstOrDefault();
return(vehicalExists);
}
catch (Exception exception)
{
throw exception;
}
}
/// <summary>
/// This method used for storing data in parking detail object.
/// </summary>
/// <param name="sqlDataReader">Sql reader.</param>
/// <returns>Parking details.</returns>
public ParkingDetails VehicleDetails(SqlDataReader sqlDataReader)
{
ParkingDetails parkingDetails = new ParkingDetails();
parkingDetails.ParkingId = Convert.ToInt32(sqlDataReader["PARKING_ID"]);
parkingDetails.SlotNumber = Convert.ToInt32(sqlDataReader["SLOT_NUMBER"]);
parkingDetails.VehicleNumber = sqlDataReader["VEHICLE_NUMBER"].ToString();
parkingDetails.ParkingType = Convert.ToInt32(sqlDataReader["PARKING_TYPE"]);
parkingDetails.VehicleType = Convert.ToInt32(sqlDataReader["VEHICLE_TYPE"]);
parkingDetails.DriverType = Convert.ToInt32(sqlDataReader["DRIVER_TYPE"]);
parkingDetails.EntryTime = sqlDataReader["Entry_Time"].ToString();
parkingDetails.ExitTime = sqlDataReader["Exit_Time"].ToString();
parkingDetails.ParkingCharge = Convert.ToInt32(sqlDataReader["PARKING_CHARGE"]);
return(parkingDetails);
}
public ActionResult GetVehicleBySlotNumber(int slotNumber)
{
try
{
ParkingDetails parking = this.parkingService.GetDetailsBySlotNumber(slotNumber);
if (parking == null)
{
return(this.NotFound(new ResponseEntity(HttpStatusCode.NotFound, "Plaese check slot number again")));
}
return(this.Ok(new ResponseEntity(HttpStatusCode.OK, "Vehicle details found", parking)));
}
catch (Exception e)
{
return(this.BadRequest(new ResponseEntity(HttpStatusCode.BadRequest, e.Message)));
}
}
public ActionResult UnParkVehicle(int slotNumber)
{
try
{
ParkingDetails result = this.parkingService.UnParkVehicle(slotNumber);
if (result == null)
{
return(this.NotFound(new ResponseEntity(HttpStatusCode.NotFound, "Please check details again")));
}
return(this.Ok(new ResponseEntity(HttpStatusCode.OK, "Vehicle unParked successfully", result)));
}
catch (Exception e)
{
return(this.BadRequest(new ResponseEntity(HttpStatusCode.BadRequest, e.Message)));
}
}
public ParkResponse ParkVehicle(int securityID, ParkRequest parkDetails)
{
try
{
var securityExists = _appDBContext.Users.
Any(security => security.ID == securityID);
if (securityExists)
{
ParkingDetails parkData = new ParkingDetails
{
OwnerName = parkDetails.OwnerName,
VehicleNumber = parkDetails.VehicleNumber,
VehicleBrand = parkDetails.VehicleBrand,
Color = parkDetails.Color,
IsParked = true,
AttendantName = parkDetails.AttendantName,
Disability = parkDetails.Disability,
ParkingDate = DateTime.Now
};
if (parkDetails.Disability)
{
parkingSlot = GetParkingSlotForHandicap();
}
else
{
parkingSlot = GetParkingSlot();
}
if (parkingSlot == null)
{
return(null);
}
parkData.ParkingSlot = parkingSlot;
_appDBContext.ParkingDetails.Add(parkData);
_appDBContext.SaveChanges();
ParkResponse responseData = ParkedVehicleResponse(parkData);
return(responseData);
}
return(null);
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
public List <ParkingDetails> GetAllVehiclesParkedData()
{
try
{
List <ParkingDetails> listParkingData = new List <ParkingDetails>();
using (this.connection)
{
SqlCommand cmd = new SqlCommand("spGetAllParkingData", this.connection);
cmd.CommandType = CommandType.StoredProcedure;
this.connection.Open();
SqlDataReader dataReader = cmd.ExecuteReader();
if (dataReader.HasRows)
{
while (dataReader.Read())
{
ParkingDetails parkingDetails = new ParkingDetails();
parkingDetails.ParkingId = Convert.ToInt32(dataReader["PARKING_ID"]);
parkingDetails.VehicleNumber = dataReader["VEHICLE_NUMBER"].ToString();
parkingDetails.EntryTime = dataReader["ENTRY_TIME"].ToString();
parkingDetails.ParkingType = Convert.ToInt32(dataReader["PARKING_TYPE"]);
parkingDetails.DriverType = Convert.ToInt32(dataReader["DRIVER_TYPE"]);
parkingDetails.VehicleType = Convert.ToInt32(dataReader["VEHICLE_TYPE"]);
parkingDetails.ExitTime = dataReader["EXIT_TIME"].ToString();
parkingDetails.SlotNumber = Convert.ToInt32(dataReader["SLOT_NUMBER"]);
listParkingData.Add(parkingDetails);
}
this.connection.Close();
return(listParkingData);
}
return(null);
}
}
catch (Exception e)
{
throw new Exception(e.Message);
}
finally
{
this.connection.Close();
}
}
public ParkingDetails GetParkingDetailsWithSlotNumber(int slotNumber)
{
try
{
ParkingDetails parkingDetails = new ParkingDetails();
using (this.connection)
{
SqlCommand cmd = new SqlCommand("spSearchSlotID", this.connection);
cmd.CommandType = CommandType.StoredProcedure;
cmd.Parameters.AddWithValue("@SlotNumber", slotNumber);
this.connection.Open();
SqlDataReader dataReader = cmd.ExecuteReader();
if (dataReader.HasRows)
{
while (dataReader.Read())
{
parkingDetails.ParkingId = Convert.ToInt32(dataReader["PARKING_ID"]);
parkingDetails.VehicleNumber = dataReader["VEHICLE_NUMBER"].ToString();
parkingDetails.EntryTime = dataReader["ENTRY_TIME"].ToString();
parkingDetails.ParkingType = Convert.ToInt32(dataReader["PARKING_TYPE"]);
parkingDetails.DriverType = Convert.ToInt32(dataReader["DRIVER_TYPE"]);
parkingDetails.VehicleType = Convert.ToInt32(dataReader["VEHICLE_TYPE"]);
parkingDetails.ExitTime = dataReader["EXIT_TIME"].ToString();
parkingDetails.SlotNumber = Convert.ToInt32(dataReader["SLOT_NUMBER"]);
parkingDetails.ParkingCharge = Convert.ToInt32(dataReader["CHARGE"]);
}
this.connection.Close();
return(parkingDetails);
}
return(null);
}
}
catch (Exception e)
{
throw new Exception(e.Message);
}
finally
{
this.connection.Close();
}
}
public ParkingFee ValidateVehicleClamped(string accessToken, ParkingDetails objParkingDetails)
{
ParkingFee obj_ParkingFee = new ParkingFee();
try
{
string baseUrl = Convert.ToString(App.Current.Properties["BaseURL"]);
using (var client = new HttpClient())
{
client.BaseAddress = new Uri(baseUrl);
client.DefaultRequestHeaders.Accept.Clear();
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
// Add the Authorization header with the AccessToken.
client.DefaultRequestHeaders.Add("Authorization", "bearer " + accessToken);
// create the URL string.
string url = "api/InstaConsumer/ValidateVehicleClamped";
// make the request
var json = JsonConvert.SerializeObject(objParkingDetails);
var content = new StringContent(json, Encoding.UTF8, "application/json");
HttpResponseMessage response = client.PostAsync(url, content).Result;
if (response.IsSuccessStatusCode)
{
string jsonString = response.Content.ReadAsStringAsync().Result;
if (jsonString != null)
{
APIResponse apiResult = JsonConvert.DeserializeObject <APIResponse>(jsonString);
if (apiResult.Result)
{
obj_ParkingFee = JsonConvert.DeserializeObject <ParkingFee>(Convert.ToString(apiResult.Object));
}
}
}
}
}
catch (Exception ex)
{
}
return(obj_ParkingFee);
}
public bool PostParking(ParkingDetails p)
{
try
{
Parking_Details pd = new Parking_Details();
pd.Parking_ID = p.Parking_ID;
pd.Vechile_Number = p.Vechile_Number;
pd.Visitor_ID = p.Visitor_ID;
es.Parking_Details.Add(pd);
var res = es.SaveChanges();
if (res > 0)
{
return(true);
}
return(false);
}
catch (Exception ex)
{
throw ex;
}
}
public IEnumerable <ParkingDetails> GetParking()
{
try
{
var res = es.Parking_Details.ToList();
List <ParkingDetails> pd = new List <ParkingDetails>();
foreach (var r in res)
{
ParkingDetails p = new ParkingDetails();
p.Parking_ID = r.Parking_ID;
p.Vechile_Number = r.Vechile_Number;
p.Visitor_ID = r.Visitor_ID;
p.Slot_Id = r.Slot_Id;
pd.Add(p);
}
return(pd);
}
catch (Exception ex)
{
throw ex;
}
}
public List <ParkingDetails> GetAllEmptySlots()
{
try
{
List <ParkingDetails> listEmptySlots = new List <ParkingDetails>();
using (this.connection)
{
SqlCommand cmd = new SqlCommand("spGetEmptySLots", this.connection);
cmd.CommandType = CommandType.StoredProcedure;
this.connection.Open();
SqlDataReader datarReader = cmd.ExecuteReader();
if (datarReader.HasRows)
{
while (datarReader.Read())
{
ParkingDetails parkingDetails = new ParkingDetails();
parkingDetails.SlotNumber = Convert.ToInt32(datarReader["SLOT_NUMBER"]);
listEmptySlots.Add(parkingDetails);
}
this.connection.Close();
return(listEmptySlots);
}
return(null);
}
}
catch (Exception e)
{
throw new Exception(e.Message);
}
finally
{
this.connection.Close();
}
}
public ParkingDetails GetByParkingId(int id)
{
try
{
ParkingDetails p = new ParkingDetails();
var r = es.Parking_Details.Where(x => x.Parking_ID == id).SingleOrDefault();
if (r != null)
{
p.Parking_ID = r.Parking_ID;
p.Vechile_Number = r.Vechile_Number;
p.Visitor_ID = Convert.ToInt32(r.Visitor_ID);
p.Slot_Id = r.Slot_Id;
}
else
{
throw new Exception("Invalid id");
}
return(p);
}
catch (Exception ex)
{
throw ex;
}
}
public IActionResult GetVehicalByNumber([FromRoute] string VehicalNumber)
{
try
{
//Throws Custom Exception If VehicalNumber Is Null;
if (VehicalNumber == null)
{
throw new Exception(ParkingLotExceptions.ExceptionType.NULL_FIELD_EXCEPTION.ToString());
}
//Throws Custom Exception If VehicalNumber Is Not in Valid Format.
if (!Regex.IsMatch(VehicalNumber, @"^[A-Z]{2}\s[0-9]{2}\s[A-Z]{1,2}\s[0-9]{4}$"))
{
throw new Exception(ParkingLotExceptions.ExceptionType.INVALID_VEHICAL_NUMBER_FORMAT.ToString() + " Please Enter Vehical In 'MH 01 AZ 2005' This Format.");
}
//Calling BL.
ParkingDetails details = this.parkingLotBL.GetVehicalByNumber(VehicalNumber);
if (details != null && details.Status == "Parked")
{
return(Ok(new { Success = true, Message = "Vehical Details Fetched Successful", Data = details }));
}
else if (details != null && details.Status == "Unparked")
{
return(NotFound(new { Success = false, Message = "Car Already Unparked" }));
}
else
{
return(NotFound(new { Success = false, Message = "Car Not Found" }));
}
}
catch (Exception exception)
{
return(BadRequest(new { Success = false, Message = exception.Message }));
}
}
/// <summary>
/// database connection for get all Parking details
/// </summary>
public IEnumerable <ParkingDetails> GetAllParkingDetails()
{
try
{
List <ParkingDetails> listparking = new List <ParkingDetails>();
SqlConnection connection = DatabaseConnection();
//for store procedure and connection to database
SqlCommand command = StoreProcedureConnection("spAllVehicleParking", connection);
connection.Open();
//Read data from database
SqlDataReader Response = command.ExecuteReader();
while (Response.Read())
{
ParkingDetails parking = new ParkingDetails();
parking.ParkingID = Convert.ToInt32(Response["ParkingID"]);
parking.UserID = Convert.ToInt32(Response["UserID"]);
parking.VehicleOwnerAddress = Response["VehicleOwnerAddress"].ToString();
parking.VehicleNumber = Response["VehicleNumber"].ToString();
parking.VehicalBrand = Response["VehicalBrand"].ToString();
parking.VehicalColor = Response["VehicalColor"].ToString();
parking.ParkingSlot = Response["ParkingSlot"].ToString();
parking.ParkingUserCategory = Response["ParkingUserCategory"].ToString();
parking.ParkingStatus = Response["ParkingStatus"].ToString();
parking.Charges = Response["Charges"].ToString();
parking.EntryTime = Convert.ToDateTime(Response["EntryTime"]);
parking.ExitTime = Convert.ToDateTime(Response["ExitTime"]);
listparking.Add(parking);
}
connection.Close();
return(listparking);
}
catch (Exception e)
{
throw new Exception(e.Message);
}
}
public HttpResponseMessage <ParkingConfirmation> Post(ParkingDetails id)
{
//if (parkingDetails.LocationFile != null && parkingDetails.LocationFile.ContentLength > 0)
var result = new ParkingConfirmation
{
Id = 122345,
Location = new Location
{
Id = 1,
Name = "Vancouver"
},
QuotedPrice = 0.30m,
UserProperties = new UserProperties
{
Vehicle = new Dictionary <string, string>()
{
{ "car 1 ", "123 sdf" }, { "car 2", "sdf234" }
}
}
};
return(Request.CreateResponse(result));
}
public ParkingDetails UnParkVehicle(int slotNumber)
{
ParkingDetails parkingDetails = this.parkingLotRepository.UnParkVehicle(slotNumber);
return(parkingDetails);
}
