Ejemplo n.º 1
0
        internal async void Nuevo()
        {
            //if (ListaVehiculos.Exists(x => x.Matricula == VehiculoSelected.Matricula))
            //{
            //    MessageBox.Show("Coche existente");
            //}
            //else
            //{
            try
            {
                VehiculoDTO v = await _webApiClient.CreateVehiculo(VehiculoSelected);

                //Si el coche devuelto !=null es porque se creo y lo añadimos a la collection observable
                if (v != null)
                {
                    ListaVehiculos.Add(v);
                }
                else
                {
                    MessageBox.Show("Coche existente");
                }
            }
            catch (WebApiException e)
            {
                MessageBox.Show(e.Message);
            }
        }
Ejemplo n.º 2
0
        public async Task <VehiculoDTO> CreateVehiculo(VehiculoDTO vehiculo)
        {
            try
            {
                HttpClient client = GetClient();

                string jfdJson        = JsonConvert.SerializeObject(vehiculo);
                var    jfdBuffer      = Encoding.UTF8.GetBytes(jfdJson);
                var    jfdByteContent = new ByteArrayContent(jfdBuffer);
                jfdByteContent.Headers.ContentType = new MediaTypeHeaderValue("application/json");

                var response = await client.PostAsync("api/Vehiculos", jfdByteContent);

                if (response.IsSuccessStatusCode)
                {
                    var vehiculoReturn = await response.Content.ReadAsAsync <VehiculoDTO>();

                    return(vehiculoReturn);
                }
                else if (response.StatusCode == HttpStatusCode.InternalServerError)
                {
                    throw new WebApiException(response.ReasonPhrase);
                }
                return(null);
            }
            catch (Exception ex)
            {
                throw;
            }
        }
Ejemplo n.º 3
0
        public async Task <IActionResult> Registrar([FromBody] VehiculoDTO vehiculo, [FromQuery] int userId)
        {
            var car = new Vehiculo()
            {
                Marca          = vehiculo.Marca,
                Modelo         = vehiculo.Modelo,
                CantidadPlazas = vehiculo.CantidadPlazas,
                Patente        = vehiculo.Patente,
                Color          = vehiculo.Color,
                Foto           = vehiculo.Foto,
                TipoVehiculo   = vehiculo.TipoVehiculo
            };

            try
            {
                var user = this.userRepository.GetAllUserById(userId);

                var newCar = this.genericRepo.Create(car);

                user.Vehiculos.Add(newCar.Result);
                this.userRepository.Update(user.Id, user);

                return(Ok());
            }
            catch (Exception)
            {
                // return BuildApiResponse.BuildNotOk( "Hubo un error al registrar");
                return(BadRequest("Hubo un error al registrar"));
            }
        }
Ejemplo n.º 4
0
        public IEnumerable <VehiculoDTO> GetStock()
        {
            var vehiculos = _context.Vehiculo.ToList();

            //Mapeo de Vehiculo a VehiculoDTO
            List <VehiculoDTO> vehiculosdto = new List <VehiculoDTO>();

            foreach (var v in vehiculos)
            {
                var vehiculo = new VehiculoDTO
                {
                    Matricula       = v.Matricula,
                    Marca           = v.Marca,
                    Modelo          = v.Modelo,
                    Tipo            = v.Tipo,
                    Precio          = v.Precio,
                    Kilometros      = v.Kilometros,
                    Color           = v.Color,
                    Combustible     = v.Combustible,
                    FechaEntrada    = v.FechaEntrada.ToString(),
                    IdConcesionario = v.IdConcesionario,
                    IdCliente       = v.IdCliente,
                    Vendido         = v.Vendido,
                };
                if (vehiculo.Vendido == 0)
                {
                    vehiculosdto.Add(vehiculo);
                }
            }

            return(vehiculosdto);
        }
        private void btnVerVehiculo_Click(object sender, RoutedEventArgs e)
        {
            VehiculoDTO vehiculoDTO = ((VehiculoDTO)gestionAlquileresViewModel.alquiler.vehiculo);

            vehiculoDTO.urlImage = "/Images/ico_rojo.png";
            LoginWindow.mainWindow.selectRb(1);
            UpdateViewCommand.viewModel.SelectedViewModel = new GestionVehiculoViewModel(vehiculoDTO);
        }
