Example #1
0
        public IActionResult GetCarById(int id)
        {
            Car car = carRepository.GetCarById(id);

            if (car == null)
            {
                return(NotFound("Car doesn't exist"));
            }
            CarViewModel carVm = this.entitytoVmMapper.Map(car);

            return(Ok(carVm));
        }
Example #2
0
        public async Task <IActionResult> Edit(int id)
        {
            var car = await _carService.GetByIdAsync(id);

            var editViewModel = new CarViewModel
            {
                Title = "Edit Car",
                Car   = car
            };

            return(View(editViewModel));
        }
Example #3
0
 public ActionResult Feedback(CarViewModel model)
 {
     try
     {
         _ICarService.SaveFeedbackSvc(model);
     }
     catch (Exception ex)
     {
         throw ex;
     }
     return(View());
 }
Example #4
0
        public ActionResult Delete(int id)
        {
            CarViewModel carVM = new CarViewModel();

            using (CarServiceReference.CarClient carService = new CarServiceReference.CarClient())
            {
                CarDto carDto = carService.GetCarById(id);
                carVM = new CarViewModel(carDto);
            }

            return(View(carVM));
        }
Example #5
0
        public CarViewModel GetDetailCar(int id)
        {
            var carModel = service.GetDetailCar(id);

            var carViewModel = new CarViewModel
            {
                Id    = carModel.Id,
                Model = carModel.Model,
            };

            return(carViewModel);
        }
        public async Task <ActionResult> Edit(CarViewModel carViewModel)
        {
            if (ModelState.IsValid)
            {
                var car = carViewModel.ToEntityModel();
                await db.Update(car);

                TempData["Message"] = "You have saved the car!";
                return(RedirectToAction("Index"));
            }
            return(View(carViewModel));
        }
Example #7
0
        public async Task <IActionResult> Create([Bind("CarID,Description,Model,BrandID,Color,Transmission,Condition,FuelType,GearType,BodyType,EngineSize,NoOfSeats,Price,Mileage,Category,Images")] CarViewModel carvm)
        {
            if (ModelState.IsValid)
            {
                UploadCarInformation(carvm);
                await _context.SaveChangesAsync();

                return(RedirectToAction(nameof(Index)));
            }
            ViewData["BrandID"] = new SelectList(_context.Brands, "BrandID", "BrandName", carvm.BrandID);
            return(View(carvm));
        }
        public IActionResult Edit(int id)
        {
            IEnumerable <CarDTO> carDTOs      = carService.GetCars();
            CarViewModel         carViewModel = Mapper.Map <IEnumerable <CarDTO>, IEnumerable <CarViewModel> >(carDTOs).SingleOrDefault(c => c.Id == id);

            if (carViewModel == null)
            {
                return(NotFound());
            }

            return(View(carViewModel));
        }
 public ActionResult Create(CarViewModel model)
 {
     if (ModelState.IsValid)
     {
         using (_connection = SqlConnectionHelper.GetOpenConnection())
         {
             _connection.Insert(model);
         }
         return(RedirectToAction("index"));
     }
     return(View(model));
 }
Example #10
0
        public IActionResult Index()
        {
            CarViewModel carViewModel = new CarViewModel()
            {
                CAR_BRANDS = turboAzContext.CAR_BRAND.ToList(),
                CAR_MODEL  = turboAzContext.CAR_MODEL.ToList(),
                CITY       = turboAzContext.GENERAL_INFO.Where(x => x.TYPE_ID == 7).ToList(),
                Currency   = turboAzContext.GENERAL_INFO.Where(x => x.TYPE_ID == 3).ToList()
            };

            return(View("Index", carViewModel));
        }
Example #11
0
        public CarViewModel GetDetails(int id)
        {
            CarModel carModel = carViewModelRepo.GetDetails(id);

            var carViewModel = new CarViewModel()
            {
                Id    = carModel.Id,
                Model = carModel.Model
            };

            return(carViewModel);
        }
        private CarViewModel CreateViewModelFromCar(Car car)
        {
            var viewModel = new CarViewModel
            {
                Id         = car.Id,
                Brand      = car.Brand,
                Conso      = car.Conso,
                StartConso = car.StartConso
            };

            return(viewModel);
        }
        private void Window_Loaded(object sender, RoutedEventArgs e)
        {
            CarFactory obj  = new CarFactory();
            Car_Table  Cobj = obj.GetAllCarT(CarId);

            _vm.CA_RegNo     = Cobj.CA_RegNo;
            _vm.CA_Color     = Cobj.CA_Color;
            _vm.CA_Company   = Cobj.CA_Company;
            _vm.CA_Model     = Cobj.CA_Model;
            _vm              = new CarViewModel();
            this.DataContext = _vm;
        }
        public ActionResult Create(CarViewModel carViewModel, HttpPostedFileBase uploadImage)
        {
            if (ModelState.IsValid && uploadImage != null)
            {
                carViewModel.Image = carViewModel.Image = _service.GetCarImage(uploadImage);
                var carDto = carViewModel.ToCarDto();
                _service.AddCar(carDto);

                return(RedirectToAction("Index"));
            }
            return(View(carViewModel));
        }
