public void Create_GivenInvalidData_ShouldThrowException()
{
// arrange
int ownerId = 1;
CarCreateViewModel model = new CarCreateViewModel()
{
Brand = "TestBrand",
CarModel = "TestModel",
Year = 1234,
HasAirConditioner = true,
Image = new Mock <IFormFile>().Object
};
IMapper mapper = new Mapper(new MapperConfiguration(cfg =>
cfg.CreateMap <CarCreateViewModel, Car>()
.ForMember(car => car.Id, opt => opt.Ignore())
.ForMember(car => car.Image, opt => opt.Ignore())));
Mock <IDbRepository <Car> > mockRepository = new Mock <IDbRepository <Car> >();
mockRepository
.Setup(x => x.CreateAsync(It.IsAny <Car>()))
.ThrowsAsync(new InvalidOperationException());
var service = new CarsService(mockRepository.Object, mapper);
// act
Func <Task> action = () => service.Create(model, ownerId);
// assert
action.Should().ThrowExactly <CarCreateException>()
.WithMessage("Failed has car creating.");
}
public IActionResult Create(CarCreateViewModel viewModel)
{
if (ModelState.IsValid)
{
Car newcar = new Car
{
RegistrationNumber = viewModel.RegistrationNumber,
Make = viewModel.Make,
Model = viewModel.Model,
ProductionYear = viewModel.ProductionYear,
Id = new Guid(),
IsAvailable = true,
IsReserved = false,
BodyType = viewModel.BodyType,
Color = viewModel.Color,
EngineSize = viewModel.EngineSize,
FuelType = viewModel.FuelType,
GearboxType = viewModel.GearboxType,
Milage = viewModel.Milage,
NextTechCheckDate = viewModel.RegistrationDate.AddYears(3),
PowerHP = viewModel.PowerHP,
PowerkW = viewModel.PowerkW,
RegistrationDate = viewModel.RegistrationDate,
ServiceInterval = viewModel.ServiceInterval,
SpecType = viewModel.SpecType,
VIN = viewModel.VIN,
NextServiceMilage = viewModel.ServiceInterval,
};
_carsrepository.Add(newcar);
return(RedirectToAction("details", new { id = newcar.Id }));
}
return(View());
}
public async Task <IActionResult> Create(CarCreateViewModel model)
{
if (!this.ModelState.IsValid)
{
return(this.View(model));
}
var user = await this.userManager.GetUserAsync(this.User);
var files = model.CarImages;
var carId = await this.carService.CreateAsync(
model.Year,
model.ModelId,
model.MakeId,
model.FuelType,
model.TransmissionsId,
model.CubicCapacity,
model.RegistrationNumber,
model.HorsePower,
user.Id);
if (files != null)
{
var urlOfProducts = await this.carImageService.UploadAsync(this.cloudinary, files);
await this.carImageService.AddImageInBase(urlOfProducts, carId);
}
return(this.Redirect("MyCars"));
}
public async Task Create(CarCreateViewModel model, int ownerId)
{
Require.ThatObjectIsNotNull(model);
Require.ThatIntIsPositive(ownerId);
try
{
Car car = this.mapper.Map <Car>(model);
using (var ms = new MemoryStream())
{
await model.Image.CopyToAsync(ms);
car.Image = ms.ToArray();
}
car.OwnerId = ownerId;
await this.cars.CreateAsync(car);
}
catch (Exception ex)
{
// TODO: Log exception
throw new CarCreateException("Failed has car creating.");
}
}
public void Create_GivenValidModelAndOwnerId_ShouldReturnCompletedTask()
{
// arrange
int ownerId = 1;
CarCreateViewModel model = new CarCreateViewModel()
{
Brand = "TestBrand",
CarModel = "TestModel",
Year = 1234,
HasAirConditioner = true,
Image = new Mock <IFormFile>().Object
};
IMapper mapper = new Mapper(new MapperConfiguration(cfg =>
cfg.CreateMap <CarCreateViewModel, Car>()
.ForMember(car => car.Id, opt => opt.Ignore())
.ForMember(car => car.Image, opt => opt.Ignore())));
Mock <IDbRepository <Car> > mockRepository = new Mock <IDbRepository <Car> >();
mockRepository
.Setup(x => x.CreateAsync(It.IsAny <Car>()))
.Returns(Task.FromResult(new Car()));
var service = new CarsService(mockRepository.Object, mapper);
// act
Func <Task> action = async() => await service.Create(model, ownerId);
// assert
action.Should().NotThrow();
}
public async Task <IActionResult> Create([Bind("OwnerId,Model,Year,Color")] CarCreateViewModel user)
{
try
{
if (ModelState.IsValid)
{
var serializedItem = JsonSerializer.Serialize(user);
var response = await client.PostAsync(APIDATA.URL + $"Cars", new StringContent(serializedItem, Encoding.UTF8, "application/json"));
if (response.IsSuccessStatusCode)
{
return(RedirectToAction(nameof(Index)));
}
else
{
AddModelError();
}
}
}
catch
{
AddModelError();
}
var json = await client.GetStringAsync(APIDATA.URL + $"Users/Select");
var users = JsonSerializer.Deserialize <IEnumerable <SelectItem> >(json);
ViewData["OwnerId"] = new SelectList(users, "Value", "Text");
return(View(user));
}
public ActionResult Create()
{
var viewModel = new CarCreateViewModel();
viewModel.AvailableBranches = branchRepo.Get();
return(View(viewModel));
}
// GET: Cars/Create
public IActionResult Create()
{
CarCreateViewModel model = new CarCreateViewModel
{
Drivers = GetDrivers()
};
return(View(model));
}
public bool Post(CarCreateViewModel model)
{
return(CarsDAL.Post(new Car()
{
OwnerId = model.OwnerId,
Model = model.Model,
Year = model.Year,
Color = model.Color
}));
}
public ActionResult CarGridViewNew(CarCreateViewModel carVM)
{
if (ModelState.IsValid)
{
try
{
if (carVM != null)
{
HseqCaseFile hseqCaseFile;
Car car = new Car();
Mapper.Map(carVM, car);
//Car car = new Car()
//{
// CaseNo = carVM.CaseNo,
// RecordNo = carVM.RecordNo,
// Title = carVM.Title,
// Description = carVM.Description,
// JobNumber = carVM.JobNumber,
// DrawingNumber = carVM.DrawingNumber,
// RecordType = carVM.RecordType,
// EnteredBy = carVM.EnteredBy,
// ReportedBy = carVM.ReportedBy,
// CreatedBy = carVM.CreatedBy,
// DateCreated = carVM.DateCreated,
// CoordinatorID = carVM.CoordinatorID
//};
car = (Car)_RecordService.CreateCaseFile(car, out hseqCaseFile, db);
db.HseqRecords.Add(car);
db.SaveChanges();
}
}
catch (AutoMapperConfigurationException autoMapperException)
{
throw autoMapperException.InnerException;
}
catch (AutoMapperMappingException autoMapperException) {
throw autoMapperException.InnerException;
}
catch (Exception e)
{
ViewData["EditError"] = e.Message;
return(PartialView("_CarNewView", carVM));
}
}
else
{
ViewData["EditError"] = "Please, correct all errors.";
return(PartialView("_CarNewView", carVM));
}
return(PartialView("_MainContentCallbackPanel"));
}
public async Task <IActionResult> Create(CarCreateViewModel model)
{
if (!this.ModelState.IsValid)
{
return(this.View(model));
}
var id = await this.carService.Create(model);
return(this.RedirectToAction("Details", new { id = id }));
}
public ActionResult Delete(int carId)
{
var viewModel = new CarCreateViewModel();
viewModel.New = carRepo.GetById(carId);
viewModel.AvailableBranches = branchRepo.Get();
return(View(viewModel));
}
protected override ValidationResult IsValid(object value, ValidationContext validationContext)
{
CarCreateViewModel model = (CarCreateViewModel)validationContext.ObjectInstance;
if (model.Manufacturer != "Fiat")
{
return(ValidationResult.Success);
}
return(new ValidationResult(GetErrorMessage()));
}
public ActionResult CreatePost(CarCreateViewModel model)
{
if (model.New.BranchId <= 0)
{
}
else
{
carRepo.Create(model.New);
}
return(RedirectToAction("Index"));
}
public ActionResult Create(CarCreateViewModel model)
{
if (!Security.IsAuthenticate)
{
return RedirectToAction("Index", "Car");
}
if(!ModelState.IsValid)
{
return View("Create",model);
}
return RedirectToAction("Index", "Car");
}
private string ProcessUploadedFile(CarCreateViewModel model)
{
string uniqueFileName = null;
if (model.Photo != null)
{
string uploadsFolder = Path.Combine(hostingEnvironment.WebRootPath, "img");
uniqueFileName = Guid.NewGuid().ToString() + "_" + model.Photo.FileName;
string filePath = Path.Combine(uploadsFolder, uniqueFileName);
model.Photo.CopyTo(new FileStream(filePath, FileMode.CreateNew));
}
return(uniqueFileName);
}
public IActionResult Create(CarCreateViewModel model)
{
Car car = new Car
{
Manufacturer = model.Manufacturer,
MOT = model.MOT,
DriverID = model.SelectedDriverId
};
carRepository.InsertCar(car);
carRepository.Save();
return(RedirectToAction("Index"));
}
public void Create_GivenModelWithNullImage_ShouldThrowException()
{
// arrange
int ownerId = 1;
CarCreateViewModel model = new CarCreateViewModel();
CarsService service = new CarsService(null, null);
// act
Func <Task> action = () => service.Create(model, ownerId);
// assert
action.Should().Throw <Exception>();
}
public void Create_GivenNegativeOwnerId_ShouldThrowNegativeIntException()
{
// arrange
int ownerId = -1;
CarCreateViewModel model = new CarCreateViewModel();
CarsService service = new CarsService(null, null);
// act
Func <Task> action = () => service.Create(model, ownerId);
// asert
action.Should().ThrowExactly <NegativeIntException>();
}
public async Task <int> Create(CarCreateViewModel input)
{
var carOwner = carOwnerReposotiry.All().FirstOrDefault(x => x.Name == input.Name);
var car = mapper.Map <Car>(input);
car.CarOwner = carOwner;
await this.carReposotiry.AddAsync(car);
await this.carReposotiry.SaveChangesAsync();
var id = car.Id;
return(id);
}
public async Task <IHttpActionResult> CreateCar()
{
ResponseDataDTO <string> response = new ResponseDataDTO <string>();
try
{
var path = Path.GetTempPath();
if (!Request.Content.IsMimeMultipartContent("form-data"))
{
throw new HttpResponseException(Request.CreateResponse(HttpStatusCode.UnsupportedMediaType));
}
MultipartFormDataStreamProvider streamProvider = new MultipartFormDataStreamProvider(path);
await Request.Content.ReadAsMultipartAsync(streamProvider);
// save file
string fileName = "";
foreach (MultipartFileData fileData in streamProvider.FileData)
{
fileName = FileExtension.SaveFileOnDisk(fileData);
}
// get data from formdata
CarCreateViewModel CarCreateViewModel = new CarCreateViewModel
{
CarNumber = Convert.ToString(streamProvider.FormData["CarNumber"])
};
// mapping view model to entity
var createdCar = _mapper.Map <Car>(CarCreateViewModel);
// save new Car
_Carservice.Create(createdCar);
// return response
response.Code = HttpCode.OK;
response.Message = MessageResponse.SUCCESS;
response.Data = fileName;
return(Ok(response));
} catch (Exception ex)
{
response.Code = HttpCode.INTERNAL_SERVER_ERROR;
response.Message = MessageResponse.FAIL;
response.Data = null;
Console.WriteLine(ex.ToString());
return(Ok(response));
}
}
public async Task <IActionResult> Create(CarCreateViewModel model,
[FromServices] ICarsService carsService,
[FromServices] UserManager <ApplicationUser> userManager)
{
if (this.ModelState.IsValid)
{
try
{
int userId = int.Parse(userManager.GetUserId(User));
await carsService.Create(model, userId);
return(Json(new { success = "true", message = "Car successfully created." }));
}
catch (CarCreateException ex)
{
return(Json(new { success = "false", message = ex.Message }));
}
}
return(this.PartialView("_CreateModal", model));
}
public IActionResult Create(CarCreateViewModel model)
{
if (ModelState.IsValid)
{
string uniqueFileName = null;
if (model.Photo != null)
{
string uploadsFolder = Path.Combine(hostingEnvironment.WebRootPath, "images");
uniqueFileName = Guid.NewGuid().ToString() + "_" + model.Photo.FileName;
string filePath = Path.Combine(uploadsFolder, uniqueFileName);
model.Photo.CopyTo(new FileStream(filePath, FileMode.Create));
}
Car newCar = new Car
{
CarName = model.CarName,
Color = model.Color,
Category = model.Category,
VIN = model.VIN,
CarDescription = model.CarDescription,
Model = model.Model,
Brand = model.Brand,
PhotoPath = uniqueFileName
};
_context.Add(newCar);
_context.SaveChanges();
/*
* book.customer = await _context.Customers.FindAsync(userManager.GetUserId(HttpContext.User));
* _context.Add(book);
* await _context.SaveChangesAsync();
* return RedirectToAction("myBooks", "book");*/
return(RedirectToAction("index", "home"));
}
return(View());
}
public IActionResult Create(CarCreateViewModel model)
{
// check if we have valid data in the form
if (ModelState.IsValid)
{
string uniqueFileName = ProcessUploadedFile(model);
Car newCar = new Car
{
CarName = model.CarName,
VehicleClass = model.VehicleClass,
Capacity = model.Capacity,
CarType = model.CarType,
Price = model.Price,
PhotoPath = uniqueFileName
// Store the file name in PhotoPath property of the car object
// which gets saved to the Cars database table
};
_carRepository.Add(newCar);
return(RedirectToAction("Details", "Home", new { id = newCar.Id }));
}
return(View());
}
public ActionResult DeletePost(CarCreateViewModel model)
{
carRepo.Delete(model.New);
return(RedirectToAction("Index"));
}
public bool Post(CarCreateViewModel model) => CarsBL.Post(model);
public IActionResult Edit([FromForm] CarCreateViewModel vg)
{
return(View(vg));
}
public ActionResult MainContentCallbackPanel()
// DXCOMMENT: Pass a data model for GridView in the PartialView method's second parameter
{
if (DevExpressHelper.IsCallback)
{
NavigationFilter.RecordTypeCheckState = null;
NavigationFilter.ResponsibleAreaCheckState = null;
NavigationFilter.CoordinatorsCheckState = null;
NavigationFilter.RecordTypes = null;
NavigationFilter.ResponsibleAreaIds = null;
NavigationFilter.CoordinatorIds = null;
//Checked, Unchecked, Indeterminate
NavigationFilter.RecordTypeCheckState = Request.Params["recordTypeCheckState"];
NavigationFilter.ResponsibleAreaCheckState = Request.Params["responsibleAreaCheckState"];
NavigationFilter.CoordinatorsCheckState = Request.Params["coordinatorsCheckState"];
//Record Type
if (!string.IsNullOrEmpty(Request.Params["recordTypeCheckedNodes"]))
{
string recordTypeNodes = Request.Params["recordTypeCheckedNodes"];
NavigationFilter.RecordTypes = recordTypeNodes.Split(',');
setActiveTab();
}
//Responsible Area Type
if (!string.IsNullOrEmpty(Request.Params["responsibleAreaCheckedNodes"]))
{
string responsibleAreaNodes = Request.Params["responsibleAreaCheckedNodes"];
NavigationFilter.ResponsibleAreaIds = Array.ConvertAll(responsibleAreaNodes.Split(','), int.Parse);
}
if (!string.IsNullOrEmpty(Request.Params["coordinatorsCheckedNodes"]))
{
string responsibleAreaNodes = Request.Params["coordinatorsCheckedNodes"];
NavigationFilter.CoordinatorIds = Array.ConvertAll(responsibleAreaNodes.Split(','), int.Parse);
}
//ViewData["Collapsed"] = false;
//edit
if (!string.IsNullOrEmpty(Request.Params["EditRecord"]))
{
if (!string.IsNullOrEmpty(Request.Params["currentActiveView"]) && !string.IsNullOrEmpty(Request.Params["recordId"]))
{
string currentActiveView = Request.Params["currentActiveView"];
int recordId = int.Parse(Request.Params["recordId"]);
if (currentActiveView.Contains("Task"))
{
HseqTask record = db.HseqTasks.Find(recordId);
HseqTaskEditViewModel HseqTaskEditVM = Mapper.Map <HseqTask, HseqTaskEditViewModel>(record);
ViewData["record"] = HseqTaskEditVM;
ViewData["currentview"] = "_Task" + EDIT_VIEW_PREFIX;
}
else if (currentActiveView.Contains("Approval"))
{
HseqApprovalRequest record = db.HseqApprovalRequests.Find(recordId);
HseqApprovalEditViewModel HseqApprovalEditVM = Mapper.Map <HseqApprovalRequest, HseqApprovalEditViewModel>(record);
ViewData["record"] = HseqApprovalEditVM;
ViewData["currentview"] = "_Approval" + EDIT_VIEW_PREFIX;
}
////////////////////////////////////////
else if (currentActiveView.Contains("Ncr"))
{
Ncr record = db.NcrRecords.Find(recordId);
NcrEditViewModel ncrEditVM = Mapper.Map <Ncr, NcrEditViewModel>(record);
ViewData["record"] = ncrEditVM;
ViewData["currentview"] = "_Ncr" + EDIT_VIEW_PREFIX;
}
else if (currentActiveView.Contains("Car"))
{
Car record = db.CarRecords.Find(recordId);
CarEditViewModel carEditVM = Mapper.Map <Car, CarEditViewModel>(record);
ViewData["record"] = carEditVM;
ViewData["currentview"] = "_Car" + EDIT_VIEW_PREFIX;
}
else if (currentActiveView.Contains("Par"))
{
Par record = db.ParRecords.Find(recordId);
ParEditViewModel parEditVM = Mapper.Map <Par, ParEditViewModel>(record);
ViewData["record"] = parEditVM;
ViewData["currentview"] = "_Par" + EDIT_VIEW_PREFIX;
}
else if (currentActiveView.Contains("Fis"))
{
Fis record = db.FisRecords.Find(recordId);
FisEditViewModel fisEditVM = Mapper.Map <Fis, FisEditViewModel>(record);
ViewData["record"] = fisEditVM;
ViewData["currentview"] = "_Fis" + EDIT_VIEW_PREFIX;
}
}
}
//new
else if (!string.IsNullOrEmpty(Request.Params["NewRecord"]))
{
if (!string.IsNullOrEmpty(Request.Params["currentActiveView"]))
{
string currentActiveView = Request.Params["currentActiveView"];
if (currentActiveView.Contains("Ncr"))
{
Ncr ncr = new Ncr();
ncr.CaseNo = _RecordService.GetNextCaseNumber(db);
ncr.RecordNo = ncr.CaseNo;
ncr.CreatedBy = _RecordService.GetCurrentApplicationUser().FullName;
ncr.DateCreated = DateTime.Now;
ncr.RecordType = RecordType.NCR;
ncr.NcrSource = NcrSource.Internal;
ncr.NcrState = NcrState.New;
NcrCreateViewModel carVM = Mapper.Map <Ncr, NcrCreateViewModel>(ncr);
ViewData["record"] = carVM;
ViewData["currentview"] = "_Ncr" + NEW_VIEW_PREFIX;
}
else if (currentActiveView.Contains("Car"))
{
Car car = new Car();
car.CaseNo = _RecordService.GetNextCaseNumber(db);
car.RecordNo = car.CaseNo;
car.CreatedBy = _RecordService.GetCurrentApplicationUser().FullName;
car.DateCreated = DateTime.Now;
car.RecordType = RecordType.CAR;
CarCreateViewModel carVM = Mapper.Map <Car, CarCreateViewModel>(car);
ViewData["record"] = carVM;
ViewData["currentview"] = "_Car" + NEW_VIEW_PREFIX;
}
else if (currentActiveView.Contains("Par"))
{
Par par = new Par();
par.CaseNo = _RecordService.GetNextCaseNumber(db);
par.RecordNo = par.CaseNo;
par.CreatedBy = _RecordService.GetCurrentApplicationUser().FullName;
par.DateCreated = DateTime.Now;
par.RecordType = RecordType.PAR;
ParCreateViewModel parVM = Mapper.Map <Par, ParCreateViewModel>(par);
ViewData["record"] = parVM;
ViewData["currentview"] = "_Par" + NEW_VIEW_PREFIX;
}
else if (currentActiveView.Contains("Fis"))
{
Fis fis = new Fis();
fis.CaseNo = _RecordService.GetNextCaseNumber(db);
fis.RecordNo = fis.CaseNo;
fis.CreatedBy = _RecordService.GetCurrentApplicationUser().FullName;
fis.DateCreated = DateTime.Now;
fis.RecordType = RecordType.FIS;
FisCreateViewModel fisVM = Mapper.Map <Fis, FisCreateViewModel>(fis);
ViewData["record"] = fisVM;
ViewData["currentview"] = "_Fis" + NEW_VIEW_PREFIX;
}
}
}
//// Task ///////////////////
else if (!string.IsNullOrEmpty(Request.Params["addTask"]))
{
if (!string.IsNullOrEmpty(Request.Params["currentActiveView"]) && !string.IsNullOrEmpty(Request.Params["recordId"]))
{
string currentActiveView = Request.Params["currentActiveView"];
int recordId = int.Parse(Request.Params["recordId"]);
HseqTask hseqTask = new HseqTask()
{
Status = TaskStatus.NotStarted
};
HseqRecord hseqRecord = db.HseqRecords.Find(recordId);
hseqTask.HseqRecordID = hseqRecord.HseqRecordID;
hseqTask.HseqRecord = hseqRecord;
HseqTaskCreateViewModel hseqTaskVM = Mapper.Map <HseqTask, HseqTaskCreateViewModel>(hseqTask);
ViewData["record"] = hseqTaskVM;
ViewData["currentview"] = "_Task" + NEW_VIEW_PREFIX;
}
}
//// Approval ///////////////////
else if (!string.IsNullOrEmpty(Request.Params["addApproval"]))
{
if (!string.IsNullOrEmpty(Request.Params["currentActiveView"]) && !string.IsNullOrEmpty(Request.Params["recordId"]))
{
string currentActiveView = Request.Params["currentActiveView"];
int recordId = int.Parse(Request.Params["recordId"]);
HseqApprovalRequest hseqApproval = new HseqApprovalRequest()
{
Response = ApprovalResult.Waiting,
Status = ApprovalStatus.Active,
DateAssigned = DateTime.Now
};
HseqRecord hseqRecord = db.HseqRecords.Find(recordId);
hseqApproval.HseqRecordID = hseqRecord.HseqRecordID;
hseqApproval.HseqRecord = hseqRecord;
HseqApprovalCreateViewModel hseqApprovalVM = Mapper.Map <HseqApprovalRequest, HseqApprovalCreateViewModel>(hseqApproval);
ViewData["record"] = hseqApprovalVM;
ViewData["currentview"] = "_Approval" + NEW_VIEW_PREFIX;
}
}
//// Linked Record ///////////////////
else if (!string.IsNullOrEmpty(Request.Params["createLinkedRecord"]) &&
!string.IsNullOrEmpty(Request.Params["linkedRecordDetails"]))
{
if (!string.IsNullOrEmpty(Request.Params["recordId"]))
{
int recordId = int.Parse(Request.Params["recordId"]);
var linkedRecordDetails = Request.Params["linkedRecordDetails"].Split('-');
var sourceRecord = linkedRecordDetails[0];
var targetRecord = linkedRecordDetails[1];
//Ncr to Car
if (sourceRecord == "NCR")
{
if (targetRecord == "CAR")
{
Ncr ncr = db.NcrRecords.Find(recordId);
Car car = new Car(ncr)
{
CreatedBy = _RecordService.GetCurrentApplicationUser().FullName,
DateCreated = DateTime.Now,
RecordType = RecordType.CAR
};
CarVM carVM = new CarVM()
{
Car = car,
LinkedRecord = true,
SourceRecordId = ncr.HseqRecordID
};
ViewData["record"] = carVM;
ViewData["currentview"] = "_Car" + LINKED_VIEW_PREFIX;
}
}
}
}
else
{
ViewData["currentview"] = "_MainContentTabPanel";
}
}
return(PartialView("_MainContentCallbackPanel"));
}