Ejemplo n.º 6
0
        public void saveVehicule(VehiculoDTO datos)
        {
            Resgistrar resgistrar = new  Resgistrar(
                datos.Placa, datos.Dueno, datos.Marca
                );

            _dataSql.saveVehiculo(resgistrar);
        }
Ejemplo n.º 7
0
        private void ocultarMostrar(int modo)
        {
            switch (modo)
            {
            case 1:
                //Ocultar
                btnModificar.Visibility = Visibility.Hidden;
                btnBaja.Visibility      = Visibility.Hidden;
                panelDisp.Visibility    = Visibility.Hidden;

                //Por defecto
                cmbPlazas.SelectedIndex  = 0;
                cmbTamanio.SelectedIndex = 0;
                vehiculoModif            = new VehiculoDTO();

                break;

            case 2:
                //Ocultar
                btnAceptarVehiculo.Visibility  = Visibility.Hidden;
                btnCancelarVehiculo.Visibility = Visibility.Hidden;
                btnSeleccionarPC.Visibility    = Visibility.Hidden;

                //Mostrar
                btnModificar.Visibility = Visibility.Visible;
                panelDisp.Visibility    = Visibility.Visible;

                //Deshabilitar
                txtMatricula.IsEnabled          = false;
                dtpFecha.IsEnabled              = false;
                txtModelo.IsEnabled             = false;
                cmbPlazas.IsEnabled             = false;
                cmbTamanio.IsEnabled            = false;
                txtKilometros.IsEnabled         = false;
                btnImgVehiculo.IsHitTestVisible = false;
                break;

            case 3:
                //Ocultar
                btnModificar.Visibility = Visibility.Hidden;

                //Mostrar
                btnAceptarVehiculo.Visibility  = Visibility.Visible;
                btnCancelarVehiculo.Visibility = Visibility.Visible;
                btnSeleccionarPC.Visibility    = Visibility.Visible;
                panelDisp.Visibility           = Visibility.Visible;

                //Habilitar
                txtMatricula.IsEnabled          = true;
                dtpFecha.IsEnabled              = true;
                txtModelo.IsEnabled             = true;
                cmbPlazas.IsEnabled             = true;
                cmbTamanio.IsEnabled            = true;
                txtKilometros.IsEnabled         = true;
                btnImgVehiculo.IsHitTestVisible = true;
                break;
            }
        }
Ejemplo n.º 8
0
        public RegistrarInfraccion(VehiculoDTO v)
        {
            InitializeComponent();

            _v                                = v;
            _webApiClient                     = new DGTApiClient();;
            labelConductor.Content            = v.Dni;
            labelMatricula.Content            = v.Matricula;
            comboInfraccion.ItemsSource       = _webApiClient.GetInfracciones();
            comboInfraccion.DisplayMemberPath = "Descripcion";
        }
Ejemplo n.º 9
0
        public async Task <ActionResult> Post([FromForm] VehiculoDTO vehiculoDTO)
        {
            vehiculoDTO.Foto = await _helperImage.Upload(vehiculoDTO.Image, directory);

            var vehiculo = _mapper.Map <Vehiculo>(vehiculoDTO);
            await _vehiculoService.InsertVehiculo(vehiculo);

            vehiculoDTO = _mapper.Map <VehiculoDTO>(vehiculo);
            var response = new ApiResponse <VehiculoDTO>(vehiculoDTO);

            return(Created(nameof(Get), new { id = vehiculo.Id, response }));
        }
Ejemplo n.º 10
0
 // POST api/<controller>
 public HttpResponseMessage Post([FromBody] VehiculoDTO vehiculo)
 {
     try
     {
         var v = _service.CrearVehiculo(vehiculo.Matricula, vehiculo.Marca, vehiculo.Modelo, vehiculo.Dni);
         return(Request.CreateResponse(HttpStatusCode.OK, _mapper.Map <VehiculoDTO, Vehiculo>(v)));
     }
     catch (Exception e)
     {
         return(Request.CreateResponse(HttpStatusCode.InternalServerError, e.Message));
     }
 }