Example #15
0
        public ActionResult AddNewCar()
        {
            var          brands       = carBrandRepository.GetAll().ToList();
            var          carTypes     = carTypeRepository.GetAll().ToList();
            CarViewModel carViewModel = new CarViewModel
            {
                Brands   = new SelectList(brands.Select(brand => brand.Brand).ToList()),
                CarTypes = new SelectList(carTypes.Select(type => type.Type).ToList())
            };

            return(View(carViewModel));
        }
Example #16
0
        public async System.Threading.Tasks.Task<ActionResult> Details(int? id)
        {
            CarViewModel cvm = new CarViewModel();
           
           cvm.car = db.Cars.Find(id);
            if (cvm.car == null)
            {
                return new HttpStatusCodeResult(HttpStatusCode.BadRequest);
            }
            HttpResponseMessage response;
            var client = new BingSearchContainer(new Uri("https://api.datamarket.azure.com/Bing/search/")
                   );
            client.Credentials = new NetworkCredential("accountKey", "JDNjFEYyxMGlhlX66nh3S6hQ8aQVOLmI8LJO4QQgdVE");
            var marketData = client.Composite(
                "image",
                $"{cvm.car.model_year} {cvm.car.make} {cvm.car.model_name} {cvm.car.model_trim}",
                null,
                null,
                null,
                null,
                null,
                null,
                null,
                null,
                null,
                null,
                null,
                null,
                null
                ).Execute();

              cvm.imageUrl = marketData.FirstOrDefault()?.Image?.FirstOrDefault()?.MediaUrl;
            
            using (var httpclient = new HttpClient())
            {
                httpclient.BaseAddress = new Uri("Http://www.nhtsa.gov/");

                try
                {
                    response = await httpclient.GetAsync($"webapi/api/Recalls/vehicle/modelyear/{cvm.car.model_year}/make/{cvm.car.make}/model/{cvm.car.model_name}?format=json");
                    cvm.recalls = JsonConvert.DeserializeObject(await response.Content.ReadAsStringAsync());
                }

                catch (Exception e)
                {
                    return new HttpStatusCodeResult(HttpStatusCode.InternalServerError);
                }
            }

            return View(cvm);

        }
Example #17
0
        public IActionResult CreateCar(CarViewModel carViewModel)
        {
            var car = new AwesomeCar
            {
                CarName         = carViewModel.CarName,
                BrandName       = carViewModel.BrandName,
                MileAge         = carViewModel.MileAge,
                producerCountry = carViewModel.producerCountry
            };

            _awesomeCarQueryHandler.Add(car);
            return(RedirectToAction("Index"));
        }
        public async Task <IActionResult> NewCar(CarViewModel car)
        {
            try
            {
                await this.carManager.AddNewCarAsync(car);

                return(RedirectToAction("Index"));
            }
            catch (Exception ex)
            {
                return(BadRequest(ex.Message));
            }
        }
Example #19
0
        public async Task <IActionResult> Update([FromBody] CarViewModel car)
        {
            ValidationUtils.CheckViewModelNotIsNull(car);
            ModelState.CheckModelStateValidation();

            var carDTO = _mapper.Map <CarViewModel, CarDTO>(car);

            carDTO = await _carService.Update(carDTO);

            var editedCar = _mapper.Map <CarDTO, CarViewModel>(carDTO);

            return(Ok(editedCar));
        }
Example #20
0
        public void AddCarToDealer(int dealerId, CarViewModel car)
        {
            var dealer = dataBase.Dealers.Get(dealerId);

            // Конфигурирование AutoMapper
            Mapper.Initialize(cfg => cfg.CreateMap <CarViewModel, Car>());
            // Отображение объекта CarViewModel на объект Car
            var c = Mapper.Map <Car>(car);

            // добавить авто
            dealer.Cars.Add(c);
            dataBase.Save();
        }
Example #21
0
        public async Task <IActionResult> Post(CarViewModel car)
        {
            ;
            if (!this.ModelState.IsValid)
            {
                return(NotFound("Invalid data!!!"));
            }
            ;
            await this.carsService.Add(car, car.UserId);

            ;
            return(Ok("Done!!!"));
        }
        public IActionResult Details(int id)
        {
            var car  = this.carService.GetCar(id);
            var user = this.userManager.GetUserAsync(HttpContext.User).Result;

            var model = new CarViewModel(car)
            {
                IsFavorite    = userService.IsCarFavorite(id, user),
                StatusMessage = this.StatusMessage
            };

            return(this.View(model));
        }
