public async Task WhenRequestVehicleControllerUsingPostWithVehicleOnBody_AndRequestVehicleControllerUsingGet_ThenVerifyIfVehicleWasAdded_ThenRequestVehicleControllerUsingPutWithUpdatedVehicleOnBody_AndRequestVehicleControllerUsingGet_ThenVerifyIfVehicleWasUpdated()
{
// Arrange
var vehicle = VehicleHelper.CreateRandomVehicle();
// Act
var post_response = await client.PostAsync($"{url}",
new StringContent(JsonConvert.SerializeObject(vehicle), Encoding.UTF8, "application/json"));
Assert.AreEqual(post_response.StatusCode, System.Net.HttpStatusCode.OK);
var get_response = await client.GetAsync($"{url}/{vehicle.Id}");
Assert.AreEqual(get_response.StatusCode, System.Net.HttpStatusCode.OK);
VehicleHelper.AssertVehicle(vehicle, JsonConvert.DeserializeObject <Vehicle>(await get_response.Content.ReadAsStringAsync()));
var updatedVehicle = VehicleHelper.CreateRandomVehicle();
updatedVehicle.Id = vehicle.Id;
var put_response = await client.PutAsync($"{url}/{vehicle.Id}",
new StringContent(JsonConvert.SerializeObject(updatedVehicle), Encoding.UTF8, "application/json"));
Assert.AreEqual(put_response.StatusCode, System.Net.HttpStatusCode.OK);
get_response = await client.GetAsync($"{url}/{vehicle.Id}");
Assert.AreEqual(get_response.StatusCode, System.Net.HttpStatusCode.OK);
VehicleHelper.AssertVehicle(updatedVehicle, JsonConvert.DeserializeObject <Vehicle>(await get_response.Content.ReadAsStringAsync()));
}
public async void Get_ReturnsData()
{
// arrange
var targetId = IdentifierHelper.VehicleId;;
var errorCodeConverter = new ErrorCodeConverter();
var vehicleServiceMoq = new Mock <IVehicleService>();
vehicleServiceMoq.Setup(x => x.Get(It.IsAny <Guid>()))
.ReturnsAsync(() => new Result <Vehicle>(ResultCode.Success, TestVehicle()));
var dataStructureConverterMoq = new Mock <IDataStructureConverter>();
dataStructureConverterMoq.Setup(x => x.ConvertAndMap <VehicleModel, Vehicle>(It.IsAny <string>(), It.IsAny <Vehicle>()))
.Returns(new Dictionary <string, object>
{
{ "vehicle", VehicleHelper.Get() }
});
var sut = new VehiclesController(vehicleServiceMoq.Object, errorCodeConverter, dataStructureConverterMoq.Object)
{
ControllerContext = DefaultControllerContext()
};
// act
var result = await sut.Get(targetId);
var okResult = result as OkObjectResult;
var response = okResult.Value as Dictionary <string, object>;
// assert
Assert.NotNull(response.Values);
}
public async Task <IActionResult> RegisterMember([Bind("Personnummer,FirstName,LastName,Address,PostNumber,City,IsPro")] MembershipViewModel newMember)
{
if (ModelState.IsValid)
{
Membership member = new Membership
{
Personnummer = newMember.Personnummer,
FirstName = newMember.FirstName,
LastName = newMember.LastName,
RegistrationDate = DateTime.Now,
Birthdate = VehicleHelper.ConvertBirthdayFromPersonnummer(newMember.Personnummer),
Address = newMember.Address,
PostNumber = newMember.PostNumber,
City = newMember.City,
StayPro = newMember.StayPro,
GarageId = 1
};
dbGarage.Membership.Add(member);
await dbGarage.SaveChangesAsync();
TempData["message"] = $"Thank you, {member.FirstName} for joining our garage! Enjoy your 30 days of free Pro Membership!";
return(RedirectToAction("Index", "Home"));
}
return(View(newMember));
}
public void ProcessDataTest()
{
RoboticRover roboticNew = new RoboticRover('N', new Plateau(5, 5)
{
XAxis = 1, YAxis = 2
}); //Standard documentation test
VehicleHelper.ProcessData("LMLMLMLMM", roboticNew, originalPlateau);
RoboticRover roboticNew2 = new RoboticRover('E', new Plateau(5, 5)
{
XAxis = 3, YAxis = 3
}); //Standard documentation test
VehicleHelper.ProcessData("MMRMMRMRRM", roboticNew2, originalPlateau);
RoboticRover roboticNew3 = new RoboticRover('E', new Plateau(5, 5)
{
XAxis = 3, YAxis = 3
}); //Check for what happens if boundaries exceed
VehicleHelper.ProcessData("MMMRMMRMRRM", roboticNew3, originalPlateau);
RoboticRover roboticNew4 = new RoboticRover('E', new Plateau(5, 5)
{
XAxis = 3, YAxis = 3
}); //Check for if direction changes
VehicleHelper.ProcessData("MMMRMMRMRRMR", roboticNew4, originalPlateau);
}
public async void GetAllVehicles_WhenFound()
{
// arrange
var locationId = IdentifierHelper.LocationId;
var errorCodeConverter = new ErrorCodeConverter();
var locationServiceMoq = new Mock <ILocationService>();
locationServiceMoq.Setup(x => x.GetVehicles(It.IsAny <Guid>()))
.ReturnsAsync(() => new Result <IEnumerable <Vehicle> >(ResultCode.Success, TestVehicles()));
var dataStructureConverterMoq = new Mock <IDataStructureConverter>();
dataStructureConverterMoq.Setup(x => x.ConvertAndMap <IEnumerable <VehicleModel>, IEnumerable <Vehicle> >(It.IsAny <string>(), It.IsAny <IEnumerable <Vehicle> >()))
.Returns(new Dictionary <string, object>
{
{ "vehicles", VehicleHelper.GetMany() }
});
var sut = new LocationsController(locationServiceMoq.Object, errorCodeConverter, dataStructureConverterMoq.Object)
{
ControllerContext = DefaultControllerContext()
};
// act
var result = await sut.GetAllVehicles(locationId);
var okResult = result as OkObjectResult;
var response = okResult.Value as Dictionary <string, object>;
// assert
Assert.Equal(200, okResult.StatusCode);
}
// POST: Garages/Delete/5
//[HttpPost, ActionName("UnParked")]
//[ValidateAntiForgeryToken]
public async Task <IActionResult> UnparkVehicle(int?id)//Todo -Add to Remove action for Receipt
{
// Unpark. Updates Vehicle and ParkingPlace in db
UnparkTheVehicle(id);
//Create Receipt
ReceiptViewModel receipt = null;
var vehicle = await dbGarage.Vehicle.FindAsync(id);
if (vehicle != null)
{
var member = dbGarage.Membership
.FirstOrDefault(m => m.MembershipId == vehicle.MembershipId);
receipt = new ReceiptViewModel
{
Id = vehicle.VehicleId,
RegistrationNumber = vehicle.RegistrationNumber,
MemberNumber = member.Personnummer,
CheckIn = vehicle.CheckInTime,
StayPro = member.StayPro,
IsPro = VehicleHelper.IsPro(member),
MemberSpaces = dbGarage.Vehicle.Where(v => v.IsParked && v.MembershipId == member.MembershipId)
.Select(v => v.VehicleType.Size)
.Count()
};
dbGarage.Vehicle.Update(vehicle);
await dbGarage.SaveChangesAsync();
TempData["message"] = $"You have unparked your {vehicle.VehicleType}!";
return(View("Receipt", receipt));
}
return(View());
}
public void GetDirectionToMoveTest()
{
for (int i = 0; i < 4; i++) //One iteration for each side
{
Plateau plateau = VehicleHelper.GetDirectionToMove(robotic);
VehicleHelper.TurnVehicle(robotic, 'L');
}
}
public void TurnVehicleTest()
{
for (int i = 0; i < 4; i++) //One iteration for each side
{
VehicleHelper.TurnVehicle(robotic, 'L');
}
for (int i = 0; i < 4; i++)//One iteration for each side
{
VehicleHelper.TurnVehicle(robotic, 'R');
}
}
private bool AreAvailableSpace(Vehicle vehicle)
{
List <Vehicle> vehicles = vehicleQuery.GetAllActiveVehicles(vehicle.VehicleType);
if ((VehicleHelper.IsCar(vehicle) && vehicles.Count.Equals(20)) ||
(VehicleHelper.IsMotorcycle(vehicle) && vehicles.Count.Equals(10)))
{
errorMessage = Messages.ErrorSpaceFull;
return(false);
}
return(true);
}
public void MoveVehicleTest()
{
RoboticRover roboticNew = new RoboticRover('N', new Plateau(5, 5)
{
XAxis = 1, YAxis = 1
});
for (int i = 0; i < 4; i++)
{
VehicleHelper.MoveVehicle(roboticNew, originalPlateau);
VehicleHelper.TurnVehicle(roboticNew, 'L');
}
}
public ActionResult SearchFor(string sortOrder, string oldSortBy, string memberName)
{
List <MembersViewModel> lstMembers = null;
if (String.IsNullOrWhiteSpace(sortOrder))
{
sortOrder = "asc";
}
if (!String.IsNullOrWhiteSpace(memberName))
{
memberName = memberName.Trim();
memberName = memberName.ToLower();
ViewBag.SearchFor = memberName;
lstMembers = dbGarage.Membership.Where(r => r.FirstName.ToLower().Equals(memberName) || r.LastName.ToLower().Equals(memberName))
.Select
(m => new MembersViewModel
{
MembershipId = m.MembershipId,
FirstName = m.FirstName,
LastName = m.LastName,
Name = $"{m.FirstName} {m.LastName}",
Vehicles = m.Vehicles.Where(v => v.MembershipId == m.MembershipId).ToList(),
TotalVehicles = m.Vehicles.Count()
})
.ToList <MembersViewModel>();
}
else
{
lstMembers = dbGarage.Membership
.Select
(n => new MembersViewModel
{
MembershipId = n.MembershipId,
FirstName = n.FirstName,
LastName = n.LastName,
Name = $"{n.FirstName} {n.LastName}",
Vehicles = n.Vehicles.Where(v => v.MembershipId == n.MembershipId).ToList(),
TotalVehicles = n.Vehicles.Count()
})
.ToList <MembersViewModel>();
}
lstMembers = VehicleHelper.Sort(lstMembers, oldSortBy, sortOrder);
ViewBag.SortOrder = sortOrder;
ViewBag.OlderSortBy = oldSortBy;
return(View("Members", lstMembers));
}
public void CheckForBoundaries()
{
RoboticRover roboticNew = new RoboticRover('N', new Plateau(5, 5)
{
XAxis = 1, YAxis = 1
});
Plateau plateau = VehicleHelper.GetDirectionToMove(robotic);
for (int i = 0; i < 4; i++)//One iteration for each side
{
VehicleHelper.CheckForBoundaries(roboticNew.CurrentCoordinates(), plateau, originalPlateau);
plateau = TurnAndGetDirection(robotic);
}
}
private void UpdateSteeringAngle(float deltaTime)
{
// TODO: Reduce max steering angle at high speeds.
const float MaxAngle = 0.5f;
const float SteeringRate = 3;
// We limit the amount of change per frame.
float change = SteeringRate * deltaTime;
float direction = 0;
if (_inputService.IsDown(Keys.A))
{
direction += 1;
}
if (_inputService.IsDown(Keys.D))
{
direction -= 1;
}
var gamePadState = _inputService.GetGamePadState(LogicalPlayerIndex.One);
direction -= gamePadState.ThumbSticks.Left.X;
if (direction != 0)
{
// Increase steering angle.
_steeringAngle = MathHelper.Clamp(_steeringAngle + direction * change, -MaxAngle, +MaxAngle);
}
else
{
// Steer back to neutral position (angle 0).
if (_steeringAngle > 0)
{
_steeringAngle = MathHelper.Clamp(_steeringAngle - change, 0, +MaxAngle);
}
else if (_steeringAngle < 0)
{
_steeringAngle = MathHelper.Clamp(_steeringAngle + change, -MaxAngle, 0);
}
// TODO: Maybe we steer back with half rate?
// (Pressing a button steers faster than not pressing a button?)
}
VehicleHelper.SetCarSteeringAngle(_steeringAngle, Vehicle.Wheels[0], Vehicle.Wheels[1], Vehicle.Wheels[2], Vehicle.Wheels[3]);
}
public bool GetVehicleCheckOut(ref Vehicle vehicle, out string errorMessage)
{
errorMessage = string.Empty;
vehicle = GetVehicle(vehicle.Id);
if (IsActiveVehicle(vehicle.Id))
{
vehicle.Payment = CalculatePayment(vehicle);
vehicle.DepartureTime = dateTimeHelper.GetDateTimeNow();
vehicle.State = VehicleHelper.SetActive();
bool vehicleRegisteredSuccess = vehicleQuery.CheckOutVehicle(vehicle);
return(vehicleRegisteredSuccess);
}
this.errorMessage = Messages.ErrorVehicleAlreadyCheckOut;
errorMessage = this.errorMessage;
return(false);
}
private int CalculatePayment(Vehicle vehicle)
{
int payment = 0;
int differenceHours = Convert.ToInt32(Math.Ceiling((dateTimeHelper.GetDateTimeNow() - vehicle.EntryTime).TotalHours));
if (differenceHours >= 9)
{
payment = CalculatePaymentParkingDays(vehicle, differenceHours);
}
else
{
payment = GetPaymentParkingHours(vehicle, differenceHours);
}
payment = VehicleHelper.IsMotorcycle(vehicle) && vehicle.Displacement > 500 ?
payment + VehicleHelper.GetExtraCostMotorcycleHigher500Displacement() :
payment;
return(payment);
}
public ActionResult Sort(string sortBy, string sortOrder, string firstName)
{
List <MembersViewModel> lsMembers = null;
if (String.IsNullOrWhiteSpace(sortOrder))
{
sortOrder = "asc";
}
lsMembers = dbGarage.Membership
.Select
(n => new MembersViewModel
{
MembershipId = n.MembershipId,
FirstName = n.FirstName,
LastName = n.LastName,
Name = $"{n.FirstName} {n.LastName}",
Vehicles = n.Vehicles.Where(v => v.MembershipId == n.MembershipId).ToList()
})
.ToList <MembersViewModel>();
// Sort list with vehicle
lsMembers = VehicleHelper.Sort(lsMembers, sortBy, sortOrder);
// Now set up sortOrder for next postback
if (sortOrder.Equals("desc"))
{
sortOrder = "asc";
}
else
{
sortOrder = "desc";
}
// Set ViewBags
ViewBag.SortOrder = sortOrder;
ViewBag.OldSortBy = sortBy;
return(View("Members", lsMembers));
}
public async Task WhenRequestVehicleControllerUsingPost_AndRequestVehicleControllerUsingGetWithId_ThenICheckIfVehicleWasAddedCorrectly()
{
// Arrange
var vehicle = VehicleHelper.CreateRandomVehicle();
// Act
var post_response = await client.PostAsync($"{url}",
new StringContent(JsonConvert.SerializeObject(vehicle), Encoding.UTF8, "application/json"));
Assert.AreEqual(post_response.StatusCode, System.Net.HttpStatusCode.OK);
var get_response = await client.GetAsync($"{url}/{vehicle.Id}");
Assert.AreEqual(get_response.StatusCode, System.Net.HttpStatusCode.OK);
// Assert
var vehicleReceived = JsonConvert.DeserializeObject <Vehicle>(await get_response.Content.ReadAsStringAsync());
VehicleHelper.AssertVehicle(vehicle, vehicleReceived);
}
public void GetDirectionToTurnTest()
{
char direction = VehicleHelper.GetDirectionToTurn(robotic, 'L');
robotic.Turn('W');
direction = VehicleHelper.GetDirectionToTurn(robotic, 'L');
robotic.Turn('S');
direction = VehicleHelper.GetDirectionToTurn(robotic, 'L');
robotic.Turn('E');
direction = VehicleHelper.GetDirectionToTurn(robotic, 'L');
robotic.Turn('N');
direction = VehicleHelper.GetDirectionToTurn(robotic, 'R');
robotic.Turn('E');
direction = VehicleHelper.GetDirectionToTurn(robotic, 'R');
robotic.Turn('S');
direction = VehicleHelper.GetDirectionToTurn(robotic, 'R');
robotic.Turn('W');
direction = VehicleHelper.GetDirectionToTurn(robotic, 'R');
robotic.Turn('N');
}
private async void LoadMotorcycles()
{
var response = await this.vehicleBusinessLogic.GetAllActiveVehicles(VehicleEnumerator.VehicleTypes.motorcycle.ToString());
if (!response.IsSuccess)
{
this.IsRefreshing = false;
await Application.Current.MainPage.DisplayAlert(
"Error",
response.Message,
"Aceptar");
return;
}
this.vehiclesList = (List <Vehicle>)response.Result;
this.Vehicles = new ObservableCollection <VehicleItemViewModel>(
VehicleHelper.ToVehicleItemViewModel(this.vehiclesList)
);
this.IsRefreshing = false;
}
//List of things that can be spawned : https://subnauticacommands.com/items
public void Spawn(GameObject gameObject)
{
TechType techType = CraftData.GetTechType(gameObject);
try
{
if (VehicleHelper.IsVehicle(techType))
{
SpawnVehicle(gameObject);
}
else
{
SpawnItem(gameObject);
//TODO: Add support for no AI creature that need to be spawned as well
}
}
catch (Exception ex)
{
Log.Error(ex, $"Error while trying to spawn {techType} from devconsole");
}
}
public async Task <int> Handle(CreateOrderingCommand request, CancellationToken cancellationToken)
{
if (await VehicleHelper.IsVehicleBusy(request.VehicleId, _context))
{
throw new ConflictException("Vehicle is currently participating in another project");
}
var project = new Domain.Entities.Ordering
{
OwnerUserId = request.OwnerUserId,
VehicleId = request.VehicleId,
OrderingStatusId = 10,
CreatedDate = DateTime.UtcNow,
StartDirection = _mapper.Map <Domain.Entities.Direction>(request.StartDirection),
EndDirection = _mapper.Map <Domain.Entities.Direction>(request.EndDirection)
};
await _context.Ordering.AddAsync(project);
await _context.SaveChangesAsync(cancellationToken);
return(project.OrderingId);
}
public async Task <int> Handle(CreateVehicleCommand request, CancellationToken cancellationToken)
{
if (await VehicleHelper.IsVehicleNumberOccupied(request.Number, _context))
{
throw new ConflictException("Vehicle number is occupied!");
}
var vehicle = new Domain.Entities.Vehicle
{
OwnerUserId = request.OwnerUserId,
Brand = request.Brand,
Model = request.Model,
Year = request.Year,
Number = request.Number,
Country = request.Country
};
await _context.Vehicle.AddAsync(vehicle);
await _context.SaveChangesAsync(cancellationToken);
return(vehicle.VehicleId);
}
async void Page_Loaded(object sender, RoutedEventArgs e)
{
VehicleHelper vh = new VehicleHelper();
var vehiclesList = await vh.GetAllAsync();
VehiclesComboBox.ItemsSource = vehiclesList;
}
private void Setup()
{
name = "CustomizeItVehicleExtendedPanel";
isVisible = false;
canFocus = true;
isInteractive = true;
relativePosition = new Vector3(0f, UiVehicleTitleBar.Instance.height);
width = parent.width;
var fields = SelectedVehicle.GetType().GetFields();
var fieldsToRetrieve = typeof(CustomVehicleProperties).GetFields().Select(x => x.Name);
Inputs = new List <UIComponent>();
_labels = new List <UILabel>();
var widestWidth = 0f;
foreach (var field in fields.Where(x => fieldsToRetrieve.Contains(x.Name)))
{
var label = AddUIComponent <UILabel>();
label.name = field.Name + "Label";
label.text = UiUtils.FieldNames[field.Name];
label.textScale = 0.9f;
label.isInteractive = false;
if (field.FieldType == typeof(float) || field.FieldType == typeof(int))
{
Inputs.Add(UiUtils.CreateVehicleTextField(this, field.Name));
_labels.Add(label);
}
else if (field.FieldType == typeof(bool))
{
Inputs.Add(UiUtils.CreateVehicleCheckBox(this, field.Name));
_labels.Add(label);
}
if (label.width + UiUtils.FieldWidth + UiUtils.FieldMargin * 6 > widestWidth)
{
widestWidth = label.width + UiUtils.FieldWidth + UiUtils.FieldMargin * 6;
}
}
if (!CustomizeItExtendedMod.Settings.OverrideAVO)
{
foreach (var input in Inputs)
{
if (!AdvancedVehicleOptionsCompatibilityPatch.IsAVOActive() ||
!AdvancedVehicleOptionsCompatibilityPatch.AVOFields.Contains(input.name))
{
continue;
}
input.isEnabled = false;
input.isInteractive = false;
if (input is UITextField textField)
{
textField.text = "DISABLED";
}
if (input is UICheckBox checkbox)
{
checkbox.enabled = false;
checkbox.isInteractive = false;
checkbox.disabledColor = Color.gray;
}
}
}
Inputs.Add(UiUtils.CreateNameTextfield(this, "DefaultName", (component, value) =>
{
if (!string.IsNullOrEmpty(value))
{
if (CustomizeItExtendedVehicleTool.instance.CustomVehicleNames.TryGetValue(SelectedVehicle.name,
out var props))
{
props.CustomName = value;
props.DefaultName = true;
}
else
{
CustomizeItExtendedVehicleTool.instance.CustomVehicleNames.Add(SelectedVehicle.name,
new NameProperties(value, true));
}
}
else
{
if (CustomizeItExtendedVehicleTool.instance.CustomVehicleNames.TryGetValue(SelectedVehicle.name,
out var _))
{
CustomizeItExtendedVehicleTool.instance.CustomVehicleNames.Remove(SelectedVehicle.name);
}
}
if (!CustomizeItExtendedMod.Settings.SavePerCity)
{
CustomizeItExtendedMod.Settings.Save();
}
}, CustomizeItExtendedVehicleTool
.instance.CustomVehicleNames.TryGetValue(SelectedVehicle.name, out var customName)
? customName.CustomName
: string.Empty));
var nameLabel = AddUIComponent <UILabel>();
nameLabel.name = "DefaultNameLabel";
nameLabel.text = "Default Name";
nameLabel.textScale = 0.9f;
nameLabel.isInteractive = false;
if (nameLabel.width + UiUtils.FieldWidth + UiUtils.FieldMargin * 6 > widestWidth)
{
widestWidth = nameLabel.width + UiUtils.FieldWidth + UiUtils.FieldMargin * 6;
}
_labels.Add(nameLabel);
Inputs.Sort((x, y) => x.name.CompareTo(y.name));
_labels.Sort((x, y) => x.name.CompareTo(y.name));
Inputs.Add(UiUtils.CreateVehicleResetButton(this));
Inputs.Add(UiUtils.CreateDropdown(this, "SelectedVehicle", VehicleHelper.GetAllVehicleNames().ToArray(),
(component, value) =>
{
var newVehicle = VehicleHelper.GetAllVehicles()
.Find(x =>
x.name == VehicleHelper.RetrieveOriginalVehicleName(((UIDropDown)component).items[value]));
UiUtils.DeepDestroy(CustomizeItExtendedVehicleTool.instance.VehiclePanelWrapper);
CustomizeItExtendedVehicleTool.instance.SelectedVehicle = newVehicle;
newVehicle.GenerateVehiclePanel();
}, VehicleHelper.RetrieveCurrentVehicleName(SelectedVehicle)));
width = UIVehiclePanelWrapper.Instance.width =
UiVehicleTitleBar.Instance.width = UiVehicleTitleBar.Instance.DragHandle.width = widestWidth;
UiVehicleTitleBar.Instance.RecenterElements();
Align();
Inputs.Find(x => x.name == "SelectedVehicle").relativePosition = new Vector3(12,
Inputs.Find(x => x.name == "CustomizeItExtendedVehicleResetButton").relativePosition.y);
height = Inputs.Count * (UiUtils.FieldHeight + UiUtils.FieldMargin) + UiUtils.FieldMargin * 3;
UIVehiclePanelWrapper.Instance.height = height + UiVehicleTitleBar.Instance.height;
UIVehiclePanelWrapper.Instance.relativePosition = new Vector3(CustomizeItExtendedMod.Settings.PanelX,
CustomizeItExtendedMod.Settings.PanelY);
isVisible = UIVehiclePanelWrapper.Instance.isVisible =
UiVehicleTitleBar.Instance.isVisible = UiVehicleTitleBar.Instance.DragHandle.isVisible = true;
}
/// <summary>
/// Method get a list of vehicle and information for the parked vehicle list
/// </summary>
/// <param name="iGarageId">Garage id</param>
/// <returns>List of GarageVehiclesInfoViewModel objects</returns>
private async Task <List <GarageVehiclesInfoViewModel> > GetParkedVehiclelist(int iGarageId)
{
var garage = await dbGarage.Garage.AsNoTracking().Where(i => i.GarageId == iGarageId).FirstOrDefaultAsync();
var members = await dbGarage.Membership.AsNoTracking().Where(i => i.GarageId == iGarageId).ToListAsync();
int iNumberOfOccupiedParkingPlaces = await dbGarage.ParkingPlace.Where(g => g.GarageId == garage.GarageId && g.IsOccupied).CountAsync();
var vehicleTypes = await dbGarage.VehicleType.AsNoTracking().ToListAsync();
// TODO Check if algo is ok in another test project
// Now i want to know a members type of membership
foreach (var member in members)
{
member.TypeOfMembersShip = MemberShipHelper.GetTypeOfMemberShip(member);
}
var results = await dbGarage.ParkingPlace
.Join(
dbGarage.Vehicle,
parkingPlace => parkingPlace.ParkingPlaceId,
vehicle => vehicle.ParkingPlaceId,
(parkingPlace, vehicle) => new GarageVehiclesInfoViewModel
{
VehicleId = vehicle.VehicleId,
RegistrationNumber = vehicle.RegistrationNumber,
CheckInTime = vehicle.CheckInTime,
CheckOutTime = DateTime.Now,
IsParked = vehicle.IsParked,
VehicleTypeId = vehicle.VehicleTypeId,
VehicleType = String.Empty,
MemberShipId = vehicle.MembershipId,
Make = vehicle.Make,
Model = vehicle.Model,
Year = vehicle.Year,
ParkingPlaceId = parkingPlace.ParkingPlaceId,
GarageId = parkingPlace.GarageId
})
.Where(n => n.GarageId == iGarageId && n.IsParked == true)
.ToListAsync();
// Get data i dident get in the join
Membership memberShip = null;
VehicleType vehicleType = null;
foreach (var result in results)
{
// Get members first and last name
memberShip = members.Where(m => m.MembershipId == result.MemberShipId).FirstOrDefault();
if (memberShip != null)
{
result.MemberFirstName = memberShip.FirstName;
result.MemberLastName = memberShip.LastName;
}
// Get the vehicle type
vehicleType = vehicleTypes.Where(v => v.VehicleTypeId == result.VehicleTypeId).FirstOrDefault();
if (vehicleType != null)
{
result.VehicleType = vehicleType.Type_Name;
}
result.ParkedTime = VehicleHelper.CalculateParkedTime(result.CheckInTime);
}
return(results);
}
//We need to get TechType from parameters because CraftData can't resolve TechType.Cyclops by himself
public VehicleModel BuildVehicleModelFrom(GameObject gameObject, TechType techType)
{
if (VehicleHelper.IsVehicle(techType))
{
List <InteractiveChildObjectIdentifier> childIdentifiers = VehicleChildObjectIdentifierHelper.ExtractInteractiveChildren(gameObject);
Optional <Vehicle> opvehicle = Optional.OfNullable(gameObject.GetComponent <Vehicle>());
NitroxId constructedObjectId = NitroxEntity.GetId(gameObject);
NitroxVector3[] hsb = VehicleHelper.GetPrimalDefaultColours();
string name = string.Empty;
float health = 200f;
if (opvehicle.HasValue)
{ //Seamoth & Exosuit
Optional <LiveMixin> livemixin = Optional.OfNullable(opvehicle.Value.GetComponent <LiveMixin>());
if (livemixin.HasValue)
{
health = livemixin.Value.health;
}
name = opvehicle.Value.GetName();
if (techType == TechType.Exosuit)
{ //For odd reasons the default colors aren't set yet for exosuit so we force it
opvehicle.Value.ReflectionCall("RegenerateRenderInfo", false, false);
}
hsb = opvehicle.Value.subName.AliveOrNull()?.GetColors().ToDto();
}
else
{ //Cyclops
try
{
GameObject target = NitroxEntity.RequireObjectFrom(constructedObjectId);
SubNameInput subNameInput = target.RequireComponentInChildren <SubNameInput>();
SubName subNameTarget = (SubName)subNameInput.ReflectionGet("target");
name = subNameTarget.GetName();
hsb = subNameTarget.AliveOrNull()?.GetColors().ToDto();
Optional <LiveMixin> livemixin = Optional.OfNullable(target.GetComponent <LiveMixin>());
if (livemixin.HasValue)
{
health = livemixin.Value.health;
}
}
catch (Exception ex)
{
Log.Error($"{nameof(Vehicles)}: Error while trying to spawn a cyclops ({constructedObjectId})", ex);
}
}
return(VehicleModelFactory.BuildFrom(
techType.ToDto(),
constructedObjectId,
gameObject.transform.position.ToDto(),
gameObject.transform.rotation.ToDto(),
childIdentifiers,
Optional.Empty,
name,
hsb ?? VehicleHelper.GetDefaultColours(techType), //Shouldn't be null now, but just in case
health
));
}
else
{
Log.Error($"{nameof(Vehicles)}: Impossible to build from a non-vehicle GameObject (Received {techType})");
}
return(null);
}
private string CreatePostData(string name)
{
string type = VehicleHelper.GetVehicleType(name);
return(DataOpener + type + DataPart2 + name);
}
private IEnumerable <Vehicle> TestVehicles()
{
return(VehicleHelper.GetMany());
}
public Plateau TurnAndGetDirection(IVehicle vehicle)
{
VehicleHelper.TurnVehicle(robotic, 'L');
return(VehicleHelper.GetDirectionToMove(robotic));
}
private Vehicle TestVehicle()
{
return(VehicleHelper.Get());
}
