/*
* Creates a new list carpark of the defined size, it also moves the cars from the existing carpark to the new
* carpark and removes the old carpark afterwards. The callback will only return true if operations are
* successfully performed.
*/
public void CreateNewCarpark(int size, Action <bool> callback)
{
if (size > GetMaxListSize())
{
Debug.Log($"Maximum carpark size is {Carpark.GetComponent<ListCarparkManager>().Carparks.Count}");
callback(false);
}
else
{
GameObject carpark = Instantiate(Carpark);
IsoTransform isoTransform = carpark.GetComponent <IsoTransform>();
_shiftAmount = new Vector3(isoTransform.Size.x, 0, 0);
if (_currentListCarpark != null)
{
isoTransform.Position = _currentListCarpark.GetComponent <IsoTransform>().Position + _shiftAmount;
}
ListCarparkManager newCarparkManager = carpark.GetComponent <ListCarparkManager>();
if (newCarparkManager.CreateCarpark(size, out List <IsoTransform> newCarpark))
{
GridGraph.UpdateGraph();
StartCoroutine(CopyVehiclesToNewCarpark(newCarparkManager, newCarpark, callback));
}
else
{
DestroyImmediate(carpark);
}
}
}
public void ProcessStatusUpdate(IParkingSpotStatusUpdate parkingSpotStatusUpdate)
{
logger.LogInformation("BEGIN ProcessStatusUpdate");
this.carparkProvider.ProcessStatusUpdate(parkingSpotStatusUpdate);
Carpark carpark = this.carparkProvider.GetCarparkByName(parkingSpotStatusUpdate.Location);
if (carpark == null)
{
logger.LogError($"No carpark found for {parkingSpotStatusUpdate.Location}");
return;
}
ISpotUpdate spotUpdate = new SpotUpdateImpl()
{
CarparkId = carpark.Id,
SpotId = parkingSpotStatusUpdate.SpotId,
Status = parkingSpotStatusUpdate.Available ? SpotStatus.Available : SpotStatus.Unavailable,
UpdatedOn = parkingSpotStatusUpdate.Timestamp,
Source = MessageSource.MessageBus
};
ProcessUpdate(spotUpdate);
logger.LogInformation("END ProcessStatusUpdate");
}
public async Task <IActionResult> PutCarpark([FromRoute] string id, [FromBody] Carpark carpark)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != carpark.CarparkID)
{
return(BadRequest());
}
_context.Entry(carpark).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!CarparkExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
private Carpark UpdateURAAvailability(Carpark carparkFromRepo)
{
var task = Task.Run(async() => await publicAPI.GetURAAvailability());
var result = task.Result;
var carparks = result.FindAll(a => a.carparkNo == carparkFromRepo.CarparkId);
if (carparks != null)
{
foreach (var v in carparks)
{
if (v.lotType == "C")
{
carparkFromRepo.CarAvailability = int.Parse(v.lotsAvailable);
}
else if (v.lotType == "M")
{
carparkFromRepo.MAvailability = int.Parse(v.lotsAvailable);
}
else if (v.lotType == "H")
{
carparkFromRepo.HVAvailability = int.Parse(v.lotsAvailable);
}
}
if (carparks.Count == 0)
{
carparkFromRepo.TotalAvailableLots = -1;
}
else
{
carparkFromRepo.TotalAvailableLots = carparkFromRepo.CarAvailability + carparkFromRepo.MAvailability + carparkFromRepo.HVAvailability;
}
_parkingRepository.UpdateCarpark(carparkFromRepo);
_parkingRepository.SaveChanges();
}
else
{
carparkFromRepo.TotalAvailableLots = -1;
carparkFromRepo.CarAvailability = -1;
carparkFromRepo.MAvailability = -1;
carparkFromRepo.HVAvailability = -1;
_parkingRepository.UpdateCarpark(carparkFromRepo);
_parkingRepository.SaveChanges();
}
Timer.RequestedDT = DateTime.Now;
return(carparkFromRepo);
}
// GET: Carparks
public ActionResult Random()
{
var carpark = new Carpark()
{
Name = "HP"
};
return(View(carpark));
}
private Carpark GetCarparkById(int carparkId)
{
Carpark carpark = carparkProvider.GetCarpark(carparkId);
if (carpark == null)
{
throw new CarparkNotFoundException(carparkId);
}
return(carpark);
}
public static List <Carpark> fixURACarparkData()
{
FetchPublicAPI publicAPI = new FetchPublicAPI();
var carparks = new List <Carpark>();
// URA Carpark Info
var task = Task.Run(async() => await publicAPI.GetURAParkingInfoAsync());
var URACarparkInfo = task.Result;
var carparkNo = "";
foreach (var r in URACarparkInfo)
{
if (carparkNo != r.ppCode)
{
double xcoord = 0.00, ycoord = 0.00;
if (r.geometries != null)
{
var uncooord = r.geometries[0].coordinates.Split(",");
var x = uncooord[0];
var y = uncooord[1];
Svy21Coordinate svy21 = new Svy21Coordinate(double.Parse(x), double.Parse(y));
LatLongCoordinate latLong = svy21.ToLatLongCoordinate();
xcoord = latLong.Latitude;
ycoord = latLong.Longitude;
}
Carpark carpark = new Carpark()
{
Id = Guid.NewGuid(),
CarparkId = r.ppCode,
CarparkName = r.ppName,
Address = r.ppName,
AgencyType = "URA",
IsCentral = false,
XCoord = xcoord.ToString(),
YCoord = ycoord.ToString(),
ParkingSystem = "",
LotType = ""
};
carparks.Add(carpark);
}
carparkNo = r.ppCode;
}
return(carparks);
}
public IEnumerable <ParkingSpotDTO> GetParkingSpots(int carparkId)
{
Carpark carpark = GetCarparkById(carparkId);
return(carpark.SpotData.Select(x => new ParkingSpotDTO {
LastUpdated = x.Value.LastUpdated,
SpotId = x.Value.SpotId,
Status = x.Value.SpotStatus,
CarparkId = carparkId
}));
}
public void ProcessSpotUpdate(ISpotUpdate spotUpdate)
{
Carpark carpark = GetCarpark(spotUpdate.CarparkId);
carpark.SpotData[spotUpdate.SpotId] = new ParkingSpotImpl()
{
SpotId = spotUpdate.SpotId,
LastUpdated = spotUpdate.UpdatedOn,
SpotStatus = spotUpdate.Status
};
}
public async Task <IActionResult> PostCarpark([FromBody] Carpark carpark)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
_context.Carpark.Add(carpark);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetCarpark", new { id = carpark.CarparkID }, carpark));
}
public void AddCarpark(Carpark carpark)
{
int id = Carparks.Any() ? Carparks.Max(x => x.Id) + 1 : 1;
Carparks.Add(new Carpark {
Id = id,
Name = carpark.Name,
Latitude = carpark.Latitude,
Longitude = carpark.Longitude,
TotalSpaces = carpark.TotalSpaces,
Description = carpark.Description
});
}
public void ProcessStatusUpdate(IParkingSpotStatusUpdate parkingSpotStatusUpdate)
{
Carpark carpark = GetCarparkByName(parkingSpotStatusUpdate.Location);
if (carpark != null)
{
carpark.SpotData[parkingSpotStatusUpdate.SpotId] = new ParkingSpotImpl
{
SpotId = parkingSpotStatusUpdate.SpotId,
LastUpdated = DateTime.Now,
SpotStatus = parkingSpotStatusUpdate.Available ? SpotStatus.Available : SpotStatus.Unavailable
};
}
}
public static void FixShoppingMallData(ParkingContext context)
{
FetchPublicAPI publicAPI = new FetchPublicAPI();
// URA Carpark Info
var task2 = Task.Run(async() => await publicAPI.GetShoppingMallAsync());
var ShoppingmallCarpark = task2.Result;
List <Carpark> carparks = new List <Carpark>();
int i = 1;
foreach (var shop in ShoppingmallCarpark)
{
Carpark carpark = new Carpark()
{
Id = Guid.NewGuid(),
CarparkName = shop.carpark,
Address = shop.category,
AgencyType = "Shopping Mall",
ParkingSystem = "",
CarAvailability = 0,
CarCapacity = 0,
CarparkId = $"SHP{i}",
HVAvailability = 0,
HVCapacity = 0,
IsCentral = false,
LotType = "C",
MAvailability = 0,
MCapacity = 0,
TotalAvailableLots = 0,
TotalLots = 0,
XCoord = "",
YCoord = ""
};
carparks.Add(carpark);
i++;
}
context.Carparks.AddRange(carparks);
context.SaveChanges();
}
static void Main(string[] args)
{
string filename = "Config.xml";
byte[] sendData_byte = null;
XML xml = new XML(filename);
string address = xml.GetStrXML("/config/tcpip/address");
int port = xml.GetIntXML("/config/tcpip/port");
Carpark cp = new Carpark();
TCPIP tcpip = new TCPIP(address, port);
Console.WriteLine("Running at IP:" + address + " Port: " + port.ToString() + "\n");
while (true)
{
Console.WriteLine("Host Server: Listening");
string recvData = Utils.Byte2StrAscii(tcpip.StartListen());
// Can be better
if (recvData.Contains(Commands.complementaryFareCommand))
{
sendData_byte = cp.GetComplementaryFare();
}
else if (recvData.Contains(Commands.normalFareCommand))
{
sendData_byte = cp.GetNormalFare();
}
if (recvData.Contains(Commands.openGateCommand2_0))
{
sendData_byte = cp.OpenGate2_0();
}
if (sendData_byte != null)
{
tcpip.SendData(sendData_byte);
}
tcpip.StopListen();
}
}
private Carpark UpdateHDBAvailability(Carpark carparkFromRepo)
{
var task = Task.Run(async() => await publicAPI.GetHDBAvailabilityAsync());
var result = task.Result;
var v = result.FirstOrDefault(a => a.carpark_number.Equals(carparkFromRepo.CarparkId));
if (v != null)
{
if (v.carpark_info.Length > 0)
{
foreach (var x in v.carpark_info)
{
if (x.lot_type.Equals("C"))
{
carparkFromRepo.CarAvailability = int.Parse(x.lots_available);
}
else if (x.lot_type.Equals("H"))
{
carparkFromRepo.HVAvailability = int.Parse(x.lots_available);
}
else if (x.lot_type.Equals("Y"))
{
carparkFromRepo.MAvailability = int.Parse(x.lots_available);
}
}
carparkFromRepo.TotalAvailableLots = carparkFromRepo.CarAvailability + carparkFromRepo.HVAvailability + carparkFromRepo.MAvailability;
_parkingRepository.UpdateCarpark(carparkFromRepo);
_parkingRepository.SaveChanges();
}
}
Timer.RequestedDT = DateTime.Now;
return(carparkFromRepo);
}
private Carpark UpdateLTAAvailability(Carpark carparkFromRepo)
{
var task = Task.Run(async() => await publicAPI.GetParkingInfoAsync());
var result = task.Result;
var v = result.FirstOrDefault(a => a.CarparkId == carparkFromRepo.CarparkId);
if (v != null)
{
carparkFromRepo.CarAvailability = v.CarAvailability;
carparkFromRepo.TotalAvailableLots = v.TotalAvailableLots;
_parkingRepository.UpdateCarpark(carparkFromRepo);
_parkingRepository.SaveChanges();
}
Timer.RequestedDT = DateTime.Now;
return(carparkFromRepo);
}
public CarparkDTO GetCarpark(int carparkId)
{
Carpark carpark = GetCarparkById(carparkId);
return(new CarparkDTO
{
Name = carpark.Name,
Description = carpark.Description,
Location = new LocationDTO
{
Latitude = carpark.Latitude,
Longitude = carpark.Longitude
},
Info = new CarparkInfoDTO
{
AvailableSpaces = carpark.SpotData.Count(x => x.Value.SpotStatus == SpotStatus.Available),
UnavailableSpaces = carpark.SpotData.Count(x => x.Value.SpotStatus == SpotStatus.Unavailable),
UnknownSpaces = carpark.SpotData.Count(x => x.Value.SpotStatus == SpotStatus.Unknown),
TotalSpaces = 0,
}
});
}
public async Task <Carpark> GetAllCarparks()
{
Carpark Carpark = new Carpark();
while (true)
{
var builder = new UriBuilder(Constant.TRAFFIC_CARKPARKAVAILABILITY);
var query = HttpUtility.ParseQueryString(builder.Query);
query.Add("$skip", Carpark.Value.Count.ToString());
builder.Query = query.ToString();
var newResult = await _clientService.GetAsync <Carpark>(builder.Uri);
if (newResult.Value.Count == 0)
{
//Finally add Odata (Just to maintain the integrity)
Carpark.OdataMetadata = newResult.OdataMetadata;
break;
}
Carpark.Value.AddRange(newResult.Value);
}
return(Carpark);
}
private void InsertCarparkToDb(Carpark cp)
{
_connection = new MySqlConnection(ConnectionString);
_connection.Open();
try
{
const string query =
"INSERT INTO Roadwatch_Parking (City, District, Name, Location, Url, Access, Hours, Tarriffs, City_Id, Updated)" +
" VALUES (@city, @district, @name, @location, @url, @access, @hours, @tarriffs, @cityid, @updated);";
using (var cmd = new MySqlCommand(query, _connection))
{
// Start using the passed values in our parameters:
cmd.Parameters.AddWithValue("@city", cp.City);
cmd.Parameters.AddWithValue("@district", cp.District);
cmd.Parameters.AddWithValue("@name", cp.Name);
cmd.Parameters.AddWithValue("@location", cp.Location);
cmd.Parameters.AddWithValue("@url", cp.Url);
cmd.Parameters.AddWithValue("@access", cp.Access);
cmd.Parameters.AddWithValue("@hours", cp.Hours);
cmd.Parameters.AddWithValue("@tarriffs", cp.Tarrifs);
cmd.Parameters.AddWithValue("@cityid", cp.CityId);
cmd.Parameters.AddWithValue("@updated", DateTime.Now);
// Execute the query
cmd.ExecuteNonQuery();
}
}
catch (Exception ex)
{
var sf = new StackFrame();
var methodBase = sf.GetMethod();
Database.InsertErrorToDb(methodBase.Name, ex.Message, ex.ToString());
}
}
public Carpark GetCarparkByName(string name)
{
Carpark carpark = Carparks.FirstOrDefault(x => x.Name == name);
return(carpark);
}
public List <Carpark> GetCarparks(string name, int id)
{
var carparks = new List <Carpark>();
var recent = true;
var getThem = false;
try
{
_connection = new MySqlConnection(ConnectionString);
_connection.Open();
var sql = string.Format("SELECT * from Roadwatch_Parking where City = '{0}' ", name);
using (var cmd = new MySqlCommand(sql, _connection))
{
using (var r = cmd.ExecuteReader())
{
if (r.HasRows)
{
while (r.Read())
{
//if (DateTime.Now.Subtract(r.GetDateTime("Updated")).TotalDays > 30)
//{
// recent = false;
// break;
//}
var cp = new Carpark
{
Access = r.GetString("Access"),
City = r.GetString("City"),
CityId = r.GetInt32("City_Id"),
District = r.GetString("District"),
Hours = r.GetString("Hours"),
Id = r.GetInt32("Id"),
Location = r.GetString("Location"),
Name = r.GetString("Name"),
Tarrifs = r.GetString("Tarriffs"),
Url = r.GetString("Url")
};
carparks.Add(cp);
}
}
else
{
getThem = true;
}
}
}
}
catch (Exception ex)
{
var sf = new StackFrame();
var methodBase = sf.GetMethod();
Database.InsertRoadwatchErrorToDb(methodBase.Name, ex.Message, ex.ToString());
}
if (!recent || getThem)
{
var web = new HtmlWeb();
var doc = web.Load("http://www.theaa.ie/AA/AA-Roadwatch/Car-parking/" + name + "/");
var nodes = doc.DocumentNode.SelectNodes("//div[@class='parkingList']");
foreach (var node in nodes)
{
var parks = node.ChildNodes[3].ChildNodes[3].ChildNodes; //.SelectNodes("//tr");
foreach (var n in parks.Where(p => p.Name == "tr"))
{
var cp = new Carpark();
cp.District = CleanString(node.ChildNodes[1].InnerText);
cp.Name = CleanString(n.ChildNodes[1].InnerText);
cp.Location = CleanString(n.ChildNodes[3].InnerText);
cp.Url = "http://www.theaa.ie" + n.ChildNodes[1].ChildNodes[1].Attributes[0].Value;
cp.Access = CleanString(GetDetails(cp.Url));
cp.Tarrifs = CleanString(tariffs);
cp.Hours = CleanString(openingHours);
cp.City = name;
cp.CityId = id;
carparks.Add(cp);
}
}
if (carparks.Count > 0)
{
foreach (var cp in carparks)
{
//InsertCarparkToDb(cp);
}
}
GetCarparks(name, id);
}
return(carparks);
}
public async Task <List <Carpark> > GetParkingInfoAsync()
{
List <Carpark> carParks = new List <Carpark>();
for (int i = 0; i <= 2000; i += 500)
{
var responseBody = await HttpHelpers.GetResource($"http://datamall2.mytransport.sg/ltaodataservice/CarParkAvailabilityv2?$skip={i}", "AccountKey", "/QfcKQGpSQqaMjxGODUfpQ==");
DataMallEntity dataMallEntity = JsonConvert.DeserializeObject <DataMallEntity>(responseBody);
foreach (var value in dataMallEntity.value)
{
if (value.Agency == "LTA")
{
// Split location coordinates
string[] coordinates = { "", "" };
// If there is no location, XCoord and YCoord should be blank
if (value.Location == "")
{
coordinates[0] = "";
coordinates[1] = "";
}
// Otherwise, split location into XCoord and YCoord
else
{
coordinates = value.Location.Split(" ");
}
int carAv = 0, HVAv = 0, MAv = 0;
if (value.LotType == "C")
{
carAv = value.AvailableLots;
}
else if (value.LotType == "H")
{
HVAv = value.AvailableLots;
}
else if (value.LotType == "Y")
{
MAv = value.AvailableLots;
}
Carpark carpark =
new Carpark
{
Id = Guid.NewGuid(),
CarparkId = value.CarParkID,
CarparkName = value.Development,
AgencyType = value.Agency,
Address = value.Area,
XCoord = coordinates[0],
YCoord = coordinates[1],
IsCentral = false,
ParkingSystem = "ELECTRONIC PARKING",
CarAvailability = carAv,
CarCapacity = 0,
HVCapacity = 0,
LotType = value.LotType,
HVAvailability = HVAv,
MAvailability = MAv,
MCapacity = 0,
TotalAvailableLots = value.AvailableLots,
TotalLots = 0
};
if (carParks.Count == 0)
{
carParks.Add(carpark);
}
if (carParks.Count > 0)
{
if (carpark.CarparkId == carParks[carParks.Count - 1].CarparkId)
{
}
else
{
carParks.Add(carpark);
}
}
}
}
}
return(carParks);
}
public async Task <List <Carpark> > GetHDBParkingInfoAsync()
{
try
{
using (var client = new HttpClient())
{
client.BaseAddress = new Uri("https://data.gov.sg/api/action/datastore_search?resource_id=139a3035-e624-4f56-b63f-89ae28d4ae4c&limit=1000000");
HttpResponseMessage response = await client.GetAsync(client.BaseAddress);
response.EnsureSuccessStatusCode();
string responseBody = response.Content.ReadAsStringAsync().Result;
HDBEntity HdbEntity = JsonConvert.DeserializeObject <HDBEntity>(responseBody);
List <Carpark> carparks = new List <Carpark>();
foreach (var c in HdbEntity.result.records)
{
//Svy21Coordinate svy21 = new Svy21Coordinate(double.Parse(c.x_coord), double.Parse(c.y_coord));
// LatLongCoordinate latLong = svy21.ToLatLongCoordinate();
var task = Task.Run(async() => await GetCoordinates(float.Parse(c.x_coord), float.Parse(c.y_coord)));
var coordinates = task.Result;
bool isCentral = false;
if (c.car_park_no.Contains("HLM") ||
c.car_park_no.Contains("KAB") ||
c.car_park_no.Contains("KAM") ||
c.car_park_no.Contains("KAS") ||
c.car_park_no.Contains("PRM") ||
c.car_park_no.Contains("SLS") ||
c.car_park_no.Contains("SR1") ||
c.car_park_no.Contains("SR2") ||
c.car_park_no.Contains("TPM") ||
c.car_park_no.Contains("UCS")
)
{
isCentral = true;
}
Carpark carpark = new Carpark()
{
Id = Guid.NewGuid(),
Address = c.address,
AgencyType = "HDB",
CarparkId = c.car_park_no,
XCoord = coordinates.latitude.ToString(),
YCoord = coordinates.longitude.ToString(),
CarparkName = c.address,
IsCentral = isCentral,
ParkingSystem = c.type_of_parking_system
};
carparks.Add(carpark);
}
return(carparks);
}
}
catch (HttpRequestException e)
{
Console.WriteLine("\nHttpRequest couldn't be fulfilled.");
Console.WriteLine("Message: {0} ", e.Message);
return(null);
}
}