Example #23
0
        public async Task <IActionResult> EditCar(CarViewModel viewModel)
        {
            if (ModelState.IsValid)
            {
                var data = await _repository.UpdateCar(viewModel);

                if (data)
                {
                    return(RedirectToAction("Index", new RouteValueDictionary(new { status = data })));
                }
            }
            return(View(viewModel));
        }
Example #24
0
        public IActionResult EditCar(string statenumber)
        {
            ViewData["StateNumber"] = statenumber;
            CarViewModel carViewModel = new CarViewModel();
            Car          car          = carManager.GetCar(statenumber);

            carViewModel.Color       = car.Color;
            carViewModel.Make        = car.Manufacturer;
            carViewModel.Model       = car.Model;
            carViewModel.StateNumber = car.StateNumber;
            carViewModel.Year        = car.Year;
            return(View(carViewModel));
        }
        public ActionResult Index()
        {
            var cars = _context.Cars
                       .Where(car => !car.IsRemoved)
                       .OrderByDescending(car => car.Id)
                       .ToList();

            var model = new CarViewModel {
                Cars = cars
            };

            return(View(model));
        }
Example #26
0
 public static CarDto ToCarDto(this CarViewModel car)
 {
     return(new CarDto
     {
         Id = car.Id,
         ModelName = car.ModelName,
         Image = car.Image,
         Color = car.Color,
         Price = car.Price,
         Transmission = car.Transmission,
         Valume = car.Valume
     });
 }
        public ActionResult New()
        {
            //Construim o masina noua, fara date
            Car car = new Car();

            //Constuim un car view model
            CarViewModel carViewModel = new CarViewModel();

            carViewModel.Car         = car;
            carViewModel.ListDrivers = GetAllDrivers();

            return(View(carViewModel));
        }
Example #28
0
        public async Task <IActionResult> CheckIfExists(CarViewModel model)
        {
            string redisKey = model.AutoMaker + model.Name + model.Year;

            if (!_redis.KeyExists(redisKey))
            {
                return(NotFound("That car didn't exists!!!"));
            }

            var car = (await _redis.StringGetAsync(redisKey)).ToString().FromJsonTo <CarViewModel>();

            return(Ok(car));
        }
Example #29
0
        public ActionResult Edit(CarViewModel model)
        {
            if (ModelState.IsValid)
            {
                using (_connection = Utilities.GetOpenConnection())
                {
                    _connection.Update(model);
                }
                return(RedirectToAction("index"));
            }

            return(View(model));
        }
Example #30
0
 public IActionResult Create(CarViewModel carViewModel)
 {
     if (ModelState.IsValid)
     {
         Car.carList.Add(new Car()
         {
             Brand     = carViewModel.Brand,
             ModelName = carViewModel.ModelName
         });
         return(RedirectToAction("Index"));
     }
     return(View(carViewModel));
 }
Example #31
0
        public async Task <ActionResult <int> > Post([FromBody] CarViewModel carViewModel)
        {
            try
            {
                var id = await carManager.AddNewCarAsync(carViewModel);

                return(Ok(id));
            }
            catch (CarException ex)
            {
                return(BadRequest(ex.Message));
            }
        }
Example #32
0
        void InsertAtPosition(int pos, CarViewModel car)
        {
            //now we can insert it at correct place

            //check if we have correct number of slots before inserting
            if (pos >= MainViewModel.Cars.Count)
            {
                for (int items = pos + 1 - MainViewModel.Cars.Count; items > 0; --items)
                {
                    //blank car
                    MainViewModel.Cars.Add(new CarViewModel()
                    {
                        CarId = -1,
                        TablePosition = pos + 1
                    });
                }
            }

            MainViewModel.Cars[pos] = car;
        }
Example #33
0
 private IActionResult CreateNewCar(CarViewModel carVm)
 {
     if (_carRepository.GetItem(u => u.Plate == carVm.Plate) == null)
     {
         Car car = _mapper.Map<Car>(carVm);
         return SaveData(() =>
         {
             _carRepository.Add(car);
         },
         () =>
         {
             this.Response.StatusCode = (int)HttpStatusCode.Created;
             return this.Json(new JsonResult(this.Json(_mapper.Map<CarViewModel>(car)))
             {
                 StatusCode = this.Response.StatusCode
             });
         });
     }
     else
     {
         this.Response.StatusCode = (int)HttpStatusCode.BadRequest;
         return this.Json(new JsonResult($"Car with plate '{carVm.Plate}' already exist.")
         {
             StatusCode = this.Response.StatusCode
         });
     }
 }