Beispiel #1
0
        public void CreateNewVehicle()
        {
            var currUser = new ApplicationUser()
            {
            };
            var newBattery = new Battery()
            {
                Status          = BatteryStatus.Good,
                SoftwareVersion = "2020.48.5",
                Mileage         = 30000,
                HorsePower      = 503,
                KilowattHour    = 375,
                Range           = 450,
            };
            var newVehicle = new CreateVehicleModel()
            {
                VehicleModel   = VehicleModel.Model_3,
                VehicleType    = VehicleType.Sedan,
                ImageURL       = "https://stimg.cardekho.com/images/carexteriorimages/930x620/Tesla/Tesla-Model-3/5100/1558500541732/front-left-side-47.jpg?tr=h-48",
                DateOfPurchase = new DateTime(2018, 3, 15),
                Description    = "My Tesla Model 3 car",
                ServiceId      = 1,
                BatteryId      = newBattery.Id,
            };

            this.vehicleService.CreateVehicle(currUser.Id, newVehicle);
            var expect = 1;
        }
Beispiel #2
0
        public void CreateVehicle(string userId, CreateVehicleModel vehicle)
        {
            if (this.userRepository.All().Any(x => x.Id == userId))
            {
                var currBattery   = this.batteryRepository.All().FirstOrDefault(x => x.Id == vehicle.BatteryId.Trim());
                var currInsurance = this.insuranceRepository.All().FirstOrDefault(x => x.Id == vehicle.InsuranceId.Trim());
                var currService   = this.serviceRepository.All().FirstOrDefault(x => x.Id == vehicle.ServiceId);

                if (currBattery == null || currInsurance == null || currService == null)
                {
                    return;
                }

                var currVehicle = new Vehicle()
                {
                    VehicleModel   = vehicle.VehicleModel,
                    VehicleType    = vehicle.VehicleType,
                    ImageURL       = vehicle.ImageURL,
                    DateOfPurchase = vehicle.DateOfPurchase,
                    BatteryId      = vehicle.BatteryId,
                    Battery        = currBattery,
                    UserId         = userId,
                    User           = this.userRepository.All().FirstOrDefault(x => x.Id == userId),
                    Description    = vehicle.Description,
                    InsuranceId    = vehicle.InsuranceId,
                    Insurance      = currInsurance,
                    ServiceId      = vehicle.ServiceId,
                    Service        = currService,
                };
                this.vehicleRepository.AddAsync(currVehicle).GetAwaiter().GetResult();
                this.vehicleRepository.SaveChangesAsync().GetAwaiter().GetResult();
            }
        }
Beispiel #3
0
        public async Task <IActionResult> Create(CreateVehicleModel input)
        {
            var user = await this.userManager.GetUserAsync(this.User);

            if (!Enum.IsDefined(typeof(VehicleType), input.VehicleType))
            {
                return(this.NotFound("Vehicle type not exist!"));
            }
            else if (!Enum.IsDefined(typeof(VehicleModel), input.VehicleModel))
            {
                return(this.NotFound("Vehicle model not exist!"));
            }

            var validDate = DateTime.Compare(input.DateOfPurchase, DateTime.UtcNow);

            if (validDate > 0)
            {
                return(this.ValidationProblem("You set date from future!"));
            }
            try
            {
                WebRequest  webRequest  = WebRequest.Create(input.ImageURL);
                WebResponse webResponse = await webRequest.GetResponseAsync();
            }
            catch //// If exception thrown then couldn't get response from address
            {
                return(this.NotFound());
            }

            this.vehicleService.CreateVehicle(user.Id, input);
            return(this.Redirect("All"));
        }