Ejemplo n.º 11
0
        public async Task <ActionResult> Put(int id, [FromForm] VehiculoDTO vehiculoDTO)
        {
            await DeleteImage(id);

            vehiculoDTO.Foto = await _helperImage.Upload(vehiculoDTO.Image, directory);

            var vehiculo = _mapper.Map <Vehiculo>(vehiculoDTO);

            vehiculo.Id = id;
            await _vehiculoService.UpdateVehiculo(vehiculo);

            return(NoContent());
        }
Ejemplo n.º 12
0
        private void cargarDatos(int modo)
        {
            if (modo == Constantes.CONSULTA)
            {
                if (null != gestionVehiculoViewModel.vehiculo.nombreImagenPermiso &&
                    0 != gestionVehiculoViewModel.vehiculo.nombreImagenPermiso.Length)
                {
                    txtPermiso.Text = gestionVehiculoViewModel.vehiculo.nombreImagenPermiso;
                    cargarFotoPermiso();
                }

                cargarFoto();
            }

            vehiculoModif = gestionVehiculoViewModel.vehiculo;

            string matricula = gestionVehiculoViewModel.vehiculo.matricula;

            txtTitulo.Text    = matricula;
            txtMatricula.Text = matricula;

            DateTime dt = DateTime.ParseExact(gestionVehiculoViewModel.vehiculo.fechaMatriculacion, "dd/MM/yyyy", CultureInfo.InvariantCulture);

            dtpFecha.SelectedDate = dt;

            txtModelo.Text = gestionVehiculoViewModel.vehiculo.modelo;

            txtKilometros.Text = gestionVehiculoViewModel.vehiculo.km.ToString();

            if (gestionVehiculoViewModel.vehiculo.disponibilidad)
            {
                txtDisponible.Text = "Disponible";
            }
            else
            {
                txtDisponible.Text = "Alquilado";
            }

            Uri resourceUri = new Uri(gestionVehiculoViewModel.vehiculo.urlImage, UriKind.Relative);

            imgDisponible.Source = new BitmapImage(resourceUri);

            cmbPlazas.Text  = gestionVehiculoViewModel.vehiculo.plazas.ToString();
            cmbTamanio.Text = gestionVehiculoViewModel.vehiculo.capacidad.ToString();

            //TODO IMG
            txtPermiso.Text = gestionVehiculoViewModel.vehiculo.nombreImagenPermiso;

            ocultarMostrar(modo);
        }
Ejemplo n.º 13
0
        public async Task <ActionResult <ConductorVehiculosDTO> > InsertarVehiculo(VehiculoDTO vehiculo)
        {
            ConductorVehiculosDTO v;

            try
            {
                v = await _apiService.InsertarVehiculo(vehiculo);
            }
            catch (ApiException e)
            {
                return(BadRequest(new  ApiErrorRespuesta(e.Mensaje)));
            }

            return(Ok(v));
        }
        public void Add(VehiculoDTO vehiculoDTO)
        {
            var vehiculo = new Vehículo
            {
                NumSerial    = vehiculoDTO.NumSerie,
                Modelo       = vehiculoDTO.Modelo,
                Marca        = vehiculoDTO.Marca,
                Tipo         = vehiculoDTO.Tipo,
                Precio       = vehiculoDTO.Precio,
                FechaEntrada = vehiculoDTO.FechaEntrada,
                InfAdicional = vehiculoDTO.InfAdicional
            };

            _context.Vehículo.Add(vehiculo);
            _context.SaveChanges();
        }
Ejemplo n.º 15
0
        /// <summary>
        /// Parseo de DTO a Modelo
        /// </summary>
        /// <param name="vehiculoDTO"></param>
        /// <returns>Vehiculo</returns>
        private Vehiculo transformVehiculoDTOToVehiculo(VehiculoDTO vehiculoDTO)
        {
            Vehiculo vehiculo = new Vehiculo();

            vehiculo.capacidad          = vehiculoDTO.capacidad;
            vehiculo.fechaMatriculacion = vehiculoDTO.fechaMatriculacion;
            vehiculo.km                  = vehiculoDTO.km;
            vehiculo.matricula           = vehiculoDTO.matricula;
            vehiculo.modelo              = vehiculoDTO.modelo;
            vehiculo.plazas              = vehiculoDTO.plazas;
            vehiculo.disponibilidad      = vehiculoDTO.disponibilidad;
            vehiculo.baja                = vehiculoDTO.baja;
            vehiculo.nombreImagen        = vehiculoDTO.nombreImagen;
            vehiculo.nombreImagenPermiso = vehiculoDTO.nombreImagenPermiso;

            return(vehiculo);
        }
