public void UpdateVehicleMake_ShouldReturnNewVehicleYear()
{
using (var context = new VehicleContext())
{
//Arrange
VehicleCRUDService vs = new VehicleCRUDService(context);
var newYear = 2019;
var vehicle = vs.CreateVehicle(new Vehicle
{
Make = "Audi",
Model = "Etron",
Year = 2020
});
context.SaveChanges();
//Act
var stored = context.Vehicles.Where(v => v.Id == vehicle.Id).FirstOrDefault();
stored.Year = newYear;
var updated = vs.UpdateVehicle(stored);
//Assert
Assert.AreEqual(newYear, updated.Year);
}
}
protected override void SetActive(ActiveSetting activeSetting)
{
var vehicle = activeSetting.Vehicle;
var active = activeSetting.Active;
vehicle.SetActive(active);
if (active)
{
if (_isPredictMode)
{
NotifyVehicleActive(vehicle);
}
else
{
var selfEntity = PlayerContext.flagSelfEntity;
if (selfEntity.IsOnVehicle() &&
vehicle == VehicleContext.GetEntityWithEntityKey(selfEntity.controlledVehicle.EntityKey))
{
NotifyVehicleActive(vehicle);
}
}
vehicle.SetLodLevel(activeSetting.LowLod);
}
}
private static VehicleEntity GetVehicleByHierachy(PlayerEntity player, VehicleContext context)
{
VehicleEntity vehicle = null;
if (player.IsOnVehicle())
{
var controlledEntity = player.controlledVehicle;
vehicle = context.GetEntityWithEntityKey(controlledEntity.EntityKey);
}
else
{
var transform = player.RootGo().transform.parent;
while (transform != null)
{
if (transform.GetComponent <VehicleCommonController>() != null)
{
var reference = transform.GetComponent <EntityReference>();
if (reference != null)
{
vehicle = (VehicleEntity)reference.Reference;
}
break;
}
transform = transform.parent;
}
}
return(vehicle);
}
public IHttpActionResult CreateVehicle([FromBody] Vehicle vehicle)
{
using (var dbcontext = new VehicleContext())
{
var vehicleService = new VehicleCRUDService(dbcontext);
try
{
var v = vehicleService.ExistingVehicle(vehicle);
if (v == true)
{
return(Content(HttpStatusCode.Conflict, "Vehicle already exists"));
}
else
{
var vehicleHelper = new VehicleHelperService();
bool validation = vehicleHelper.VehicleDataValidator(vehicle);
if (validation == false)
{
return(Content(HttpStatusCode.Forbidden, vehicleHelper.errorMsg));
}
else
{
var newVehicle = vehicleService.CreateVehicle(vehicle);
dbcontext.SaveChanges();
return(Content(HttpStatusCode.OK, newVehicle));
}
}
}
catch (Exception)
{
return(Content(HttpStatusCode.BadRequest, "Something wrong with internal server "));
}
}
}
public static void DragCar(VehicleContext context, PlayerEntity player)
{
var vehicles = context.GetGroup(VehicleMatcher.GameObject).GetEntities();
var position = player.position.Value;
var minSqrDist = float.MaxValue;
VehicleEntity nearestVehicle = null;
foreach (var vehicle in vehicles)
{
if (vehicle.HasAnyPassager() || (vehicle.hasVehicleDrivable && !vehicle.vehicleDrivable.IsDrivable) ||
!vehicle.IsCar())
{
continue;
}
var sqrDist = (vehicle.GetDynamicData().Position - position).sqrMagnitude;
if (sqrDist < minSqrDist)
{
nearestVehicle = vehicle;
minSqrDist = sqrDist;
}
}
if (nearestVehicle != null)
{
var dragPosition = position + new Vector3(0.0f, 5.0f, 0.0f);
var dynamicData = nearestVehicle.GetDynamicData();
dynamicData.Position = dragPosition;
var go = nearestVehicle.gameObject.UnityObjWrapper.Value;
go.transform.position = dragPosition;
}
}
public static void SetVehicleDynamicPrediction(VehicleContext context, bool isPredict)
{
if (SharedConfig.DynamicPrediction == isPredict)
{
return;
}
var vehicles = context.GetEntities();
foreach (var vehicle in vehicles)
{
if (vehicle.hasEntityKey)
{
if (SharedConfig.IsServer)
{
if (vehicle.HasDriver())
{
vehicle.SetKinematic(!isPredict);
}
}
else
{
if (!vehicle.HasDriver())
{
vehicle.SetKinematic(!isPredict);
}
VehicleStateUtility.SetVehicleSyncLatest(vehicle, isPredict);
}
}
}
SharedConfig.DynamicPrediction = isPredict;
}
public VehiclePredictionProvider(ISnapshotSelector snapshotSelector, IGameContexts gameContexts,
VehicleContext vehicleContext, bool serverAuthorative) : base(snapshotSelector,
gameContexts)
{
_vehicleContext = vehicleContext;
_serverAuthorative = serverAuthorative;
}
public void GetAll()
{
using (var context = new VehicleContext(options))
{
var id = 0;
if (context.Vehicles.Count() > 0)
{
id = context.Vehicles.Max(x => x.Id);
}
context.Vehicles.Add(new Vehicle {
Id = (id + 1), Mark = "Fiat", Model = "teste1", Color = "color1", Description = "desc1"
});
context.Vehicles.Add(new Vehicle {
Id = (id + 2), Mark = "Honda", Model = "teste1", Color = "color1", Description = "desc1"
});
context.Vehicles.Add(new Vehicle {
Id = (id + 3), Mark = "Ferrari", Model = "teste1", Color = "color1", Description = "desc1"
});
context.SaveChanges();
}
using (var context = new VehicleContext(options))
{
var service = new Services(context);
var result = service.GetAll(null);
Assert.AreEqual(3, result.Count());
}
}
public void GetVehicleWithParams_ShouldReturnCorrectVehicle()
{
using (var context = new VehicleContext())
{
//Arrange
VehicleCRUDService vs = new VehicleCRUDService(context);
var vehicle = vs.CreateVehicle(new Vehicle
{
Make = "Kia",
Model = "Morning",
Year = 2019
});
context.SaveChanges();
//Act
var found = vs.GetVehiclesWithParams("Kia", "Morning", 2019).FirstOrDefault();
//Assert
bool check = false;
if (found.Make.Equals("Kia") && found.Model.Equals("Morning") && found.Year == 2019)
{
check = true;
}
Assert.IsTrue(check);
}
}
public IHttpActionResult GetVehicles([FromUri] FilterModel filter)
{
using (var dbcontext = new VehicleContext())
{
var vehicleService = new VehicleCRUDService(dbcontext);
try
{
var vehicleList = new List <Vehicle>();
// Return all vehicles for null filter
if (filter == null)
{
vehicleList = vehicleService.GetAllVehicles().ToList();
}
// Or return vehicles that match params
else
{
// Will do waterfall matching from Make --> Model --> Year ---> result
vehicleList = vehicleService.GetVehiclesWithParams(filter.Make, filter.Model, filter.Year).ToList();
}
return(Content(HttpStatusCode.OK, vehicleList));
}
catch (Exception)
{
return(Content(HttpStatusCode.InternalServerError, "Oops! Something when wrong on our end"));
}
}
}
public void DeleteVehicle_ShouldReturnNullWhenFindVehicle()
{
using (var context = new VehicleContext())
{
//Arrange
VehicleCRUDService vs = new VehicleCRUDService(context);
var vehicle = vs.CreateVehicle(new Vehicle
{
Make = "BMW",
Model = "X7",
Year = 1999
});
context.SaveChanges();
//Act
var delete = vs.DeleteVehicle(vehicle.Id);
context.SaveChanges();
var found = context.Vehicles.Where(v => v.Id == delete.Id).FirstOrDefault();
//Assert
Assert.IsNull(found);
}
}
public void Move(string command, VehicleContext vehicleContext)
{
foreach (var item in command)
{
singleCommandInvoker.Move(item.ToString(), vehicleContext);
}
}
public void ModelRepositoryUpdateTest()
{
//Arrange
IncludeAllMappings.include();
var vModel = new VehicleModelDomain()
{
Name = "ModelRepositoryUpdateTest", Abrv = "ModelRepositoryUpdateTest", VehicleModelId = Guid.NewGuid(), VehicleMakeId = Guid.Parse("03f3a155-c7a2-e611-9c16-b88687075332")
};
var context = new VehicleContext();
var repository = new Repositorys.Repository(context, new UnitOfWorkFactory(new UnitOfWork(context)));
var testRepository = new ModelRepository(repository);
Task.Run(async() =>
{
var response = await testRepository.Add(vModel);
Assert.AreEqual(1, response);
}).GetAwaiter().GetResult();
vModel.Name = "ModelRepositoryUpdateTestUpdated";
//Act
Task.Run(async() =>
{
var result = await testRepository.Update(vModel);
//Assert
Assert.AreEqual(1, result);
}).GetAwaiter().GetResult();
}
public void MakeControllerGetAllTest()
{
//Arange
IncludeAllMappings.include();
var context = new VehicleContext();
var repository = new Repository.Repositorys.Repository(context, new UnitOfWorkFactory(new UnitOfWork(context)));
var makeRepository = new MakeRepository(repository);
var modelRepository = new ModelRepository(repository);
var makeService = new MakeService(makeRepository, modelRepository);
var testController = new MakeController(makeService);
testController.Request = new HttpRequestMessage();
testController.Configuration = new HttpConfiguration();
//Add make
var vMake = new VehicleMakeView()
{
Name = "MakeControllerGetAllTest", Abrv = "MakeControllerGetAllTest"
};
Task.Run(async() =>
{
var response = await testController.Add(vMake);
Assert.IsNotNull(response);
}).GetAwaiter().GetResult();
Task.Run(async() =>
{
//Act
var result = await testController.GetAll();
//Assert
Assert.IsNotNull(result);
}).GetAwaiter().GetResult();
}
public VehicleRideSystem(Contexts contexts)
{
_context = contexts.vehicle;
_currentTime = contexts.session.currentTimeObject;
}
public static IVehicleCmd CreateVehicleCmd(IVehicleCmdGenerator generator, VehicleContext context, PlayerEntity player, int currentSimulationTime)
{
if (!player.IsOnVehicle())
{
return(null);
}
var vehicle = context.GetEntityWithEntityKey(player.controlledVehicle.EntityKey);
if (vehicle == null)
{
return(null);
}
var vehicleCmd = generator.GeneratorVehicleCmd(currentSimulationTime);
if (vehicleCmd == null)
{
return(null);
}
vehicleCmd.PlayerId = player.entityKey.Value.EntityId;
vehicleCmd.VehicleId = vehicle.entityKey.Value.EntityId;
if (!SharedConfig.ServerAuthorative)
{
vehicle.SetVehicleStateToCmd(vehicleCmd);
}
return(vehicleCmd);
}
private void DoChat()
{
try
{
while (true)
{
requestCount++;
//NetworkStream networkStream = clientSocket.GetStream();
//networkStream.Read(bytesFrom, 0, 10025);
//dataFromClient = System.Text.Encoding.ASCII.GetString(bytesFrom);
Console.WriteLine("From GPS - " + clNo + " : " + dataFromClient);
rCount = requestCount.ToString();
Console.WriteLine("GPS data: " + dataFromClient);
var separate = dataFromClient.Split(':');
var parseData = separate.Last().Split(',').Length;
if (parseData == 1)
{
Broadcast.BroadcastClientData("ON", clNo, false, clientsList);
}
if (parseData > 3 && dataFromClient.Contains("tracker"))
{
Dictionary <string, InsertionData> dataForInsertion = new Dictionary <string, InsertionData>();
List <string> parseGpsData = new List <string>(separate.Last().Split(','));
InsertionData insertionData = new InsertionData();
insertionData.mileage = (float.Parse(parseGpsData[5]) * 1.60934).ToString();
insertionData.latitude = CalculateData.DegreeToDecimal(Decimal.Parse(parseGpsData[7]), parseGpsData[8]).ToString();
insertionData.longitude = CalculateData.DegreeToDecimal(Decimal.Parse(parseGpsData[9]), parseGpsData[10]).ToString();
insertionData.speed = (float.Parse(parseGpsData[11]) * (float)1.852).ToString();
insertionData.bearing = float.Parse(parseGpsData[12]).ToString();
insertionData.fuelConsumption = float.Parse(parseGpsData[14]).ToString();
dataForInsertion.Add(clNo, insertionData);
Tracking data = new Tracking()
{
imei = clNo,
type = "tracker",
journey_data = JsonConvert.SerializeObject(dataForInsertion.Values),
timestamp = DateTime.Now
};
using (VehicleContext _db = new VehicleContext())
{
_db.Tracking.Add(data);
_db.SaveChangesAsync();
//##,imei:359710048989827,A; : imei:359710048989827,tracker,161101201234,,F,191235.000,A,4515.6358,N,01949.5184,E,0.14,181.92,,0,,,,;
}
}
}
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
}
public VehicleTypeSelectViewModelBase(
IEventAggregator eventAggregator,
VehicleContext masterContext) : base(eventAggregator)
{
this.VehicleTypes = masterContext.VehicleTypes.Select(vt => new VehicleTypeEntity {
Id = vt.Id, Name = vt.Name
});
}
public static async void AsyncDbAdd(VehicleModel model)
{
using (VehicleContext db = new VehicleContext())
{
db.Vehicles.Add(model);
await db.SaveChangesAsync();
}
}
public void Move(string command, VehicleContext vehicleContext)
{
if (!actionInvokerMap.ContainsKey(command))
{
throw new System.Exception($"Unknown commmand:{command}");
}
actionInvokerMap[command].Move(vehicleContext);
}
public UnitTest()
{
options = new DbContextOptionsBuilder <VehicleContext>()
.UseInMemoryDatabase(databaseName: "Vehicle")
.Options;
context = new VehicleContext(options);
}
public void Move(VehicleContext vehicleContext)
{
if (!actionInvokerMap.ContainsKey(vehicleContext.Direction))
{
throw new System.Exception($"Undefined direction case status:{vehicleContext.Direction}");
}
actionInvokerMap[vehicleContext.Direction].Move(vehicleContext);
}
public CameraPreUpdateSystem(Contexts contexts, Motors m)
{
_vehicleContext = contexts.vehicle;
_freeMoveContext = contexts.freeMove;
_contexts = contexts;
_motors = m;
_state = new DummyCameraMotorState(m);
}
public CarService(ICarRepository carRepository,
VehicleContext context,
IVehicleFactory <Car, CreateCarCommand> carFactory)
{
this._carRepository = carRepository;
this._context = context;
this._factory = carFactory;
}
public CarAddViewModelBase(
IEventAggregator eventAggregator,
MasterContext masterContext,
VehicleContext vehicleContext
) : base(eventAggregator)
{
this.masterContext = masterContext;
this.vehicleContext = vehicleContext;
}
private static void SetVehicleInput(VehicleContext context, int id, VechileDebugInput inputType, float val)
{
var vehicle = GetVehicle(context, id);
if (vehicle != null)
{
vehicle.SetDebugInput(inputType, val);
}
}
public static void SetVehicleFuel(VehicleContext context, int id, int fuelVolume)
{
var vehicle = GetVehicle(context, id);
if (vehicle != null)
{
vehicle.GetGameData().RemainingFuel = fuelVolume;
}
}
public static void SetVehicleHp(VehicleContext context, int id, int hp)
{
var vehicle = GetVehicle(context, id);
if (vehicle != null)
{
vehicle.GetGameData().Hp = hp;
}
}
public ClientCameraPreUpdateSystem(VehicleContext vehicleContext, FreeMoveContext freeMoveContext, PlayerContext playerContext, Motors m)
{
_vehicleContext = vehicleContext;
_freeMoveContext = freeMoveContext;
_motors = m;
_playerContext = playerContext;
_state = new DummyCameraMotorState(m);
_subCameraMotorTypeArray = Enum.GetValues(typeof(SubCameraMotorType));
}
public void Move_Always_DirectionW()
{
var instance = new RotateRightSActionInvoker();
var vehicleContet = new VehicleContext();
instance.Move(vehicleContet);
Assert.AreEqual(Direction.W, vehicleContet.Direction);
}
public void AddNewTransmissionTypeTest()
{
Entity entity;
using (var context = new VehicleContext())
{
entity = context.Entities.OfType<Style>().FirstOrDefault();
entity.Created = entity.Created.AddMinutes(-45);
context.DbTypes.AddOrUpdate(x => new {x.Name, x.TypeName}, new TransmissionType("Automatic", "5sp"));
context.SaveChanges();
}
var t1 = entity.Version;
var task = new Task(() => { entity.Modified = DateTime.UtcNow; });
var newEntity = DbContextExtensions.ReAttachAndSave<VehicleContext>(entity, task);
var t2 = entity.Version;
Assert.AreNotEqual(t1, t2);
int i = 0;
}