Beispiel #4
0
        public ActionResult CreateVehicle(CreateVehicleModel vehicle)
        {
            //var token = Session["BearerToken"].ToString();

            var url = ConfigurationManager.AppSettings["HostName"];

            if (vehicle.PlateNo != null)
            {
                var vehicleRequest = new VehicleDTO()
                {
                    PlateNo                = vehicle.PlateNo,
                    Model                  = vehicle.Model,
                    Brand                  = vehicle.Brand,
                    VehicleType            = vehicle.VehicleType,
                    ServiceWeight          = vehicle.ServiceWeight,
                    DateInTrafficFirstTime = vehicle.DateInTrafficFirstTime,
                    ServiceIsBooked        = vehicle.ServiceIsBooked
                };

                string jsonregistercar = JsonConvert.SerializeObject(vehicleRequest);
                var    httpcontent     = new StringContent(jsonregistercar, Encoding.UTF8, "application/json");
                using (HttpClient client = new HttpClient())
                {
                    var response = client.PostAsync(url + "api/vehicle", httpcontent).Result;
                }
            }
            return(View());
        }
        public async Task <VehiclesResults> Handle(VehicleAddCommand command, CancellationToken cancellationToken)
        {
            try
            {
                _logger.LogInformation("Creating contact started.");

                CreateVehicleModel vehicle = new CreateVehicleModel();
                CreateVehicleOtherPropertyModel otherVehicleProperty = new CreateVehicleOtherPropertyModel();

                vehicle.VehicleTypeId          = command.VehicleTypeId;
                vehicle.Make                   = command.Make;
                vehicle.Model                  = command.Model;
                vehicle.VehicleOtherProperties = command.VehicleOtherProperties;

                //call saving of vehicle record
                await _vehicleService.AddVehicle(vehicle);

                //check if vehicle has other property
                if (command.VehicleOtherProperties.Length > 0)
                {
                    foreach (var rec in command.VehicleOtherProperties)
                    {
                        string[] propertListValues = rec.Split("|");

                        otherVehicleProperty.VehicleTypePropertyId = Convert.ToInt32(propertListValues[0]);
                        otherVehicleProperty.PropertyValue         = propertListValues[1].ToString();
                        otherVehicleProperty.VehicleId             = vehicle.VehicleId;


                        //call saving of other vehicle property
                        await _vehicleService.AddVehicleOtherProperty(otherVehicleProperty);
                    }
                }

                return(new VehiclesResults
                {
                    StatusCode = Convert.ToInt32(HttpStatusCode.OK),
                    Message = Convert.ToString(HttpStatusCode.OK),
                    MessageDetails = ManageVehicleResponseStatus.Created,
                    VehicleId = vehicle.VehicleId
                });
            }
            catch (Exception ex)
            {
                _logger.LogError("Error creating vehicle : {ExceptionMessage}", ex.ToString());

                return(new VehiclesResults
                {
                    StatusCode = Convert.ToInt32(HttpStatusCode.InternalServerError),
                    Message = Convert.ToString(HttpStatusCode.InternalServerError),
                    MessageDetails = ManageVehicleResponseStatus.CreateFailed
                });
            }
        }
 public ActionResult CreateVehicle(CreateVehicleModel model)
 {
     try
     {
         CompanyFacade.CreateVehicle(model.Vehicle, model.CompanyId);
     }
     catch (ArgumentException e)
     {
         ViewBag.Message = e.Message;
         return(View(model));
     }
     return(RedirectToAction("CompanyVehicles", new { companyId = model.CompanyId }));
 }
        public Vehicle Create(CreateVehicleModel model)
        {
            var brand = _databaseService.Brands.Find(model.BrandId);


            var vehicle = _factory.Create(model.RegistrationNumber, brand, model.RegistrationDate);


            _databaseService.Vehicles.Add(vehicle);

            _databaseService.Save();

            return(vehicle);
        }
        private Vehicle GetOrCreateVehicle()
        {
            var vehicle = _database.Vehicles.Where(v => v.RegistrationNumber == _model.VehicleRegistrationNumber).FirstOrDefault();

            if (vehicle == null)
            {
                var createVehicleModel = new CreateVehicleModel();
                createVehicleModel.RegistrationNumber = _model.VehicleRegistrationNumber;
                createVehicleModel.RegistrationDate   = _model.VehicleRegistrationDate;
                createVehicleModel.BrandId            = _model.BrandId;
                vehicle = _vehicleCommand.Create(createVehicleModel);
            }
            return(vehicle);
        }
Beispiel #9
0
        public async Task CreateVehicle(CreateVehicleModel vehicle)
        {
            var vehicleType = await _typeRepo
                              .GetVehicleTypesByName(vehicle.VehicleType)
                              .SingleOrDefaultAsync();

            if (vehicleType == null)
            {
                vehicleType = new ExampleVehicleType {
                    Name = vehicle.VehicleType
                };
                await _typeRepo.Add(vehicleType);
            }

            var entity = Mapper.Map <ExampleVehicle>(vehicle);

            entity.VehicleType = vehicleType;
            await _vehicleRepo.Add(entity);
        }
Beispiel #10
0
        public async Task <IActionResult> Create([Bind("Name,Abrv,MakeId")] CreateVehicleModel createVehicleModel)
        {
            if (ModelState.IsValid)
            {
                try
                {
                    var vehicleModel  = _mapper.Map <CreateVehicleModel, VehicleModel>(createVehicleModel);
                    var numberOfSaves = await _vehicleModelService.CreateVehicleModelAsync(vehicleModel);

                    return(RedirectToAction(nameof(Index), new { makeId = vehicleModel.MakeId }));
                }
                catch (Exception)
                {
                    return(RedirectToAction("Error", "Home"));
                }
            }

            return(View(createVehicleModel));
        }
        public async Task <VehicleEntity> Create(CreateVehicleModel model)
        {
            var vehicle = new VehicleEntity
            {
                ModelName            = model.ModelName,
                ModelYear            = model.ModelYear,
                BodyStyle            = model.BodyStyle,
                ManufacturerEntityId = model.ManufacturerEntityId,
                CreateUserId         = model.CreateUserId,
                CreateDate           = DateTime.UtcNow.ToLocalTime(),
                ModifyUserId         = model.ModifyUserId,
                ModifyDate           = DateTime.UtcNow.ToLocalTime(),
                StatusId             = 1
            };

            _unitOfWork.Add(vehicle);
            await _unitOfWork.CommitAsync();

            return(vehicle);
        }