Ejemplo n.º 16
0
        public async Task <ConductorVehiculosDTO> InsertarVehiculo(VehiculoDTO vehiculoDTO)
        {
            var conductor = await _conductorRepo.GetConductorByDniAsync(vehiculoDTO.Dni);

            if (conductor == null)
            {
                throw new ApiException("Conductor no existe");
            }

            var vehiculo = await _vehiculosRepo.GetVehiculoByMatriculaAsync(vehiculoDTO.Matricula);

            if (vehiculo != null)
            {
                throw new ApiException("Existe un vehículo con la misma matrícula");
            }
            else
            {
                var numeroCoches = _vehiculoConductorRepo.GetNoVehiculosPorIdConductor(conductor.Id);
                if (numeroCoches >= 10)
                {
                    throw new ApiException("El conductor ya es habitual en 10 coches");
                }

                var newV = new Vehiculo(vehiculoDTO.Matricula, vehiculoDTO.Marca, vehiculoDTO.Modelo);
                var newC = new Conductor(conductor.Dni, conductor.Nombre, conductor.Apellidos, conductor.Puntos);

                _vehiculoConductorRepo.Insert(new VehiculosConductor(newC, newV));
                //_vehiculosRepo.Insert(v);

                var res = await _vehiculoConductorRepo.Complete();

                if (res <= 0)
                {
                    throw new ApiException("Error al Guardar los datos");
                }

                return(new ConductorVehiculosDTO {
                    Apellidos = newC.Apellidos,
                    Puntos = newC.Puntos,
                    Nombre = newC.Nombre,
                    Dni = newC.Dni,
                    NumeroVehiculos = numeroCoches
                });
            }
        }
Ejemplo n.º 17
0
        public VehiculoDTO ToVehiculoDTO(Vehiculo vehiculo)
        {
            var response = new VehiculoDTO
            {
                Id           = vehiculo.IdVehiculo,
                Equipamiento = vehiculoUtils.EquipamientoAsList(vehiculo),
                Estado       = vehiculo.IdEstadoVehiculoNavigation.Codigo
            };


            if (vehiculo.IdCilindradaNavigation != null)
            {
                response.Cilindrada = vehiculo.IdCilindradaNavigation.Descripcion;
            }

            if (vehiculo.IdModeloMarcaNavigation != null)
            {
                response.Modelo = vehiculo.IdModeloMarcaNavigation.Descripcion;
                if (vehiculo.IdModeloMarcaNavigation.IdMarcaNavigation != null)
                {
                    response.Marca = vehiculo.IdModeloMarcaNavigation.IdMarcaNavigation.Descripcion;
                }
            }

            response.Locacion = new LocacionDTO
            {
                Latitud   = vehiculo.Latitud,
                Longitud  = vehiculo.Longitud,
                Pais      = vehiculo.Pais,
                Provincia = vehiculo.Provincia,
                Localidad = vehiculo.Localidad
            };

            if (vehiculo.IdPrestadorNavigation != null)
            {
                response.Usuario = usuarioMapper.ToUsuarioDTO(vehiculo.IdPrestadorNavigation);
            }

            return(response);
        }
        public IEnumerable <VehiculoDTO> Get()
        {
            var vehiculos = _context.Vehículo.ToList();

            //Mapeo de Vehículo a VehiculoDTO
            List <VehiculoDTO> vehiculosDTO = new List <VehiculoDTO>();

            foreach (var i in vehiculos)
            {
                var vehiculo = new VehiculoDTO
                {
                    NumSerie     = i.NumSerial,
                    Modelo       = i.Modelo,
                    Marca        = i.Marca,
                    Tipo         = i.Tipo,
                    Precio       = i.Precio,
                    FechaEntrada = i.FechaEntrada,
                    InfAdicional = i.InfAdicional
                };
                vehiculosDTO.Add(vehiculo);
            }
            return(vehiculosDTO);
        }
