/// <summary>
/// Finalizes the instance.
/// </summary>
public void Flush()
{
// Set references to this object
Compound.Instance = this;
foreach (var instanceElement in
Bots.AsEnumerable <InstanceElement>()
.Concat(Pods.AsEnumerable <InstanceElement>())
.Concat(Elevators.AsEnumerable <InstanceElement>())
.Concat(InputStations.AsEnumerable <InstanceElement>())
.Concat(OutputStations.AsEnumerable <InstanceElement>())
.Concat(Waypoints.AsEnumerable <InstanceElement>())
.Concat(ItemDescriptions.AsEnumerable <InstanceElement>())
.Concat(ItemBundles.AsEnumerable <InstanceElement>()))
{
instanceElement.Instance = this;
}
//TODO:why is the code below commented out??
//// Generate Waypointgraph
//WaypointGraph = new WaypointGraph();
//foreach (var waypoint in Waypoints)
//{
// WaypointGraph.Add(waypoint);
//}
}
public async Task <IActionResult> PutOne(int id, [FromBody] Elevators body)
{
await Db.Connection.OpenAsync();
var query = new ElevatorsQuery(Db);
var result = await query.FindOneAsync(id);
//check the request sent if it valid
if (body is null)
{
return(new NotFoundObjectResult("Please enter something in the status"));
}
if (body.Status.ToLower() != "intervention" && body.Status.ToLower() != "active" && body.Status.ToLower() != "inactive")
{
return(new NotFoundObjectResult("The status you entered is invalide!"));
}
if (result is null)
{
return(new NotFoundResult());
}
result.Status = body.Status;
await result.UpdateAsync();
return(new OkObjectResult(result));
}
public async Task <IActionResult> PutElevators(long id, Elevators elevators)
{
if (id != elevators.Id)
{
return(BadRequest());
}
_context.Entry(elevators).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ElevatorsExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <IActionResult> PutElevators(long id, Elevators Elevators)
{
if (id != Elevators.id)
{
return(BadRequest());
}
_context.Entry(Elevators).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ElevatorsExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
var jsonPut = new JObject();
jsonPut["Update"] = "Update done to elevator id : " + id;
return(Content(jsonPut.ToString(), "application/json"));
}
/// <summary>
/// Choose an elevator to make the trip
/// No new elevator will be assigned during this method, but elevators may become available
/// </summary>
/// <param name="startFloor"></param>
/// <param name="endFloor"></param>
/// <returns></returns>
public Elevator AssignElevator(int startFloor, int endFloor)
{
// Find all of the available elevators
IEnumerable <Elevator> availableElevators = Elevators.Where(e => e.IsAvailable);
if (availableElevators.Count() == 0)
{
// No elevators are available try again later
return(null);
}
Elevator assignedElevator = availableElevators.First();
int floorDistance = Math.Abs(startFloor - assignedElevator.CurrentFloor);
// When an elevator request is made, the unoccupied elevator closest to it will answer the call
foreach (Elevator current in availableElevators)
{
int currentDistance = Math.Abs(startFloor - current.CurrentFloor);
if (currentDistance < floorDistance)
{
floorDistance = currentDistance;
assignedElevator = current;
}
if (currentDistance == 0)
{
return(assignedElevator);
}
}
return(assignedElevator);
}
public ViewModel()
{
Elevators.Add(new Elevator(0));
Elevators.Add(new Elevator(1));
Elevators.Add(new Elevator(2));
Task.Factory.StartNew(Operator);
}
public async Task <ActionResult <Elevators> > PostElevators(Elevators elevators)
{
_context.Elevators.Add(elevators);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetElevators", new { id = elevators.Id }, elevators));
}
private void BuildHandle()
{
try
{
// Checks
if (Floors.Count < 2)
{
throw new Exception("The simulation model must have at least 2 floors");
}
if (Elevators.Count < 1)
{
throw new Exception("The simulation model must have at least 1 elevator");
}
ElevatorSimModel simModel = m_model.BuildModel(Floors.ToList(), Elevators.ToList());
simModel.Log += AddEventLog;
m_model.LinkStatistics(Floors.Count, Elevators.Count);
IsBuilded = true;
}
catch (Exception ex)
{
MessageBox.Show(ex.Message, "Error", MessageBoxButton.OK);
}
}
public async Task <IActionResult> PutmodifyElevatorsStatus(long id, [FromBody] Elevators body)
{
//check body
if (body.Status == null)
{
return(BadRequest());
}
//find corresponding elevator
var elevator = await _context.Elevators.FindAsync(id);
//change status
elevator.Status = body.Status;
try
{
//save change
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
//catch error - elevetor doesn't exist
if (!elevatorExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
//return succeed message
return(new OkObjectResult("success"));
}
/// <summary>
/// Registers and returns a new ID for an object of the given type.
/// </summary>
/// <returns>A new unique ID that can be used to identify the object.</returns>
public int RegisterElevatorID()
{
if (Elevators.Any() && _elevatorID <= Elevators.Max(e => e.ID))
{
_elevatorID = Elevators.Max(e => e.ID) + 1;
}
return(_elevatorID++);
}
PostElevator(Elevators elevator)
{
_context.Elevators.Add(elevator);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetElevator",
new { id = elevator.Id },
elevator));
}
private void InitializeElevators(int numberOfElevators, int floors)
{
this.Output.OutputLine("*** Bringing Elevators Online ***");
this.Elevators = new Dictionary <string, Elevator>();
for (int i = 1; i < numberOfElevators + 1; i++)
{
var elevator = new Elevator(string.Format("Elevator {0}", i), this.Output, floors, i);
Elevators.Add(elevator.Name, elevator);
}
}
/// <summary>
/// Creates a new elevator.
/// </summary>
/// <param name="id">The ID of the elevator.</param>
/// <returns>The newly created elevator.</returns>
public Elevator CreateElevator(int id)
{
Elevator elevator = new Elevator(this)
{
ID = id
};
elevator.Queues = new Dictionary <Waypoint, List <Waypoint> >();
Elevators.Add(elevator);
_idToElevators[elevator.ID] = elevator;
return(elevator);
}
/// <summary>
/// Find the nearest elevator from the requested floor lobby when a up/down button is pressed by a person
/// </summary>
/// <param name="floor">This is the floor number i.e. form which floor lobby the user is pressed the button. </param>
/// <param name="elevators">All availabe elevators to the Elevator system.</param>
/// <returns>Returns the nearest elevator.</returns>
public static IDictionary <Elevator, int> GetElevatorTimeMap(int requestedFloorNo)
{
var elevatorTimeMap = new Dictionary <Elevator, int>();
System.Threading.Tasks.Task task = System.Threading.Tasks.Task.Run(() => Elevators.ToList().ForEach(elevator =>
{
int t = Utility.FindTimeTaken(elevator, requestedFloorNo);
elevatorTimeMap.Add(elevator, t);
}));
task.Wait();
return(elevatorTimeMap);
}
private void ClearElevatorsHandle()
{
try
{
Elevators.Clear();
CurrentElevator.ID = 1;
OnPropertyChanged("CurrentElevator");
}
catch (Exception ex)
{
MessageBox.Show(ex.Message, "Error", MessageBoxButton.OK);
}
}
public void BuildElevators(List<ElevatorData> elevators)
{
int min, max;
foreach (ElevatorData data in elevators)
{
// Add elevator
Elevators.Add(new Elevator(data.ID, data.Capacity, data.StartFloor));
// Add distribution
min = data.Period - data.Spread;
max = data.Period + data.Spread;
ElevatorsDistr.Add(data.ID, new UniformDistribution(min, max));
}
}
public ActionResult Update(long id, Elevators elevator)
{
var elv = _context.Elevators.Find(id);
if (elv == null)
{
return(NotFound());
}
elv.Status = elevator.Status;
_context.Elevators.Update(elv);
_context.SaveChanges();
return(NoContent());
}
//public void Put(int id, [FromBody] string value)
public IActionResult Update(long id, Elevators item)
{
var change = _context.Elevators.Find(id);
if (change == null)
{
return(NotFound());
}
//change.IsComplete = item.IsComplete;
change.Status = item.Status;
_context.Elevators.Update(change);
_context.SaveChanges();
return(NoContent());
}
private void AddElevatorHandle()
{
try
{
CheckCurrentElevator();
Elevators.Add(new ElevatorData(CurrentElevator));
CurrentElevator.ID++;
OnPropertyChanged("CurrentElevator");
}
catch (Exception ex)
{
MessageBox.Show(ex.Message, "Error", MessageBoxButton.OK);
}
}
private void DeleteElevatorHandle()
{
try
{
if (Elevators.Count > 0)
{
Elevators.RemoveAt(Elevators.Count - 1);
CurrentElevator.ID--;
OnPropertyChanged("CurrentElevator");
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message, "Error", MessageBoxButton.OK);
}
}
public async Task <IActionResult> UpdateElevatorStatus([FromRoute] long id, Elevators elevator)
{
if (id != elevator.Id)
{
Console.WriteLine(elevator.Id);
return(Content("Wrong id ! please check and try again"));
}
if (elevator.ElevatorStatus == "Active" || elevator.ElevatorStatus == "Inactive" || elevator.ElevatorStatus == "Intervention")
{
_context.Entry(elevator).State = EntityState.Modified;
await _context.SaveChangesAsync();
return(Content("Elevator: " + elevator.Id + ", status as been change to: " + elevator.ElevatorStatus));
}
return(Content("Please insert a valid status : Intervention, Inactive, Active, Tray again ! "));
}
//public async Task DeleteAllAsync()
//{
// using var txn = await Db.Connection.BeginTransactionAsync();
// using var cmd = Db.Connection.CreateCommand();
// cmd.CommandText = @"DELETE FROM `rocketApp_development`";
// await cmd.ExecuteNonQueryAsync();
// await txn.CommitAsync();
//}
private async Task <List <Elevators> > ReadAllAsync(DbDataReader reader)
{
var posts = new List <Elevators>();
using (reader)
{
while (await reader.ReadAsync())
{
var post = new Elevators(Db)
{
ElevatorId = reader.GetInt32(0),
Status = reader.GetString(1),
};
posts.Add(post);
}
}
return(posts);
}
public IActionResult PutElevatorStatus(long id, Elevators item)
{
var ele = _context.Elevators.Find(id);
if (ele == null)
{
return(NotFound());
}
ele.status = item.status;
_context.Elevators.Update(ele);
_context.SaveChanges();
var jsonPut = new JObject();
jsonPut["Update"] = "Update done to elevator id : " + id + " to the status : " + ele.status;
return(Content(jsonPut.ToString(), "application/json"));
}
public async Task <IActionResult> ChangeElevatorStatus(long id, [FromBody] Elevators elevator)
{
var findElevator = await _context.Elevators.FindAsync(id);
if (elevator == null)
{
return(BadRequest());
}
if (findElevator == null)
{
return(NotFound());
}
if (elevator.Status == findElevator.Status)
{
ModelState.AddModelError("Status", "Looks like you didn't change the status.");
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
findElevator.Status = elevator.Status;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ElevatorExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public string GetOrder(int position, string direction)
{
int positionToReach = ExitPosition;
if (positionToReach == -1)
{
Elevator finalElevator = null;
if (Elevators.Count == 1)
{
finalElevator = Elevators.FirstOrDefault();
}
else
{
int minDistance = int.MaxValue;
foreach (Elevator elevator in Elevators)
{
int currentDistance = elevator.Position > position ? elevator.Position - position : position - elevator.Position;
if (currentDistance < minDistance)
{
finalElevator = elevator;
minDistance = currentDistance;
}
}
}
positionToReach = finalElevator.Position;
}
if ((positionToReach < position && direction == Direction.RIGHT) || (positionToReach > position && direction == Direction.LEFT))
{
return("BLOCK");
}
else
{
return("WAIT");
}
}
/// <summary>
/// Removes all elements in scope from the instance.
/// </summary>
/// <param name="theTier">The tier to remove the elements from.</param>
/// <param name="xMin">The min x-value of the scope.</param>
/// <param name="xMax">The max x-value of the scope.</param>
/// <param name="yMin">The min y-value of the scope.</param>
/// <param name="yMax">The max y-value of the scope.</param>
public void ModRemoveWaypoints(ITierInfo theTier, double xMin, double yMin, double xMax, double yMax)
{
Tier tier = theTier as Tier;
// Remove waypoints
List <Waypoint> remWaypoints = Waypoints.Where(w => w.Tier == tier && xMin <= w.X && w.X <= xMax && yMin <= w.Y && w.Y <= yMax).ToList();
// Remove all of them
foreach (var waypoint in remWaypoints)
{
// Remove the waypoint - the waypoint graph handles all cascading path removals
waypoint.Tier.RemoveWaypoint(waypoint);
// Remove all elements that were connected to the waypoint
foreach (var guard in Semaphores.SelectMany(s => s.Guards).Where(guard => guard.From == waypoint || guard.To == waypoint).ToArray())
{
guard.Semaphore.UnregisterGuard(guard);
if (guard.Semaphore.Guards.Count() == 0)
{
Semaphores.Remove(guard.Semaphore);
}
}
foreach (var station in InputStations.Where(s => s.Waypoint == waypoint).ToArray())
{
station.Tier.RemoveInputStation(station);
InputStations.Remove(station);
}
foreach (var station in OutputStations.Where(s => s.Waypoint == waypoint).ToArray())
{
station.Tier.RemoveOutputStation(station);
OutputStations.Remove(station);
}
foreach (var pod in Pods.Where(p => p.Waypoint == waypoint).ToArray())
{
pod.Tier.RemovePod(pod);
Pods.Remove(pod);
}
foreach (var elevator in Elevators.Where(e => e.ConnectedPoints.Contains(waypoint)))
{
elevator.UnregisterPoint(waypoint);
if (elevator.ConnectedPoints.Count == 0)
{
Elevators.Remove(elevator);
}
}
// Make sure it is not on the list of storage locations anymore
if (waypoint.PodStorageLocation)
{
ResourceManager.RemovePodStorageLocation(waypoint);
}
// Finally remove from the overall waypoint list
Waypoints.Remove(waypoint);
}
// Also remove movables in scope
List <Bot> remBots = Bots.Where(b => b.Tier == tier && xMin <= b.X && b.X <= xMax && yMin <= b.Y && b.Y <= yMax).ToList();
foreach (var bot in remBots)
{
Bots.Remove(bot);
bot.Tier.RemoveBot(bot);
}
List <Pod> remPods = Pods.Where(p => p.Tier == tier && xMin <= p.X && p.X <= xMax && yMin <= p.Y && p.Y <= yMax).ToList();
foreach (var pod in remPods)
{
Pods.Remove(pod);
pod.Tier.RemovePod(pod);
}
}
public void StartElevators()
{
Elevators.StartElevators();
}
internal void LoadPlayer(IPlayer player)
{
player.Init(Elevators.ToArray(), Floors.ToArray());
}
/// <summary>
/// Adds an elevator
/// </summary>
/// <param name="speed">Speed of the elevator in m/s</param>
/// <param name="delay">Delay between opening and closing the doors in seconds</param>
public Elevator AddElevator(double speed, double delay)
{
Elevators.Add(new Elevator(this, speed, delay));
return(Elevators[Elevators.Count - 1]);
}
