public ActionResult <ParkingSpaceDetailDTO> UpdateParkingSpace(long id, [FromBody] ParkingSpace updatedParkingSpace)
{
var parkingSpace = this.parkingSpaceRepository.UpdateParkingSpace(id, updatedParkingSpace);
var parkingSpaceResult = this.mapper.Map <ParkingSpaceDetailDTO>(parkingSpace);
return(parkingSpaceResult);
}
public void Take_ShouldBeNotAvailable()
{
ParkingSpace sut = new ParkingSpace();
sut.Take();
Assert.That(sut.GetIsAvailable(), Is.EqualTo(false));
}
async void GetInfo()
{
ParkingSpace parkingSpace = await busCon.GetParkingSpace(bus.BusID.ToString());
parkeerLbl.Text = "Parkeer op " + parkingSpace.Type.ToString() + parkingSpace.Number.ToString();
await busCon.UpdateBus(bus, parkingSpace);
}
public void Take_ShouldBeFalse()
{
ParkingSpace sut = new ParkingSpace();
sut.Take();
Assert.That(sut.Take(), Is.EqualTo(false));
}
public bool Parkvehicle(Vehicle vehicle, ParkingType parkingType)
{
if (!IsFull)
{
ParkingSpace availableSpace = AvailableSpaces.Where(p => p.Type == parkingType).OrderBy(p => p).FirstOrDefault();
if (availableSpace != null)
{
availableSpace.Vehicle = vehicle;
availableSpace.IsOccupied = true;
UsedSpaces.Add(availableSpace);
AvailableSpaces.Remove(availableSpace);
if (UsedSpaces.Count == MAX_SLOT)
{
IsFull = true;
}
IsEmpty = false;
return(true);
}
return(false);
}
else
{
Console.WriteLine("Parking is Full");
return(false);
}
}
public async Task <ParkingSpace> GetParkingSpace(string id)
{
string path = "bus/giveparkingspace?id=" + id;
ParkingSpace parkingSpace = await PostParkingSpaceAsync(path);
return(parkingSpace);
}
public void TestPark()
{
if (Random.Range(0.0f, 100.0f) < parkChance_)
{
Road road = car_.GetCurRoad().GetComponent <Road>();
ParkingSpace parking = null;
if (road)
{
GameObject space = road.GetParkingSpace();
if (space)
{
parking = space.GetComponent <ParkingSpace>();
}
}
if (parking)
{
car_.SetState(CarState.CS_PARKING);
parking.SetAvailable(false);
car_.ClearTargets();
List <Vector3> newTargets = parking.GetEnterTargets();
foreach (Vector3 target in newTargets)
{
car_.AddTarget(target);
}
curParking_ = parking;
}
}
}
public string registerParkingSpace(ParkingSpace objParkingSpace)
{
string objMesaje = "-1";
try
{
using (ParkingDataClassesDataContext sql = new ParkingDataClassesDataContext(cadenaConexion))
{
parkingSpace objparkingSpace = new parkingSpace
{
parkingSpaceID = objParkingSpace.parkingSpaceID,
parkingLotID = objParkingSpace.parkingLotID,
shortName = objParkingSpace.shortName,
status = true,
};
sql.parkingSpaces.InsertOnSubmit(objparkingSpace);
sql.SubmitChanges();
objMesaje = "0";
};
}
catch (Exception ex)
{
objMesaje = ex.Message;
}
return(objMesaje);
}
public void Vacate_ShouldBeTrue()
{
ParkingSpace sut = new ParkingSpace();
sut.Vacate();
Assert.That(sut.GetIsAvailable(), Is.EqualTo(true));
}
public IActionResult AddParkingSpace(ParkingLevelAddParkingSpaceViewModel viewModel)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var level = _levelRepository.GetById(viewModel.ParkingLevelId);
if (level == null)
{
return(NotFound());
}
var parkingSpace = new ParkingSpace(viewModel.Number);
var result = level.AddParkingSpace(parkingSpace);
if (!result.IsSuccess)
{
return(BadRequest(result.ErrorMessage));
}
_context.SaveChanges();
return(RedirectToAction(nameof(ParkingController.Edit), "Parking", new { id = level.Parking.Id }));
}
public string updteParkingSpace(ParkingSpace objParkingSpace)
{
string objMesaje = "-1";
try
{
using (var sql = new ParkingDataClassesDataContext(cadenaConexion))
{
var objparkingSpace = sql.parkingSpaces.Single(x => x.parkingSpaceID == objParkingSpace.parkingSpaceID);
objparkingSpace.parkingLotID = objParkingSpace.parkingLotID;
objparkingSpace.parkingSpaceID = objParkingSpace.parkingSpaceID;
objparkingSpace.shortName = objParkingSpace.shortName;
objparkingSpace.status = objParkingSpace.status;
sql.SubmitChanges();
objMesaje = "0";
};
}
catch (Exception ex)
{
objMesaje = ex.Message;
}
return(objMesaje);
}
private async void FreeParkingSpaces_AddNew()
{
Days day = new Days();
var listFreeDates = await OwnerFreeSpaces();
var listBlackoutDates = await ListBlackout();
var listWorkingDays = day.WorkingDays(_dateFrom, _dateTo).ToList();
var freeDatesToDelete = from free in listFreeDates select Date.Format(free.Date);
var blackoutDatesToDelete = from black in listBlackoutDates select Date.Format(black.Date);
var dateToInsert = (from work in listWorkingDays
where
!freeDatesToDelete.Contains(Date.Format(work.Date))
&&
!blackoutDatesToDelete.Contains(Date.Format(work.Date))
select Date.Format(work.Date)).ToList();
ParkingEntities1 d = new ParkingEntities1();
foreach (var item in dateToInsert)
{
ParkingSpace p = new ParkingSpace();
p.Date = item;
p.ParkingSpaceOwnerID = _ownerId;
p.Added = DateTime.Now;
pe.ParkingSpaces.Add(p);
pe.SaveChanges();
}
}
public ParkingSpace GetlParkingSpaceById(int id)
{
ParkingSpace singleParkingSpace = GetAllPrice()
.FirstOrDefault(x => x.Id == id);
return(singleParkingSpace);
}
public void ToggleParkingSpaceIndicator(ParkingSpace ps, bool enable)
{
Transform psTrf = parkingSpaceGoMap[ps].transform;
GameObject area = psTrf.Find("Area").gameObject;
area.SetActive(enable);
}
public ParkingSpace CreateParkingSpace(ParkingSpace c)
{
this.context.ParkingSpaces.Add(c);
this.context.SaveChanges();
return(c);
}
protected override void RunActualProcess()
{
SqlConnection.RecreateTable <ParkingSpace>(Stage.Houses, Constants.PresentSlice);
var dbHouses = SqlConnection.GetDatabaseConnection(Stage.Houses, Constants.PresentSlice).Database;
var households = dbHouses.Fetch <Household>();
//var houses = dbHouses.Fetch<House>();
var cars = dbHouses.Fetch <Car>();
dbHouses.BeginTransaction();
foreach (var car in cars)
{
var household = households.Single(x => x.HouseholdGuid == car.HouseholdGuid);
var ps = new ParkingSpace(car.HouseholdGuid, Guid.NewGuid().ToString(), car.HouseGuid, household.HausAnschlussGuid, household.Name + " car")
{
CarGuid = car.CarGuid
};
if (car.CarType == CarType.Electric)
{
ps.ChargingStationType = ChargingStationType.ThreekW;
}
else
{
ps.ChargingStationType = ChargingStationType.NoCharging;
}
dbHouses.Save(ps);
}
dbHouses.CompleteTransaction();
}
public ActionResult Create([Bind(Include = "Id,RegNum,Color,CheckInTime,NumOfTires,Model,ParkingSpaceNum,TypeId,MemberId, MembershipNr")] Vehicle vehicle)
{
vehicle.CheckInTime = DateTime.Now;
if (ModelState.IsValid)
{
ParkingSpace ps = new ParkingSpace(parkingCapacity);
var index = ps.AssignParkingSpace(vehicle);
if (index != -1)
{
ViewBag.isFull = "";
vehicle.ParkingSpaceNum = index;
vehicle.MemberId = db.Members.FirstOrDefault(v => v.MembershipNr == vehicle.MembershipNr).MemberId;
db.Vehicles.Add(vehicle);
db.SaveChanges();
return(RedirectToAction("Index"));
}
else
{
ViewBag.isFull = "There is no place to park your vehicle, sorry!";
}
}
ViewBag.MemberId = new SelectList(db.Members, "MemberId", "MembershipNr", vehicle.MemberId);
ViewBag.TypeId = new SelectList(db.VehicleTypes, "TypeId", "Type", vehicle.TypeId);
return(View(vehicle));
}
public ActionResult <ParkingSpace> Create(ParkingSpace c)
{
var parkingSpace = this.mapper.Map <ParkingSpace>(c);
parkingSpace = this.parkingSpaceRepository.Create(parkingSpace);
return(this.mapper.Map <ParkingSpace>(parkingSpace));
}
public void UpdateParkingSpace(int id, ParkingSpace parkingSpace)
{
var updateParkingSpace = _context.ParkingSpaces.SingleOrDefault(pl => pl.Id == id);
CopyClass.CopyParkingSpace(parkingSpace, updateParkingSpace);
_context.ParkingSpaces.Update(updateParkingSpace);
Save();
}
public void Should_Not_Release_ParkingSpace_And_Return_Unavailable()
{
var parkingSpace = new ParkingSpace(ParkingSpaceType.Car);
parkingSpace.Occupy(2);
Assert.False(parkingSpace.IsAvailable());
}
public void Should_Occupy_ParkingSpace_And_Then_Be_Not_Available()
{
var parkingSpace = new ParkingSpace(ParkingSpaceType.Car);
parkingSpace.Occupy(2);
Assert.False(parkingSpace.IsAvailable());
}
public ActionResult DeleteConfirmed(int id)
{
ParkingSpace parkingSpace = db.ParkingSpaces.Find(id);
db.ParkingSpaces.Remove(parkingSpace);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public ParkingSpace UpdateParkingSpace(long id, ParkingSpace newParkingSpace)
{
newParkingSpace.Id = id;
this.context.Entry(newParkingSpace).State = EntityState.Modified;
this.context.SaveChanges();
return(newParkingSpace);
}
public async Task <bool> UpdateBus(Bus bus, ParkingSpace parkingSpace)
{
string path = "parkingspace/updateoccupied";
await PostUpdateParkingSpaceAsync(path, parkingSpace.ParkingSpaceID, bus.BusID, true);
return(await PostUpdateParkingSpaceAsync(path, bus.ParkingSpace, 0, false));
}
public void Should_Load_Entity_Correctly()
{
var parkingSpace = new ParkingSpace(ParkingSpaceType.Car);
var expected = ParkingSpaceType.Car;
Assert.Equal(expected, parkingSpace.Type);
}
public static ParkingSpaceViewModel ToParkingSpaceViewModel(this ParkingSpace parkingSpace)
{
return(new ParkingSpaceViewModel
{
Id = parkingSpace.Id,
Number = parkingSpace.Number,
Status = parkingSpace.Status
});
}
public void Should_Release_ParkingSpace_And_Then_Be_Available()
{
var parkingSpace = new ParkingSpace(ParkingSpaceType.Car);
parkingSpace.Occupy(2);
parkingSpace.Release();
Assert.True(parkingSpace.IsAvailable());
}
public static void CopyParkingSpace(ParkingSpace source, ParkingSpace destination)
{
destination.Details = source.Details;
destination.HasCarWash = source.HasCarWash;
destination.IsCovered = source.IsCovered;
destination.IsTaken = source.IsTaken;
destination.Name = source.Name;
destination.ParkingLotId = source.ParkingLotId;
destination.Price = source.Price;
}
public IActionResult Post([FromBody] ParkingSpace parkingSpace)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var record = service.SaveOneParkingSpace(parkingSpace);
return(Created("api/parkingSpace/:id" + parkingSpace.Id, parkingSpace));
}
public int AddParkingSpace(ParkingSpace pSpace)
{
using (ParkingSystemContext Ctx = new ParkingSystemContext())
{
Ctx.ParkingSpaces.Add(pSpace);
Ctx.SaveChanges();
}
return(pSpace.Id);
}
public async Task<bool> VendorRegistrationNotification(ParkingSpace parkingSpace)
{
var param = new string[] { parkingSpace.Email, parkingSpace.Address };
var emailToAdminBody = GetMessage(param, System.Web.Hosting.HostingEnvironment.MapPath("~/EmailTemplates/NewVendorRegistration.html"));
var emailToAdminReceiver = new List<string>();
emailToAdminReceiver.Add("*****@*****.**");
emailToAdminReceiver.Add("*****@*****.**");
emailToAdminReceiver.Add("*****@*****.**");
var emailToAdmin = new EmailNotification
{
From = "*****@*****.**",
To = emailToAdminReceiver,
Subject = "Parko - new vendor registration",
Message = emailToAdminBody,
IsHtml = true,
Status = 1
};
await EmailRepository.CreateSync(emailToAdmin);
return true;
}
public async Task<bool> VendorRegistrationSendToVendor(ParkingSpace parkingSpace)
{
var param = new string[] { parkingSpace.Email, parkingSpace.Address };
var emailToAdminBody = GetMessage(param, System.Web.Hosting.HostingEnvironment.MapPath("~/EmailTemplates/VendorRegistration.html"));
var emailToAdminReceiver = new List<string>();
emailToAdminReceiver.Add(parkingSpace.Email);
var bcc = new List<string>();
bcc.Add("*****@*****.**");
var emailToAdmin = new EmailNotification
{
From = "*****@*****.**",
To = emailToAdminReceiver,
Subject = "Welcome to Parko!",
Bcc = bcc,
Message = emailToAdminBody,
IsHtml = true,
Status = 1
};
await EmailRepository.CreateSync(emailToAdmin);
return true;
}