Ejemplo n.º 19
0
        public List <InfoConductor> Resolve(Vehiculo source, VehiculoDTO destination, List <InfoConductor> destMember, ResolutionContext context)
        {
            var conductores = new List <InfoConductor>();

            if (source.ConductorVehiculos == null)
            {
                return(null);
            }

            foreach (var conductor in source.ConductorVehiculos)
            {
                var infoConductor = new InfoConductor
                {
                    Dni       = conductor.Dni,
                    Nombre    = conductor.Conductor.Nombre,
                    Apellidos = conductor.Conductor.Apellidos,
                    Puntos    = conductor.Conductor.Puntos
                };
                conductores.Add(infoConductor);
            }

            return(conductores);
        }
Ejemplo n.º 20
0
 public void Add(VehiculoDTO vehiculoDTO)
 {
     _vehiculoRepository.Add(vehiculoDTO);
 }
Ejemplo n.º 21
0
 public GestionVehiculoViewModel(VehiculoDTO vehiculoDTO)
 {
     _vehiculo = vehiculoDTO;
 }
Ejemplo n.º 22
0
        /// <summary>
        /// Con el id "null" guarda un nuevo objeto y, en caso contrario, modifica el objeto de la BD
        /// </summary>
        /// <param name="vehiculoDTO"></param>
        /// <param name="id"></param>
        /// <returns>ServerResponseVehiculo</returns>
        public ServerResponseVehiculo Save(VehiculoDTO vehiculoDTO, string id)
        {
            ServerResponseVehiculo serverResponseVehiculo = null;

            try
            {
                OauthToken oauthToken = ServerService.obtenerToken();

                if (null != oauthToken)
                {
                    var url = Constantes.SERVIDOR + VEHICULO + "save/" + id;

                    var httpRequest = (HttpWebRequest)WebRequest.Create(url);
                    httpRequest.Method = "POST";

                    httpRequest.Headers["Authorization"] = "Bearer " + oauthToken.access_token;
                    httpRequest.ContentType = "application/json";

                    Vehiculo vehiculo = transformVehiculoDTOToVehiculo(vehiculoDTO);

                    if (null != vehiculo)
                    {
                        var data = JsonSerializer.Serialize <Vehiculo>(vehiculo);

                        using (var streamWriter = new StreamWriter(httpRequest.GetRequestStream()))
                        {
                            streamWriter.Write(data);
                        }

                        var httpResponse = (HttpWebResponse)httpRequest.GetResponse();
                        using (var streamReader = new StreamReader(httpResponse.GetResponseStream()))
                        {
                            var result = streamReader.ReadToEnd();

                            serverResponseVehiculo = JsonSerializer.Deserialize <ServerResponseVehiculo>(result);
                        }

                        //Console.WriteLine(httpResponse.StatusCode);
                    }
                    else
                    {
                        serverResponseVehiculo = new ServerResponseVehiculo();

                        ErrorBean error = new ErrorBean();
                        error.code    = MessageExceptions.SERVER_ERROR;
                        error.message = MessageExceptions.MSSG_SERVER_ERROR;

                        serverResponseVehiculo.error = error;
                    }
                }
                else
                {
                    serverResponseVehiculo = new ServerResponseVehiculo();

                    ErrorBean error = new ErrorBean();
                    error.code    = MessageExceptions.SERVER_ERROR;
                    error.message = MessageExceptions.MSSG_SERVER_ERROR;

                    serverResponseVehiculo.error = error;
                }
            }
            catch (System.Exception)
            {
                serverResponseVehiculo = new ServerResponseVehiculo();

                ErrorBean error = new ErrorBean();
                error.code    = MessageExceptions.SERVER_ERROR;
                error.message = MessageExceptions.MSSG_SERVER_ERROR;

                serverResponseVehiculo.error = error;
            }

            return(serverResponseVehiculo);
        }
Ejemplo n.º 23
0
 protected ActionResult <bool> Add(VehiculoDTO vehiculoDTO)
 {
     _vehiculoBL.Add(vehiculoDTO);
     return(Ok(true));
 }