private async Task PerformRoute(ElevatorModel elevator, int startFloor, int targetFloor)
{
await PerformSingleWayRoute(elevator, startFloor);
await PerformSingleWayRoute(elevator, targetFloor);
elevatorPoolService.ReleaseElevator(elevator.Id);
}
private async Task LockDoorInternalAsync(ElevatorModel elevator)
{
elevator.IsDoorLocked = true;
elevatorEventLogService.LogEvent(elevator, "Door locked");
await Task.Delay(Constant.DoorOperationTimeInMiliseconds);
}
public Task UnlockDoorAsync(ElevatorModel elevator)
{
if (elevator == null)
{
throw new ArgumentNullException(nameof(elevator));
}
return(UnlockDoorInternalAsync(elevator));
}
public void GetStatus_WhenElevatorProvided_ShouldReturnStatus()
{
// Arrange
var elevator = new ElevatorModel();
var readOnlyElevator = new ReadOnlyElevatorModel(elevator);
// Act
var result = sut.GetStatus(readOnlyElevator);
// Assert
Assert.IsFalse(string.IsNullOrWhiteSpace(result));
}
private void InitializeElevators(uint numberOfElevators)
{
for (var i = 0; i < numberOfElevators; i++)
{
var elevator = new ElevatorModel
{
Id = i
};
allElevators.Add(elevator.Id, elevator);
freeElevators.TryAdd(elevator.Id, elevator);
}
}
public void LogEvent_WhenArgumentsProvided_LogsNewEvent()
{
// Arrange
var elevator = new ElevatorModel();
var subject = "Test purposes subject";
// Act
sut.LogEvent(elevator, subject);
// Assert
Assert.AreEqual("Test purposes subject", elevator.Events.First().Subject);
Assert.AreNotEqual(0L, elevator.Events.First().TimeStamp);
}
public void LogEvent(ElevatorModel elevator, string subject)
{
if (elevator == null)
{
throw new ArgumentNullException();
}
elevator.Events.Add(new ElevatorEvent
{
Subject = subject,
TimeStamp = TimeStampHelper.GetCurrentTimeStamp()
});
}
private async Task PerformSingleWayRoute(ElevatorModel elevator, int targetFloor)
{
if (elevator.CurrentFloor == targetFloor)
{
return;
}
await elevatorControlService.LockDoorAsync(elevator);
await elevatorControlService.GoToFloorAsync(elevator, targetFloor);
await elevatorControlService.UnlockDoorAsync(elevator);
}
public Task GoToFloorAsync(ElevatorModel elevator, int targetFloor)
{
if (elevator == null)
{
throw new ArgumentNullException(nameof(elevator));
}
if (!routeValidationService.IsFloorNumberCorrect(targetFloor))
{
throw new ArgumentOutOfRangeException(nameof(targetFloor));
}
return(GoToFloorInternalAsync(elevator, targetFloor));
}
public async Task UnlockDoorAsync_WhenDoorUnlocked_UnlocksDoor()
{
// Arrange
var elevator = new ElevatorModel
{
IsDoorLocked = false
};
// Act
await sut.UnlockDoorAsync(elevator);
// Assert
Assert.IsFalse(elevator.IsDoorLocked);
elevatorEventLogServiceMock.Verify(x => x.LogEvent(It.IsAny <ElevatorModel>(), It.IsAny <string>()), Times.Once);
}
public async Task GoToFloorAsync_WhenTargetFloorIsCurrentFloor_DoesNotMoveElevator()
{
// Arrange
routeValidationServiceMock
.Setup(x => x.IsFloorNumberCorrect(It.IsAny <int>()))
.Returns(true);
var elevator = new ElevatorModel
{
CurrentFloor = 2
};
// Act
await sut.GoToFloorAsync(elevator, 2);
// Assert
Assert.AreEqual(2, elevator.CurrentFloor);
}
public async Task GoToFloorAsync_WhenArgumentsAreFine_MovesElevatorDown()
{
// Arrange
routeValidationServiceMock
.Setup(x => x.IsFloorNumberCorrect(It.IsAny <int>()))
.Returns(true);
var elevator = new ElevatorModel
{
CurrentFloor = 2
};
// Act
await sut.GoToFloorAsync(elevator, 1);
// Assert
Assert.AreEqual(1, elevator.CurrentFloor);
elevatorEventLogServiceMock.Verify(x => x.LogEvent(It.IsAny <ElevatorModel>(), It.IsAny <string>()), Times.Once);
}
private async Task GoToFloorInternalAsync(ElevatorModel elevator, int targetFloor)
{
var floorsToGo = targetFloor - elevator.CurrentFloor;
var isGoingUp = floorsToGo > 0;
elevator.IsMoving = true;
elevator.IsGoingUp = isGoingUp;
while (elevator.CurrentFloor != targetFloor)
{
await Task.Delay(Constant.MovementPerFloorTimeInMiliseconds);
var previousFloor = elevator.CurrentFloor;
elevator.CurrentFloor += isGoingUp ? 1 : -1;
elevatorEventLogService.LogEvent(elevator, $"Changed floor from {previousFloor} to {elevator.CurrentFloor}");
}
elevator.IsMoving = false;
}
// GET: Elevator/Edit/5
public ActionResult Edit(int id)
{
ElevatorBusiness elevatorBusiness = new ElevatorBusiness(new ElevatorDataAccess());
LookupBusiness lookupBusiness = new LookupBusiness(new LookupDataAccess());
ElevatorCoreModel.Elevator elevator = elevatorBusiness.GetElevator(id);
ElevatorModel elevatorModel = new ElevatorModel
{
ElevatorName = elevator.ElevatorName,
CreatedByUserId = elevator.CreatedByUserId,
MainStatus = (Enums.MainStatus)Enum.Parse(typeof(Enums.MainStatus), lookupBusiness.GetLookupValue(elevator.MainStatusId)),
ModifiedByUserId = elevator.ModifiedByUserId,
ModifiedDate = elevator.ModifiedDate,
MaxWeight = elevator.MaxWeight,
FloorDuration = elevator.FloorDuration,
CreatedDate = elevator.CreatedDate,
ElevatorId = elevator.ElevatorId
};
return(View(elevatorModel));
}
// GET: Elevator
public ActionResult Index()
{
ElevatorBusiness elevatorBusiness = new ElevatorBusiness(new ElevatorDataAccess());
LookupBusiness lookupBusiness = new LookupBusiness(new LookupDataAccess());
List <ElevatorCoreModel.Elevator> elevatorList = elevatorBusiness.GetElevators();
List <ElevatorModel> elevatorModelList = new List <ElevatorModel>();
foreach (var elevator in elevatorList)
{
ElevatorModel elevatorModel = new ElevatorModel
{
ElevatorId = elevator.ElevatorId,
ElevatorName = elevator.ElevatorName,
FloorDuration = elevator.FloorDuration,
MaxWeight = elevator.MaxWeight,
MainStatus = (Enums.MainStatus)Enum.Parse(typeof(Enums.MainStatus), lookupBusiness.GetLookupValue(elevator.MainStatusId)),
};
elevatorModelList.Add(elevatorModel);
}
return(View(elevatorModelList));
}
public ActionResult Index()
{
ElevatorBusiness elevatorBusiness = new ElevatorBusiness(new ElevatorDataAccess());
LookupBusiness lookupBusiness = new LookupBusiness(new LookupDataAccess());
FloorBusiness floorBusiness = new FloorBusiness(new FloorDataAccess());
List <ElevatorCoreModel.Elevator> elevatorList = elevatorBusiness.GetElevators();
List <Floor> floorList = floorBusiness.GetFloors();
List <ElevatorModel> elevatorModelList = new List <ElevatorModel>();
foreach (ElevatorCoreModel.Elevator elevator in elevatorList)
{
ElevatorModel elevatorModel = new ElevatorModel
{
ElevatorId = elevator.ElevatorId,
ElevatorName = elevator.ElevatorName,
FloorDuration = elevator.FloorDuration,
MainStatus = (Enums.MainStatus)Enum.Parse(typeof(Enums.MainStatus), lookupBusiness.GetLookupValue(elevator.MainStatusId)),
MaxWeight = elevator.MaxWeight
};
elevatorModelList.Add(elevatorModel);
}
List <FloorModel> floorModelList = new List <FloorModel>();
foreach (Floor floor in floorList)
{
FloorModel floorModel = new FloorModel
{
FloorId = floor.FloorId,
FloorName = floor.FloorName,
CreatedDate = floor.CreatedDate,
CreatedByUserId = floor.CreatedByUserId,
ModifiedByUserId = floor.ModifiedByUserId,
ModifiedDate = floor.ModifiedDate
};
floorModelList.Add(floorModel);
}
ViewBag.elevatorList = elevatorModelList;
ViewBag.floorList = floorModelList;
return(View());
}
public void GetEventLog_WhenElevatorProvided_ReturnsEventLog()
{
// Arrange
var elevator = new ElevatorModel()
{
Events = new List <ElevatorEvent>
{
new ElevatorEvent
{
Subject = "Test purposes subject",
TimeStamp = 1,
}
}
};
var readOnlyElevator = new ReadOnlyElevatorModel(elevator);
// Act
var result = sut.GetEventLog(readOnlyElevator);
// Assert
Assert.IsTrue(result.Contains("1") && result.Contains("Test purposes subject"));
}
public ActionResult DisplayElevatoBlock(ElevatorModel elevatorModel)
{
return(PartialView("_ElevatorBlock", elevatorModel));
}
public static ElevatorModel BuildElevator(Pointf elevatorPosition, float elevatorWidth, float maxMovementHeight, ref MapModel map)
{
ElevatorModel elev = new ElevatorModel(map.Game, elevatorWidth, maxMovementHeight, elevatorPosition);
map.AddComponent(elev);
return elev;
}
public static void RegisterSwitchToElevator(ref SwitchModel sw, ref ElevatorModel elev)
{
elev.RegisterSwitch(ref sw);
}
public IActionResult CallElevator(ElevatorModel model)
{
List <Elevator> closestElevatorList = new List <Elevator>();
Elevator closestElevator = new Elevator();
closestElevatorList = model.ElevatorList.OrderBy(x => x.ElevatorDistance).ToList();
if (closestElevatorList.FirstOrDefault().ElevatorDistance == 0) //End if an elevator is already on the correct floor
{
return(PartialView("Home/ElevatorPartial.cshtml", model));
}
for (int j = 0; j < closestElevatorList.Count; j++) //Adding distance if elevator is not going in the correct direction
{
if (model.CurrentFloor > closestElevatorList[j].ElevatorCurrentFloor)
{
if (!closestElevatorList[j].ElevatorGoingUp)
{
closestElevatorList[j].ElevatorDistance = closestElevatorList[j].ElevatorDistance + 3;
}
}
else if (model.CurrentFloor < closestElevatorList[j].ElevatorCurrentFloor)
{
if (closestElevatorList[j].ElevatorGoingUp)
{
closestElevatorList[j].ElevatorDistance = closestElevatorList[j].ElevatorDistance + 3;
}
}
}
closestElevator = closestElevatorList.OrderBy(x => x.ElevatorDistance)
.Where(x => x.ElevatorFull.Equals(false))
.Where(x => x.ElevatorBorked.Equals(false))
.Where(x => x.ElevatorInRange.Equals(true))
.FirstOrDefault(); //Getting closest elevator, also making sure elevator is not broken and is in range
for (int i = 0; i < model.ElevatorList.Count; i++)
{
if (model.ElevatorList[i].ElevatorID == closestElevator.ElevatorID)
{
int direction = model.ElevatorList[i].ElevatorCurrentFloor - model.CurrentFloor; //setting correct direction of elevator
if (direction > 0)
{
model.ElevatorList[i].ElevatorGoingUp = true;
}
else
{
model.ElevatorList[i].ElevatorGoingUp = false;
}
model.ElevatorList[i].ElevatorCurrentFloor = model.CurrentFloor;
model.ElevatorList[i].ElevatorOpen = true;
model.ElevatorList[i].ElevatorGoingUp = model.CallUp;
}
else
{
//Getting total distance all elevators travel, assuming they all travel at the same speed and continue in the direction they were going
if (!model.ElevatorList[i].ElevatorBorked)
{//broken elevators don't move
model.ElevatorList[i] = ElevatorTravel(model.ElevatorList[i], closestElevator.ElevatorDistance);
if (model.ElevatorList[i].ElevatorCurrentFloor == model.CurrentFloor)
{
model.ElevatorList[i].ElevatorOpen = true;
}
}
}
}
return(PartialView("~/Views/Home/ElevatorPartial.cshtml", model));
}
public IActionResult Elevator(ElevatorModel model) //randomising locations and stats of 6 different elevators
{
model.ElevatorCount = 1;
model.FloorCount = random.Next(10, 100);
model.CurrentFloor = random.Next(model.FloorCount);
model.ElevatorList = new List <Elevator>();
for (int i = 0; i < 6; i++)
{
Elevator elevator = new Elevator();
int elevatorDirection = random.Next(2);
elevator.ElevatorCurrentFloor = random.Next(0, model.FloorCount);
elevator.ElevatorGoingUp = Convert.ToBoolean(elevatorDirection);
elevator.ElevatorID = i;
elevator.ElevatorDistance = Convert.ToUInt32(Math.Abs(model.CurrentFloor - elevator.ElevatorCurrentFloor)); //getting absolute value of distance between floor and elevator
elevator.ElevatorOpen = false;
if (elevator.ElevatorDistance == 0)
{
elevator.ElevatorOpen = true;
}
elevator.ElevatorBorked = false;
elevator.ElevatorFull = false;
int borkChance = random.Next(19); //5% chance of elevator being broken
if (borkChance == 1)
{
elevator.ElevatorBorked = true;
}
int fullChance = random.Next(9);//10% chance of elevator being full
if (fullChance == 1)
{
elevator.ElevatorFull = true;
}
int rangeChance = random.Next(9);//10% chance of elevator only going between certain floors
if (rangeChance == 1)
{
elevator.ElevatorBottomFloor = random.Next(0, model.FloorCount - 10);
elevator.ElevatorTopFloor = random.Next(elevator.ElevatorBottomFloor + 10, model.FloorCount);
}
else
{
elevator.ElevatorBottomFloor = 0;
elevator.ElevatorTopFloor = model.FloorCount;
}
if (model.CurrentFloor >= elevator.ElevatorBottomFloor && model.CurrentFloor <= elevator.ElevatorTopFloor)
{
elevator.ElevatorInRange = true;
}
model.ElevatorList.Add(elevator);
}
return(View(model));
}
