public int AddToVehicleModel(PostVehicleArgs postveargs)
{
VehicleMakeEntity vehiclemakeentity = new VehicleMakeEntity();
vehiclemakeentity.Name = postveargs.make_Name;
vehiclemakeentity.Abrv = postveargs.make_Abrv;
VehicleModelEntity vehiclemodelentity = new VehicleModelEntity();
VehicleMakeEntity findvehiclemake = Context.VehicleMake.Find(postveargs.make_Id);
if (findvehiclemake == null)
{
Context.VehicleMake.Add(vehiclemakeentity);
Context.SaveChanges();
vehiclemodelentity.MakeId = vehiclemakeentity.Id;
}
else
{
vehiclemakeentity.Id = postveargs.make_Id;
vehiclemodelentity.MakeId = postveargs.make_Id;
}
vehiclemodelentity.Id = postveargs.model_Id;
vehiclemodelentity.Name = postveargs.model_Name;
vehiclemodelentity.Abrv = postveargs.model_Abrv;
Context.VehicleModel.Add(vehiclemodelentity);
return(Context.SaveChanges());
}
public ActionResult Index()
{
VehicleMakeEntity v = new VehicleMakeEntity();
//var cars = f.VehicleMake.Field.
return(View(v));
}
public async Task <bool> DeleteAsync(int id)
{
VehicleMakeEntity entity = new VehicleMakeEntity(id);
using (var adapter = new DataAccessAdapter(ConnectionString))
{
return(await adapter.DeleteEntityAsync(entity));
}
}
public int UpdateVehicleMake(VehicleMakeArgs make_model)
{
VehicleMakeEntity vehiclemakeentity = new VehicleMakeEntity();
vehiclemakeentity.Id = make_model.Id;
vehiclemakeentity.Name = make_model.Name;
vehiclemakeentity.Abrv = make_model.Abrv;
Context.VehicleMake.Update(vehiclemakeentity);
return(Context.SaveChanges());
}
public async Task <int> Update(VehicleMake entity)
{
try
{
VehicleMakeEntity vehicleMake = mapper.Map <VehicleMakeEntity>(entity);
return(await dataSource.GetConnection().UpdateAsync(vehicleMake));
}catch (Exception ex)
{
throw new ServiceException();
}
}
public async Task <VehicleMake> GetById(int id)
{
try
{
VehicleMakeEntity vehicleMakeFromDB = await dataSource.GetConnection().FindAsync <VehicleMakeEntity>(x => x.Id == id);
return(mapper.Map <VehicleMake>(vehicleMakeFromDB));
}
catch (Exception ex)
{
throw new ServiceException();
}
}
public async Task <int> Add(VehicleMake entity)
{
try
{
VehicleMakeEntity vehicleMake = mapper.Map <VehicleMakeEntity>(entity);
int added = await dataSource.GetConnection().InsertAsync(vehicleMake);
return(added);
}
catch (Exception ex)
{
throw new ServiceException();
}
}
public async Task <int> Delete(VehicleMake entity)
{
try
{
int provjera = 0;
VehicleMakeEntity vehicleMake = mapper.Map <VehicleMakeEntity>(entity);
provjera = await dataSource.GetConnection().Table <VehicleModelEntity>().DeleteAsync(x => x.MakeId == vehicleMake.Id);
int deleted = await dataSource.GetConnection().DeleteAsync(vehicleMake);
return(deleted);
}
catch (Exception ex)
{
throw new ServiceException();
}
}
public async Task <IVehicleMake> DeleteVehicleMakeAsync(Guid id)
{
if (id != null)
{
VehicleMakeEntity vehicleMakeEntity = Context.VehicleMakes.Find(id);
if (vehicleMakeEntity != null)
{
Context.VehicleMakes.Remove(vehicleMakeEntity);
await Context.SaveChangesAsync();
var vehicleMake = Mapper.Map <IVehicleMake>(vehicleMakeEntity);
return(vehicleMake);
}
return(null);
}
return(null);
}
public void InsertModelTest()
{
//arrange
var vehiclemake = new VehicleMakeEntity();
var vehiclemodel = new VehicleModelEntity();
var vehicledto = new VehicleDto();
var testMakeRepository = new Mock <IMakeRepository>();
testMakeRepository.Setup(m => m.InsertAsync(vehiclemake))
.Returns(Task.CompletedTask);
var testModelRepository = new Mock <IModelRepository>();
testModelRepository.Setup(m => m.InsertAsync(vehiclemodel))
.Returns(Task.CompletedTask);
var testUnitOfWork = new Mock <IUnitOfWork>();
//var options = new DbContextOptionsBuilder<ProjectDbContext>().UseInMemoryDatabase(databaseName: "mono").Options;
var context = new Mock <ProjectDbContext>();
context.Setup(m => m.Add(vehiclemake));
var testingClass = new VehicleService(testUnitOfWork.Object, testMakeRepository.Object, testModelRepository.Object);
//act
var insertMethod = testingClass.InsertModelAsync(vehiclemodel);
//assert
//testingClass.InsertModel().Should().
Assert.True(insertMethod.IsCompletedSuccessfully);
}
public void Update(VehicleMakeEntity entity)
{
context.VehicleMake.Update(entity);
context.SaveChanges();
}
public void Insert(VehicleMakeEntity entity)
{
context.VehicleMake.Add(entity);
context.SaveChanges();
}
public void Delete(VehicleMakeEntity entity)
{
context.VehicleMake.Remove(entity);
context.SaveChanges();
Console.WriteLine(entity.Make.Name);
}
public async Task <VehicleMakeEntity> UpdateAsync(VehicleMakeEntity updatedItem)
{
return(await repository.UpdateAsync(updatedItem));
}
public async Task <VehicleMakeEntity> CreteAsync(VehicleMakeEntity newItem)
{
return(await repository.CreteAsync(newItem));
}
/// <summary>
/// UPDATE VEHICLE MAKE
/// </summary>
/// <param name="UpdateVehicleMake"></param>
/// <returns></returns>
public async Task UpdateVehicleMakeAsync(VehicleMakeEntity UpdateVehicleMake)
{
await repository.Update(UpdateVehicleMake);
}
/// <summary>
/// DELETE VEHICLE MAKE
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
public async Task DeleteVehicleMakeAsync(int id)
{
VehicleMakeEntity vehicleMakeEntity = await repository.GetById(id);
await repository.Delete(vehicleMakeEntity);
}
/// <summary>
/// ADD VEHICLE MAKE
/// </summary>
/// <param name="vehicleMakeEntity"></param>
/// <returns></returns>
public async Task AddVehicleMakeAsync(VehicleMakeEntity vehicleMakeEntity)
{
await repository.Insert(vehicleMakeEntity);
}
public void Details(VehicleMakeEntity entity)
{
context.VehicleMake.Find(entity);
context.SaveChanges();
}
public void Delete(VehicleMakeEntity entity)
{
context.VehicleMake.Remove(entity);
context.SaveChanges();
}
private VehicleMake MapToVehicleMake(VehicleMakeEntity vehicle)
{
return(App.Mapper.Map <VehicleMakeEntity, VehicleMake>(vehicle));
}
