public void ApiPutVehicleTest()
{
// Arrange
var repo = new VehiclesRepository();
controller = new VehicleController(repo)
{
Request = new HttpRequestMessage(),
Configuration = new HttpConfiguration()
};
VehiclesRepository.Vehicles.Add(new Vehicle()
{
Make = "Honda",
Model = "HRV",
Year = 2015
});
Vehicle updatedVehicle = new Vehicle()
{
Id = 1,
Make = "Honda",
Model = "HRV",
Year = 2016
};
// Act
var actionResult = controller.Put(updatedVehicle);
var contentResult = actionResult as OkNegotiatedContentResult <IVehicleDTO>;
// Assert
Assert.IsNotNull(contentResult);
Assert.IsNotNull(contentResult.Content);
Assert.AreEqual(updatedVehicle.Year, (contentResult.Content as VehicleDTO).Year);
}
public void PutVehicle_ShouldReturnNotFound()
{
// Arrange
var repo = new VehiclesRepository();
controller = new VehicleController(repo)
{
Request = new HttpRequestMessage(),
Configuration = new HttpConfiguration()
};
Vehicle vehicle = new Vehicle()
{
Id = 1,
Make = "onda",
Model = "HRV",
Year = 2015
};
// Act
var result = controller.Put(vehicle);
// Assert
Assert.IsNotNull(result);
Assert.IsInstanceOfType(result, typeof(NotFoundResult));
}
public void ApiGetVehiclesTest_ReturnsAllVehiclesCheckCount()
{
// Arrange
var repo = new VehiclesRepository();
VehiclesRepository.Vehicles.Add(new Vehicle()
{
Id = 1,
Make = "Honda",
Model = "HRV",
Year = 2015
});
VehiclesRepository.Vehicles.Add(new Vehicle()
{
Id = 2,
Make = "Honda",
Model = "HRV",
Year = 2016
});
controller = new VehicleController(repo)
{
Request = new HttpRequestMessage(),
Configuration = new HttpConfiguration()
};
// Act
var response = controller.Get() as OkNegotiatedContentResult <IEnumerable <IVehicleDTO> >;
// Assert
Assert.IsNotNull(response);
Assert.AreEqual(2, (response.Content as List <VehicleDTO>).Count);
}
public void ApiPostVehicleTest_ShouldReturnSameVehicleAndIdInURL()
{
// Arrange
var repo = new VehiclesRepository();
controller = new VehicleController(repo)
{
Request = new HttpRequestMessage(),
Configuration = new HttpConfiguration()
};
Vehicle vehicle = new Vehicle()
{
Make = "Honda",
Model = "HRV",
Year = 2015
};
// Act
IHttpActionResult actionResult = controller.Post(vehicle);
var createdResult = actionResult as CreatedAtRouteNegotiatedContentResult <IVehicleDTO>;
// Assert
Assert.IsNotNull(createdResult);
Assert.AreEqual("GetById", createdResult.RouteName);
Assert.AreEqual(1, createdResult.RouteValues["Id"]);
Assert.AreEqual((createdResult.Content as VehicleDTO).Make, vehicle.Make);
}
//TODO: look into validation, if everything is correct
/// <summary>
/// Registers new vehicle
/// </summary>
/// <returns>Redirect to index if success, if fail redirect to same page</returns>
public IActionResult OnPostConfirm()
{
Vehicle.Email = HttpContext.Session.GetString("email");
if (Photo != null)
{
var path = Path.Combine(ihostingEnvironment.WebRootPath, "images", Vehicle.License + " - " + Photo.FileName);
using (var stream = new FileStream(path, FileMode.Create))
{
Photo.CopyToAsync(stream);
Vehicle.Vehicle_Image = Photo.FileName;
}
}
if (VehiclesRepository.AddVehicle(Vehicle))
{
FixedCost.Insurance = Vehicle.Insurance;
FixedCost.Insurance_Date = Vehicle.Insurance_Date;
FixedCost.Road_Tax = Vehicle.Road_Tax;
FixedCost.Road_Tax_Date = Vehicle.Road_Tax_Date;
if (CostsRepository.AddFixedCosts(FixedCost, Vehicle.License))
{
return(RedirectToPage("Index"));
}
//if (Vehicle.Vehicle_Image != null)
}
return(Page());
}
public void Save()
{
DbModel.Health = GameVehicle.Health;
DbModel.Door1Damage = GameVehicle.IsDoorBroken(1);
DbModel.Door2Damage = GameVehicle.IsDoorBroken(2);
DbModel.Door3Damage = GameVehicle.IsDoorBroken(3);
DbModel.Door4Damage = GameVehicle.IsDoorBroken(4);
DbModel.Window1Damage = GameVehicle.IsWindowBroken(1);
DbModel.Window2Damage = GameVehicle.IsWindowBroken(2);
DbModel.Window3Damage = GameVehicle.IsWindowBroken(3);
DbModel.Window4Damage = GameVehicle.IsWindowBroken(4);
DbModel.PrimaryColor = GameVehicle.CustomPrimaryColor.ToHex();
DbModel.SecondaryColor = GameVehicle.CustomSecondaryColor.ToHex();
DbModel.EnginePowerMultiplier = GameVehicle.EnginePowerMultiplier;
DbModel.NumberPlateStyle = GameVehicle.NumberPlateStyle;
DbModel.NumberPlate = GameVehicle.NumberPlate;
DbModel.Fuel = GameVehicle.GetSharedData("fuel");
DbModel.FuelConsumption = GameVehicle.GetSharedData("fuelConsumption");
DbModel.Milage = GameVehicle.GetSharedData("milage");
if (_nonDbVehicle)
{
return;
}
RoleplayContext ctx = Singletons.RoleplayContextFactory.Create();
using (VehiclesRepository repository = new VehiclesRepository(ctx))
{
repository.Update(DbModel);
repository.Save();
}
}
public void ApiGetVehicleByIdTest_ShouldReturnTheVehicle()
{
// Arrange
var repo = new VehiclesRepository();
controller = new VehicleController(repo)
{
Request = new HttpRequestMessage(),
Configuration = new HttpConfiguration()
};
VehiclesRepository.Vehicles.Add(new Vehicle()
{
Id = 1,
Make = "Honda",
Model = "HRV",
Year = 2015
});
// Act
OkNegotiatedContentResult <IVehicleDTO> response = controller.Get(1) as OkNegotiatedContentResult <IVehicleDTO>;
// Assert
Assert.IsNotNull(response.Content);
Assert.AreEqual(2015, (response.Content as VehicleDTO).Year);
Assert.AreEqual("HRV", (response.Content as VehicleDTO).Model);
}
public void GetVehiclesByFilterTest()
{
// arrange
Vehicle vehicle1 = new Vehicle()
{
Make = "Honda",
Model = "CRV",
Year = 2015
};
Vehicle vehicle2 = new Vehicle()
{
Make = "Honda",
Model = "CRV",
Year = 2015
};
// act
VehiclesRepository vr = new VehiclesRepository();
vr.AddVehicle(vehicle1);
vr.AddVehicle(vehicle2);
// assert
Assert.IsTrue(vr.GetVehicleByFilter("Model", "CR").Count() == 2);
}
public void UpdateVehicleTest()
{
// arrange
Vehicle vehicle = new Vehicle()
{
Make = "Honda",
Model = "HRV",
Year = 2015
};
Vehicle updatedVehicle = new Vehicle()
{
Make = "Honda",
Model = "HRV",
Year = 2016
};
// act
VehiclesRepository vr = new VehiclesRepository();
vr.AddVehicle(vehicle);
vr.UpdateVehicle(updatedVehicle);
updatedVehicle.Id = vehicle.Id;
// assert
Assert.ReferenceEquals(vehicle, updatedVehicle);
}
internal UnitOfWork(KatSystemDbContext context)
{
this.context = context;
Users = new UsersRepository(context);
Vehicles = new VehiclesRepository(context);
Persons = new PersonsRepository(context);
Fines = new FinesRepository(context);
}
public AdminController(IConfiguration Configuration)
{
VehiclesRepo = new VehiclesRepository();
MetroStationRepo = new MetroStationRepository();
RouteRepo = new RouteRepository();
ValidationRepo = new ValidationHistoryRepository();
_config = Configuration;
}
/// <summary>
/// Deletes vehicle
/// </summary>
/// <param name="license">License of vehicle</param>
/// <returns>Redirect to index if success, if fail to same page</returns>
public IActionResult OnGetDeleteVehicle(string license)
{
if (CostsRepository.DeleteVehicleCosts(license))
{
if (VehiclesRepository.DeleteVehicle(license))
{
return(RedirectToPage("Index"));
}
}
return(Page());
}
public IActionResult OnPost(string license)
{
CostType = HttpContext.Request.Query["type"];
Costs.License = license;
var vehicle = VehiclesRepository.GetVehicleByLicense(license);
if (vehicle != null)
{
Milage_KM = vehicle.Mileage_Km;
}
if (CostType == "Brandstof")
{
if (Vehicles.Mileage_Km != Milage_KM)
{
VehiclesRepository.UpdateMileage_KM(license, Vehicles.Mileage_Km);
}
CostsRepository.AddCostFuel(Costs);
}
else if (CostType == "Reparatie")
{
if (Invoice != null)
{
var path = Path.Combine(ihostingEnvironment.WebRootPath, "invoices", license + " - " + Costs.Invoice_Doc + " - " + Invoice.FileName);
using (var stream = new FileStream(path, FileMode.Create))
{
Invoice.CopyToAsync(stream);
}
CostsRepository.AddCostRepairFile(Costs, Invoice.FileName);
if (Vehicles.Mileage_Km != Milage_KM)
{
VehiclesRepository.UpdateMileage_KM(license, Vehicles.Mileage_Km);
}
}
else
{
CostsRepository.AddCostRepair(Costs);
if (Vehicles.Mileage_Km != Milage_KM)
{
VehiclesRepository.UpdateMileage_KM(license, Vehicles.Mileage_Km);
}
}
}
return(RedirectToPage("Index"));
}
public ActionResult OnGet(string license)
{
CostType = HttpContext.Request.Query["type"];
License = license;
var vehicle = VehiclesRepository.GetVehicleByLicense(License);
if (vehicle != null)
{
Milage_KM = vehicle.Mileage_Km;
}
return(Page());
}
public static VehicleEntity Create(FullPosition spawnPosition, VehicleHash hash, string numberPlate, int numberPlateStyle,
int?creatorId, Color primaryColor, Color secondaryColor, float enginePowerMultiplier = 0f, float engineTorqueMultiplier = 0f,
CharacterModel character = null, GroupModel groupModel = null)
{
VehicleModel vehicleModel = new VehicleModel
{
VehicleHash = hash.ToString(),
NumberPlate = numberPlate,
NumberPlateStyle = numberPlateStyle,
Character = character,
Group = groupModel,
CreatorId = creatorId,
SpawnPositionX = spawnPosition.Position.X,
SpawnPositionY = spawnPosition.Position.Y,
SpawnPositionZ = spawnPosition.Position.Z,
SpawnRotationX = spawnPosition.Rotation.X,
SpawnRotationY = spawnPosition.Rotation.Y,
SpawnRotationZ = spawnPosition.Rotation.Z,
PrimaryColor = primaryColor.ToHex(),
SecondaryColor = secondaryColor.ToHex(),
EnginePowerMultiplier = enginePowerMultiplier,
EngineTorqueMultiplier = engineTorqueMultiplier,
ItemsInVehicle = new List <ItemModel>(),
Milage = 0.0f,
};
vehicleModel.FuelTank = GetFuelTankSize((VehicleClass)NAPI.Vehicle.GetVehicleClass(NAPI.Util.VehicleNameToModel(vehicleModel.VehicleHash)));
vehicleModel.Fuel = vehicleModel.FuelTank * 0.2f;
vehicleModel.FuelConsumption = NAPI.Vehicle.GetVehicleMaxAcceleration(NAPI.Util.VehicleNameToModel(vehicleModel.VehicleHash)) / 0.2f;
bool nonDbVehicle = character == null && groupModel == null;
if (!nonDbVehicle)
{
RoleplayContext ctx = Singletons.RoleplayContextFactory.Create();
using (VehiclesRepository repository = new VehiclesRepository(ctx))
{
repository.Insert(vehicleModel);
repository.Save();
}
}
return(new VehicleEntity(vehicleModel)
{
_nonDbVehicle = nonDbVehicle
});
}
public bool DeleteVehicleById(int ID)
{
try
{
bool isSuccess;
using (var repo = new VehiclesRepository())
{
isSuccess = repo.DeletedById(ID);
}
return(isSuccess);
}
catch (Exception ex)
{
LogHelper.Log(LogTarget.File, ExceptionHelper.ExceptionToString(ex), true);
throw new Exception("BusinessLogic:VehiclesBusiness::DeleteVehicleById::Error occured.", ex);
}
}
public bool InsertVehicle(Vehicles entity)
{
try
{
bool isSuccess;
using (var repo = new VehiclesRepository())
{
isSuccess = repo.Insert(entity);
}
return(isSuccess);
}
catch (Exception ex)
{
LogHelper.Log(LogTarget.File, ExceptionHelper.ExceptionToString(ex), true);
throw new Exception("BusinessLogic:VehiclesBusiness::InsertVehicle::Error occured.", ex);
}
}
public void AddVehicleTest()
{
// arrange
Vehicle vehicle = new Vehicle()
{
Make = "Honda",
Model = "HRV",
Year = 2015
};
// act
VehiclesRepository vr = new VehiclesRepository();
vr.AddVehicle(vehicle);
// assert
Assert.IsTrue(VehiclesRepository.Vehicles.Contains(vehicle));
}
public void DeleteVehicleTest()
{
// arrange
Vehicle vehicle = new Vehicle()
{
Make = "Honda",
Model = "HRV",
Year = 2015
};
// act
VehiclesRepository vr = new VehiclesRepository();
vr.AddVehicle(vehicle);
// assert
Assert.IsTrue(vr.DeleteVehicle(vehicle.Id.Value));
}
public void GetVehicleByIdTest()
{
// arrange
Vehicle vehicle = new Vehicle()
{
Make = "Honda",
Model = "HRV",
Year = 2015
};
// act
VehiclesRepository vr = new VehiclesRepository();
vr.AddVehicle(vehicle);
// assert
Assert.ReferenceEquals(vr.GetVehicleId(vehicle.Id.Value), vehicle.MapDto());
}
public void GetVehicleById_ReturnsNotFound()
{
// Arrange
// Arrange
var repo = new VehiclesRepository();
controller = new VehicleController(repo)
{
Request = new HttpRequestMessage(),
Configuration = new HttpConfiguration()
};
// Act
var actionResult = controller.Get(10);
// Assert
Assert.IsInstanceOfType(actionResult, typeof(NotFoundResult));
}
public UnitOfWork(RoleplayContext context)
{
Context = context;
AccountsRepository = new AccountsRepository(context);
BuildingsRepository = new BuildingsRepository(context);
CharactersRepository = new CharactersRepository(context);
CrimeBotsRepository = new CrimeBotsRepository(context);
GroupsRepository = new GroupsRepository(context);
GroupWarehouseItemsRepository = new GroupWarehouseItemsRepository(context);
GroupWarehouseOrdersRepository = new GroupWarehouseOrdersRepository(context);
ItemsRepository = new ItemsRepository(context);
PenaltiesRepository = new PenaltiesRepository(context);
TelephoneContactsRepository = new TelephoneContactsRepository(context);
TelephoneMessagesRepository = new TelephoneMessagesRepository(context);
VehiclesRepository = new VehiclesRepository(context);
WorkersRepository = new WorkersRepository(context);
ZonesRepository = new ZonesRepository(context);
GroupRanksRepository = new GroupRankRepository(context);
TicketsRepository = new TicketsRepository(context);
ItemTemplatesRepository = new ItemTemplatesRepository(context);
}
public List <Vehicles> SelectAllVehicles()
{
var responseEntities = new List <Vehicles>();
try
{
using (var repo = new VehiclesRepository())
{
foreach (var entity in repo.SelectAll())
{
responseEntities.Add(entity);
}
}
return(responseEntities);
}
catch (Exception ex)
{
LogHelper.Log(LogTarget.File, ExceptionHelper.ExceptionToString(ex), true);
throw new Exception("BusinessLogic:VehiclesBusiness::SelectAllVehicles::Error occured.", ex);
}
}
/// <summary>
/// Updates a vehicle
/// </summary>
/// <param name="license">License of vehicle</param>
/// <returns>Redirect to index if success, if fail to same page.</returns>
public IActionResult OnPostUpdate(string license)
{
if (ModelState.ErrorCount == 1)
{
Vehicle.License = license;
if (Photo != null)
{
var path = Path.Combine(ihostingEnvironment.WebRootPath, "images",
Vehicle.License + " - " + "car.png");
using (var stream = new FileStream(path, FileMode.Create))
{
Photo.CopyToAsync(stream);
Vehicle.Vehicle_Image = "car.png";
}
}
if (VehiclesRepository.UpdateVehicle(Vehicle))
{
return(RedirectToPage("Index"));
}
}
return(Page());
}
public void ApiDeleteVehicleTest_ReturnsOkay()
{
// Arrange
var repo = new VehiclesRepository();
controller = new VehicleController(repo)
{
Request = new HttpRequestMessage(),
Configuration = new HttpConfiguration()
};
VehiclesRepository.Vehicles.Add(new Vehicle()
{
Make = "Honda",
Model = "HRV",
Year = 2015
});
// Act
IHttpActionResult actionResult = controller.Delete(1);
// Assert
Assert.IsInstanceOfType(actionResult, typeof(OkResult));
}
public Vehicles SelectVehicleById(int vehicleId)
{
try
{
Vehicles responseEntitiy;
using (var repo = new VehiclesRepository())
{
responseEntitiy = repo.SelectedById(vehicleId);
responseEntitiy.Company = new CompaniesRepository().SelectedById(responseEntitiy.CompanyID);
responseEntitiy.RentalTransaction = new RentalTransactionsRepository().SelectAll().Where(x => x.VehicleID.Equals(responseEntitiy.VehicleID)).ToList();
if (responseEntitiy == null)
{
throw new NullReferenceException("Vehicle doesnt exists!");
}
}
return(responseEntitiy);
}
catch (Exception ex)
{
LogHelper.Log(LogTarget.File, ExceptionHelper.ExceptionToString(ex), true);
throw new Exception("BusinessLogic:VehiclesBusiness::SelectVehicleById::Error occured.", ex);
}
}
public void OnGet(string license)
{
Vehicle = VehiclesRepository.GetVehicleByLicense(license);
Costs = CostsRepository.GetCostsByLicenseInner(license);
}
public IActionResult OnGet()
{
if (HttpContext.Session.GetString("email") == null)
{
return(RedirectToPage("Login"));
}
Costs = CostsRepository.GetCostsByEmail(HttpContext.Session.GetString("email"));
Vehicles = VehiclesRepository.GetVehiclesByEmail(HttpContext.Session.GetString("email"));
//Calculates all overdue fixedCosts
foreach (var item in Vehicles)
{
CostsRepository.FixedCostsMontly(item.License);
}
//Chart settings
Chart chart = new Chart();
chart.Type = Enums.ChartType.Line;
ChartJSCore.Models.Data data = new ChartJSCore.Models.Data();
data.Labels = new List <string>()
{
"Januari", "Februari", "Maart", "April", "Mei", "Juni", "Juli", "Augustus", "September", "Oktober", "November", "December"
};
data.Datasets = new List <Dataset>();
Random random = new Random();
var year = HttpContext.Request.Query["Year"];
if (!string.IsNullOrWhiteSpace(year))
{
Year = Convert.ToInt32(year);
}
else
{
Year = DateTime.Now.Year;
}
//Foreach to loop through every vehicle to get AnnualCosts and set it in the chart
foreach (var vehicle in Vehicles)
{
int[,] randomColor = new int[3, 1] {
{ random.Next(0, 255) }, { random.Next(0, 255) }, { random.Next(0, 255) }
};
IList <double?> annualCosts = CostsRepository.GetAnnualCosts(vehicle.License, Year);
LineDataset dataset = new LineDataset()
{
Label = vehicle.Brand_Name + ' ' + vehicle.Model_Name,
Data = annualCosts,
Fill = "false",
LineTension = 0.1,
BackgroundColor = ChartColor.FromRgba((byte)randomColor[0, 0], (byte)randomColor[1, 0], (byte)randomColor[2, 0], 0.4),
BorderColor = ChartColor.FromRgb((byte)randomColor[0, 0], (byte)randomColor[1, 0], (byte)randomColor[2, 0]),
BorderCapStyle = "butt",
BorderDash = new List <int> {
},
BorderDashOffset = 0.0,
BorderJoinStyle = "miter",
PointBorderColor = new List <ChartColor> {
ChartColor.FromRgb(75, 192, 192)
},
PointBackgroundColor = new List <ChartColor> {
ChartColor.FromHexString("#ffffff")
},
PointBorderWidth = new List <int> {
1
},
PointHoverRadius = new List <int> {
5
},
PointHoverBackgroundColor = new List <ChartColor> {
ChartColor.FromRgb(75, 192, 192)
},
PointHoverBorderColor = new List <ChartColor> {
ChartColor.FromRgb(220, 220, 220)
},
PointHoverBorderWidth = new List <int> {
2
},
PointRadius = new List <int> {
1
},
PointHitRadius = new List <int> {
10
},
SpanGaps = false
};
data.Datasets.Add(dataset);
}
chart.Data = data;
ViewData["chart"] = chart;
return(Page());
}
public void Trade(bool bank)
{
if (Getter.HasMoney(Money, bank))
{
if (_moneyToGroup && Sender.OnDutyGroup == null)
{
Sender.SendInfo("Musisz znajdować się na służbie grupy.");
return;
}
if (ItemModel != null)
{
ChatScript.SendMessageToNearbyPlayers(Sender,
$"{Sender.FormatName} podaje przedmiot {Getter.FormatName}",
ChatMessageType.ServerMe);
ItemModel.Character = Getter.DbModel;
RoleplayContext ctx = Singletons.RoleplayContextFactory.Create();
using (ItemsRepository repository = new ItemsRepository(ctx))
{
repository.Update(ItemModel);
repository.Save();
}
}
else if (Vehicle != null)
{
ChatScript.SendMessageToNearbyPlayers(Sender,
$"{Sender.FormatName} podaje klucze {Getter.FormatName}",
ChatMessageType.ServerMe);
Vehicle.Character = Getter.DbModel;
RoleplayContext ctx = Singletons.RoleplayContextFactory.Create();
using (VehiclesRepository repository = new VehiclesRepository(ctx))
{
repository.Update(Vehicle);
repository.Save();
}
}
else if (Building != null)
{
ChatScript.SendMessageToNearbyPlayers(Sender,
$"{Sender.FormatName} podaje klucze {Getter.FormatName}",
ChatMessageType.ServerMe);
Building.Character = Getter.DbModel;
RoleplayContext ctx = Singletons.RoleplayContextFactory.Create();
using (BuildingsRepository repository = new BuildingsRepository(ctx))
{
repository.Update(Building);
repository.Save();
}
}
if (_moneyToGroup)
{
Sender.OnDutyGroup.AddMoney(Money);
}
else
{
Sender.AddMoney(Money, bank);
}
Getter.RemoveMoney(Money, bank);
_action?.Invoke(Getter);
}
else
{
Getter.SendWarning(bank
? "Nie posiadasz wystarczającej ilości środków na karcie"
: "Nie posiadasz wystarczającej ilości gotówki.");
Sender.SendError("Wymiana zakończona niepowodzeniem.");
}
}
public HomeController(VehiclesRepository repo)
{
this.repo = repo;
}
