public void Edit(VehicleTypeModel model)
{
var dbModel = _dbContext.VehicleTypes.Include("Image").SingleOrDefault(x => x.Id == model.Id);
if (dbModel != null)
{
if (dbModel.Name != model.Name)
{
dbModel.Name = model.Name;
}
if (dbModel.IsEnabled != model.IsEnabled)
{
dbModel.IsEnabled = model.IsEnabled;
}
if (!string.IsNullOrEmpty(model.ImageFile.FileName) && dbModel.Image != null && model.Image != null)
{
var generatedPath = ImageHelper.SaveToFolder(model.ImageFile, EnitityTypesEnum.VehicleType, model.Id.ToString(), model.Name);
if (dbModel.Image.Path != generatedPath)
{
ImageHelper.DeleteFromFolder(dbModel.Image.Path);
var image = new Image
{
Id = model.Image.Id,
Path = generatedPath
};
_dbContext.Images.Remove(dbModel.Image);
dbModel.Image = image;
}
}
_dbContext.SaveChanges();
}
}
public JsonResult addVehicleType(VehicleTypeModel model)
{
var exceptionMessage = string.Empty;
try
{
model.createdBy = AppUtils.LoggedInUserId;
if (repo.saveVehicleType(model))
{
return(Json(new { error = false, message = "Operation successful" }));
}
else
{
return(Json(new { error = true, message = "An exception has occured" }));
}
}
catch (Exception ex)
{
exceptionMessage = $"An unknown exception has occured: {ex.Message}";
}
return(Json(new { error = true, message = exceptionMessage }));
}
public async void VehicleTypeUpdate()
{
// Arrange
this.FleetDbContext.VehicleTypes.AddRange(
new VehicleTypeEntity()
{
VehicleTypeId = 1, VehicleTypeName = "Escavator", CompanyId = 1, DeletedInd = false
},
new VehicleTypeEntity()
{
VehicleTypeId = 2, VehicleTypeName = "Truck", CompanyId = 1, DeletedInd = false
});
await this.SaveChangesAsync(this.FleetDbContext);
VehicleTypeModel model = new VehicleTypeModel()
{
VehicleTypeId = 2, VehicleTypeName = "Bulldozer"
};
// Act
AjaxModel <NTModel> ajaxModel = await this.Controller.VehicleTypeUpdate(model);
// Assert
VehicleTypeEntity entity = this.FleetDbContext.VehicleTypes.Where(e => e.VehicleTypeId == 2).First();
Assert.Equal(entity.VehicleTypeName, "Bulldozer");
Assert.Equal(ajaxModel.Message, FleetMessages.VehicleTypeSaveSuccess);
}
public async void VehicleTypeAdd()
{
// Arrange
VehicleTypeModel model = new VehicleTypeModel() { VehicleTypeId = 0, VehicleTypeName = "Bulldozer" };
// Act
AjaxModel<NTModel> ajaxModel = await this.Controller.VehicleTypeAdd(model);
// Assert
VehicleTypeEntity entity = this.FleetDbContext.VehicleTypes.Last();
Assert.Equal(entity.VehicleTypeName, "Bulldozer");
Assert.Equal(ajaxModel.Message, FleetMessages.VehicleTypeSaveSuccess);
}
public bool saveVehicleType(VehicleTypeModel model)
{
var newVehicleType = new VehicleType()
{
VehicleName = model.vehicleName,
CreatedBy = model.createdBy,
LastUpdatedBy = model.lastUpdatedBy,
DateTimeCreated = DateTime.Now
};
DataContext.VehicleTypes.Add(newVehicleType);
return(DataContext.SaveChanges() > 0);
}
public bool UpdateVehicleType(VehicleTypeModel model)
{
try
{
var data = tRSEntities4.VehicleTypeMasters.Where(x => x.id == model.id && x.IsActive == true).FirstOrDefault();
if (data != null)
{
data.name = model.name;
tRSEntities4.SaveChanges();
}
return(true);
}
catch (Exception e)
{
throw e;
}
}
public async void VehicleTypeAdd()
{
// Arrange
VehicleTypeModel model = new VehicleTypeModel()
{
VehicleTypeId = 0, VehicleTypeName = "Bulldozer"
};
// Act
AjaxModel <NTModel> ajaxModel = await this.Controller.VehicleTypeAdd(model);
// Assert
VehicleTypeEntity entity = this.FleetDbContext.VehicleTypes.Last();
Assert.Equal(entity.VehicleTypeName, "Bulldozer");
Assert.Equal(ajaxModel.Message, FleetMessages.VehicleTypeSaveSuccess);
}
public async void VehicleTypeUpdate()
{
// Arrange
this.FleetDbContext.VehicleTypes.AddRange(
new VehicleTypeEntity() { VehicleTypeId = 1, VehicleTypeName = "Escavator", CompanyId = 1, DeletedInd = false },
new VehicleTypeEntity() { VehicleTypeId = 2, VehicleTypeName = "Truck", CompanyId = 1, DeletedInd = false });
await this.SaveChangesAsync(this.FleetDbContext);
VehicleTypeModel model = new VehicleTypeModel() { VehicleTypeId = 2, VehicleTypeName = "Bulldozer" };
// Act
AjaxModel<NTModel> ajaxModel = await this.Controller.VehicleTypeUpdate(model);
// Assert
VehicleTypeEntity entity = this.FleetDbContext.VehicleTypes.Where(e => e.VehicleTypeId == 2).First();
Assert.Equal(entity.VehicleTypeName, "Bulldozer");
Assert.Equal(ajaxModel.Message, FleetMessages.VehicleTypeSaveSuccess);
}
public async Task <string> AddVehicleTypeProxyService([FromBody] VehicleTypeModel vehicleTypeModel)
{
if (ModelState.IsValid)
{
var headers = new Dictionary <string, string>();
var tokenGenerated = HttpContext.Session.GetHmacToken();
headers.Add("X-Hmac", tokenGenerated);
headers.Add("X-PublicKey", HttpContext.Session.GetUserPublicKey());
string queryStr = _queryCreater.GetQueryStringFromObject(vehicleTypeModel);
var response = await HttpClientRequestFactory.Get("http://proxy.mansis.co.za:18443/SlimProxyBoot.php?" + queryStr, headers);
var data = response.Content.ReadAsStringAsync().Result;
return(data.ToString());
}
else
{
throw new Exception("Model state is not valid");
}
}
public void Add(VehicleTypeModel model)
{
var generatedPath = ImageHelper.SaveToFolder(model.ImageFile, EnitityTypesEnum.VehicleType, model.Id.ToString(), model.Name);
var image = new Image
{
Path = generatedPath
};
var dbModel = new VehicleType
{
Id = model.Id,
Name = model.Name,
Image = image
};
var createdModel = _dbContext.VehicleTypes.Add(dbModel);
_dbContext.SaveChanges();
}
public IActionResult Index()
{
StatusQuery Notification;
Notification = new StatusQuery("warning", "", "Vui lòng kiểm tra lại");
ViewBag.Status = Notification.Status;
ViewBag.Value = Notification.Value;
ViewBag.Type = Notification.Type;
var _listVehicle = _vehicletypeRepository.GetAll();
List <VehicleTypeModel> ListVehicleTypeModel = new List <VehicleTypeModel>();
foreach (var item in _listVehicle)
{
if (item.Id != 0)
{
var vehicleTypeModel = new VehicleTypeModel()
{
Active = "Đã kích hoạt",
Descreption = item.Descreption,
Name = item.Name,
Id = item.Id
};
ListVehicleTypeModel.Add(vehicleTypeModel);
}
else
{
var vehicleTypeModel = new VehicleTypeModel()
{
Active = "bbbbb",
Descreption = item.Descreption,
Name = item.Name,
Id = item.Id
};
ListVehicleTypeModel.Add(vehicleTypeModel);
}
}
return(View(ListVehicleTypeModel));
}
public IActionResult AddVehicleType([FromBody] VehicleTypeModel model)
{
try {
if (model == null)
{
return(BadRequest("Body content is not valid!"));
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var entity = model.Map <VehicleTypeEntity>();
entity = _vehicleTypeLogic.AddVehicleType(entity);
if (entity == null)
{
throw new Exception("Somthing went wrong while adding model to DB!");
}
return(Ok(entity));
} catch (Exception e) {
return(StatusCode(500, e));
}
}
//public List<VehicleTypeModel> GetVehicleTypeModels()
//{
// try
// {
// var data = tRSEntities4.VehicleTypeMasters.Where(x => x.IsActive == true).ToList();
// List<VehicleTypeModel> model = new List<VehicleTypeModel>();
// if (data!=null)
// {
// foreach (var item in data)
// {
// VehicleTypeModel vehicleType = new VehicleTypeModel();
// vehicleType.id = item.id;
// vehicleType.name = item.name;
// model.Add(vehicleType);
// }
// }
// return model;
// }
// catch (Exception e)
// {
// throw e;
// }
//}GetVehicleModels
public List <VehicleTypeModel> GetVehicleTypeModels()
{
try
{
List <VehicleTypeModel> typeModels = new List <VehicleTypeModel>();
var data = tRSEntities4.VehicleTypeMasters.Where(x => x.IsActive == true).ToList();
foreach (var item in data)
{
VehicleTypeModel model = new VehicleTypeModel
{
id = item.id,
name = item.name,
IsActive = item.IsActive,
};
typeModels.Add(model);
}
return(typeModels);
}
catch (Exception e)
{
throw e;
}
}
public bool SaveVehicleType(VehicleTypeModel model)
{
try
{
if (model != null)
{
VehicleTypeMaster vehicleType = new VehicleTypeMaster();
vehicleType.name = model.name;
vehicleType.IsActive = true;
tRSEntities4.VehicleTypeMasters.Add(vehicleType);
tRSEntities4.SaveChanges();
return(true);
}
else
{
return(false);
}
}
catch (Exception e)
{
throw e;
}
}
public VehicleTypeModel GetVehicleType(int id)
{
VehicleTypeModel model = new VehicleTypeModel();
try
{
var data = tRSEntities4.VehicleTypeMasters.Where(x => x.id == id && x.IsActive == true).FirstOrDefault();
if (data != null)
{
model.id = data.id;
model.name = data.name;
}
else
{
return(null);
}
}
catch (Exception e)
{
throw e;
}
return(model);
}
public IHttpActionResult UpdateVehicleType(VehicleTypeModel model)
{
var data = vehicleTypeRepo.UpdateVehicleType(model);
return(Ok(data));
}
//public async Task <VehicleTypeModel> VehicleTypeGet(int vehicleTypeId)
//{
// return await vehicleRepository.VehicleTypeGet(vehicleTypeId);
//}
public async Task VehicleTypeSave(VehicleTypeModel model)
{
await vehicleRepository.VehicleTypeSave(model);
}
public async Task VehicleTypeSave(VehicleTypeModel model)
{
await SaveEntity <VehicleTypeEntity, VehicleTypeModel>(model);
}
public async Task <AjaxModel <NTModel> > VehicleTypeAdd([FromBody] VehicleTypeModel model)
{
return(await AjaxHelper.SaveAsync(m => this.domain.VehicleTypeSave(model), FleetMessages.VehicleTypeSaveSuccess));
}
public static async void BtnSubmitModel(int?id, TextBox txtBox, WinFormModelTypesList.ModelTypes typeModel)
{
var request = new VehicleReferenceTableAddUpdateRequest
{
Name = txtBox.Text
};
if (typeModel.ToString() == ModelTypes.VehicleCategoryModel.ToString())
{
VehicleCategoryModel entity = null;
if (id.HasValue)
{
entity = await _vehicleCategoryService.Update <VehicleCategoryModel>(int.Parse(id.ToString()), request);
}
else
{
entity = await _vehicleCategoryService.Insert <VehicleCategoryModel>(request);
}
if (entity != null)
{
MessageBox.Show("Success!");
if (Form.ActiveForm != null)
{
Form.ActiveForm.Close();
}
}
}
if (typeModel.ToString() == ModelTypes.VehicleManufacturerModel.ToString())
{
VehicleManufacturerModel entity = null;
if (id.HasValue)
{
entity = await _vehicleManufacturerService.Update <VehicleManufacturerModel>(int.Parse(id.ToString()), request);
}
else
{
entity = await _vehicleManufacturerService.Insert <VehicleManufacturerModel>(request);
}
if (entity != null)
{
MessageBox.Show("Success!");
if (Form.ActiveForm != null)
{
Form.ActiveForm.Close();
}
}
}
if (typeModel.ToString() == ModelTypes.VehicleFuelTypeModel.ToString())
{
VehicleFuelTypeModel entity = null;
if (id.HasValue)
{
entity = await _vehicleFuelService.Update <VehicleFuelTypeModel>(int.Parse(id.ToString()), request);
}
else
{
entity = await _vehicleFuelService.Insert <VehicleFuelTypeModel>(request);
}
if (entity != null)
{
MessageBox.Show("Success!");
if (Form.ActiveForm != null)
{
Form.ActiveForm.Close();
}
}
}
if (typeModel.ToString() == ModelTypes.VehicleTransmissionTypeModel.ToString())
{
VehicleTransmissionTypeModel entity = null;
if (id.HasValue)
{
entity = await _vehicleTransmissionService.Update <VehicleTransmissionTypeModel>(int.Parse(id.ToString()), request);
}
else
{
entity = await _vehicleTransmissionService.Insert <VehicleTransmissionTypeModel>(request);
}
if (entity != null)
{
MessageBox.Show("Success!");
if (Form.ActiveForm != null)
{
Form.ActiveForm.Close();
}
}
}
if (typeModel.ToString() == ModelTypes.VehicleTypeModel.ToString())
{
VehicleTypeModel entity = null;
if (id.HasValue)
{
entity = await _vehicleTypeService.Update <VehicleTypeModel>(int.Parse(id.ToString()), request);
}
else
{
entity = await _vehicleTypeService.Insert <VehicleTypeModel>(request);
}
if (entity != null)
{
MessageBox.Show("Success!");
if (Form.ActiveForm != null)
{
Form.ActiveForm.Close();
}
}
}
}
public async Task <AjaxModel <NTModel> > VehicleTypeUpdate([FromBody] VehicleTypeModel model)
{
return(await AjaxHelper.SaveAsync(m => domain.VehicleTypeSave(model), Messages.Fleet.VehicleTypeSaveSuccess));
}
public async Task VehicleTypeSave(VehicleTypeModel model)
{
await this.fleetRepository.VehicleTypeSave(model);
}
public long CreateEminity(EminitiesModel Model, VehicleTypeModel Model1, VehicleBrandsModel Model2, ColourModel Model3)
{
return(_Ser.CreateEminity(Model, Model1, Model2, Model3));
}
public int UpdateVehicleType(VehicleTypeModel Model)
{
return(_Ser.UpdateVehicleType(Model));
}
public int CreateVehicleType(VehicleTypeModel Model)
{
return(_Ser.CreateVehicleType(Model));
}