Beispiel #12
0
        public async Task <int> AddVehicle(CreateVehicleModel vehicleModel)
        {
            await _createVehicleCommand.Execute(vehicleModel);

            return(vehicleModel.VehicleId);
        }
        public async Task <int> AddVehicle(CreateVehicleModel vehicleModel)
        {
            vehicleModel.VehicleId = 1;

            return(vehicleModel.VehicleId);
        }
Beispiel #14
0
        // Check entity on create
        public string ValidateVehicleCreating(CreateVehicleModel vehicle, AspNetUser currentUser, IModelService modelService)
        {
            if (vehicle.LicenseNumber.Length > 50)
            {
                return("Biển số xe phải dưới 50 ký tự.");
            }

            if (vehicle.Name.Length > 100)
            {
                return("Tên xe phải dưới 100 ký tự.'");
            }

            if (modelService.Get().All(m => m.ID != vehicle.ModelID))
            {
                return("Dòng xe không tồn tại.");
            }

            if (vehicle.Year < Models.Constants.MIN_YEAR || vehicle.Year > DateTime.Now.Year)
            {
                return("Năm sản xuất không hợp lệ");
            }

            if (currentUser.Garages.All(g => g.ID != vehicle.GarageID))
            {
                return("Garage không tồn tại.");
            }

            if (vehicle.VehicleGroupID.HasValue && currentUser.VehicleGroups.All(g => g.ID != vehicle.VehicleGroupID))
            {
                return("Nhóm xe không tồn tại.");
            }

            if (!Models.Constants.TRANSMISSION_TYPE.ContainsKey(vehicle.TransmissionType))
            {
                return("Loại hộp số không hợp lệ.");
            }

            if (vehicle.FuelType.HasValue && !Models.Constants.FUEL_TYPE.ContainsKey(vehicle.FuelType.Value))
            {
                return("Loại nhiên liệu không hợp lệ");
            }

            if (vehicle.TransmissionDetail != null && vehicle.TransmissionDetail.Length > 100)
            {
                return("Chi tiết hộp số phải dưới 100 ký tự.");
            }

            if (vehicle.Engine != null && vehicle.Engine.Length > 100)
            {
                return("Chi tiết động cơ phải dưới 100 ký tự.");
            }

            if (vehicle.Description != null && vehicle.Description.Length > 1000)
            {
                return("Mô tả xe phải dưới 1000 ký tự.");
            }

            if (!Models.Constants.COLOR.ContainsKey(vehicle.Color))
            {
                return("Mã màu không hợp lệ.");
            }

            return(null);
        }
Beispiel #15
0
        public async Task <ActionResult> CreateVehicleAPI(CreateVehicleModel newVehicle)
        {
            var modelService = this.Service <IModelService>();
            var userId       = this.User.Identity.GetUserId();
            var currentUser  = this.Service <IUserService>().Get(userId);

            var errorMessage = ValidateVehicleCreating(newVehicle, currentUser, modelService);

            if (errorMessage != null)
            {
                Response.StatusCode = 400;
                return(Json(new { message = errorMessage }));
            }

            var newVehicleEntity = this.Mapper.Map <Vehicle>(newVehicle);

            if (Request.Files.Count < 4 || Request.Files.Count > 10)
            {
                Response.StatusCode = 400;
                return(Json(new { message = "Chỉ được phép upload từ 4 đến 10 hình." }));
            }

            // Upload images to cloudinary
            var cloudinary = new CloudinaryDotNet.Cloudinary(Models.Constants.CLOUDINARY_ACC);
            var imageList  = new List <VehicleImage>();

            try
            {
                foreach (string fileName in Request.Files)
                {
                    var file = Request.Files[fileName];
                    if (file?.ContentLength <= 0)
                    {
                        continue;
                    }

                    // Upload to cloud
                    var uploadResult = cloudinary.Upload(new ImageUploadParams()
                    {
                        File = new FileDescription(file.FileName, file.InputStream)
                    });

                    // Get the image's id and url
                    imageList.Add(new VehicleImage()
                    {
                        ID = uploadResult.PublicId, URL = uploadResult.Uri.ToString()
                    });
                }
            }
            catch (Exception ex)
            {
                Response.StatusCode = 500;
                return(Json(new { message = "Upload ảnh thất bại. Vui lòng thử lại sau." }));
            }

            var vehicleService = this.Service <IVehicleService>();
            await vehicleService.CreateAsync(newVehicleEntity);

            foreach (var image in imageList)
            {
                image.VehicleID = newVehicleEntity.ID;
                image.Vehicle   = newVehicleEntity;
            }

            newVehicleEntity.VehicleImages = imageList;
            await vehicleService.UpdateAsync(newVehicleEntity);

            Response.StatusCode = 200;
            return(Json(new { message = "Tạo xe thành công." }));
        }
        public async Task <IActionResult> CreateNewVehicle(CreateVehicleModel vehicle)
        {
            await _service.CreateVehicle(vehicle);

            return(Ok());
        }
Beispiel #17
0
        public IActionResult Create()
        {
            var viewModel = new CreateVehicleModel();

            return(this.View(viewModel));
        }