Beispiel #1
0
        /*================================================================================
         * GET ITINERARIOS
         *================================================================================*/
        public static ObservableCollection <Itinerario> GetItinerarios(long IdLinea)
        {
            // Creamos la lista.
            ObservableCollection <Itinerario> lista = new ObservableCollection <Itinerario>();

            using (OleDbConnection conexion = new OleDbConnection(App.Global.CadenaConexionLineas))
            {
                string comandoSQL = "SELECT * FROM Itinerarios WHERE IdLinea=? ORDER BY Nombre";

                OleDbCommand Comando = new OleDbCommand(comandoSQL, conexion);
                Comando.Parameters.AddWithValue("idlinea", IdLinea);
                OleDbDataReader lector = null;

                try {
                    conexion.Open();
                    // Ejecutamos el comando y extraemos los gráficos del lector a la lista.
                    lector = Comando.ExecuteReader();
                    while (lector.Read())
                    {
                        Itinerario itinerario = new Itinerario(lector);
                        itinerario.ListaParadas = BdParadas.GetParadas(itinerario.Id);
                        lista.Add(itinerario);
                        itinerario.Nuevo      = false;
                        itinerario.Modificado = false;
                    }
                } catch (Exception ex) {
                    Utils.VerError("BdItinerarios.GetItinerarios", ex);
                } finally {
                    lector.Close();
                }
            }
            return(lista);
        }
Beispiel #2
0
        /*================================================================================
         * GET ITINERARIO BY NOMBRE
         *================================================================================*/
        public static Itinerario GetItinerarioByNombre(decimal nombre)
        {
            Itinerario itinerario = null;

            using (OleDbConnection conexion = new OleDbConnection(App.Global.CadenaConexionLineas))
            {
                // Creamos el comando que extrae el itinerario
                string comandoSQL = "SELECT * FROM Itinerarios WHERE Nombre = ?";

                OleDbCommand Comando = new OleDbCommand(comandoSQL, conexion);
                Comando.Parameters.AddWithValue("nombre", nombre.ToString());
                OleDbDataReader lector = null;

                try {
                    conexion.Open();

                    lector = Comando.ExecuteReader();

                    if (lector.Read())
                    {
                        itinerario = new Itinerario(lector);
                        itinerario.ListaParadas = BdParadas.GetParadas(itinerario.Id);
                    }
                } catch (Exception ex) {
                    Utils.VerError("BdItinerarios.GetItinerarioByNombre", ex);
                } finally {
                    lector.Close();
                }
            }

            return(itinerario);
        }
Beispiel #3
0
        private Pais CurrentPaisItinerario(Itinerario itinerario, IEnumerable <Visa> visas_usuario)
        {
            bool change = false;

            foreach (var viaje in itinerario.Viajes)
            {
                change = false;
                var visas = GetVisasPais(viaje.Pais);

                if (visas.Count() != 0)
                {
                    foreach (var visa in visas)
                    {
                        if (visas_usuario.Contains(visa))
                        {
                            change = true;
                            break;
                        }
                    }

                    if (change)
                    {
                        continue;
                    }

                    return(viaje.Pais);
                }
                else
                {
                    continue;
                }
            }

            return(null);
        }
Beispiel #4
0
        public async Task <CommandResult> Handle(AdicionarItinerarioCommand request, CancellationToken cancellationToken)
        {
            var motorista = await _motoristaRepository.ObterPorId(request.MotoristaId);

            if (motorista == null)
            {
                AddNotification("Motorista", "Motorista não encontrado.");
            }

            var veiculo = await _veiculoRepository.ObterPorId(request.VeiculoId);

            if (veiculo == null)
            {
                AddNotification("Veículo", "Veículo não encontrado.");
            }

            var itinerario = new Itinerario(motorista, veiculo);
            await _itinerarioRepository.AddAsync(itinerario);

            GerarEntregasNoItinerario(request.Entregas, itinerario);

            HandleEntity(itinerario);

            if (!IsSuccess())
            {
                return(new CommandResult(false, "Existem notificações"));
            }

            await CommitAsync();

            return(new CommandResult(true, "Executado sem notificações", new {  }));
        }
        public void QuandoAtualizoUmaCotacaoDeFreteAsPropriedadesSaoAlteradas()
        {
            ProcessoDeCotacaoDeFrete processo = DefaultObjects.ObtemProcessoDeCotacaoDeFrete();

            Produto         produto         = DefaultObjects.ObtemProdutoPadrao();
            UnidadeDeMedida unidadeDeMedida = DefaultObjects.ObtemUnidadeDeMedidaPadrao();
            Itinerario      itinerario      = DefaultObjects.ObtemItinerarioPadrao();

            var dataLimiteDeRetorno = DateTime.Today.AddDays(15);
            var dataValidadeInicial = DateTime.Today.AddMonths(2);
            var dataValidadeFinal   = DateTime.Today.AddMonths(3);


            processo.Atualizar("requisitos alterados", "1500", dataLimiteDeRetorno,
                               dataValidadeInicial, dataValidadeFinal, itinerario);

            processo.AtualizarItem(produto, 1500, unidadeDeMedida);

            var item = processo.Itens.First();

            //Assert.AreSame(produto, processo.Produto);
            //Assert.AreEqual(1500, processo.Quantidade);
            //Assert.AreSame(unidadeDeMedida, processo.UnidadeDeMedida);
            Assert.AreSame(produto, item.Produto);
            Assert.AreEqual(1500, item.Quantidade);
            Assert.AreSame(unidadeDeMedida, item.UnidadeDeMedida);
            Assert.AreEqual("requisitos alterados", processo.Requisitos);
            Assert.AreEqual("1500", processo.NumeroDoContrato);
            Assert.AreEqual(dataLimiteDeRetorno, processo.DataLimiteDeRetorno);
            Assert.AreEqual(dataValidadeInicial, processo.DataDeValidadeInicial);
            Assert.AreEqual(dataValidadeFinal, processo.DataDeValidadeFinal);
            Assert.AreSame(itinerario, processo.Itinerario);
        }
Beispiel #6
0
        public async Task <IActionResult> PutItinerario(int id, Itinerario itinerario)
        {
            if (id != itinerario.Id)
            {
                return(BadRequest());
            }

            _context.Entry(itinerario).State = EntityState.Modified;

            try
            {
                await _context.SaveChangesAsync();
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!ItinerarioExists(id))
                {
                    return(NotFound());
                }
                else
                {
                    throw;
                }
            }

            return(NoContent());
        }
Beispiel #7
0
        public async Task <ActionResult <Itinerario> > PostItinerario(Itinerario itinerario)
        {
            _context.Itinerarios.Add(itinerario);
            await _context.SaveChangesAsync();

            return(CreatedAtAction("GetItinerario", new { id = itinerario.Id }, itinerario));
        }
        public async Task <IHttpActionResult> PostItinerario(Itinerario itinerario)
        {
            if (itinerario == null)
            {
                return(BadRequest("El modelo esta vacio"));
            }

            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }

            DetalleItinerario detalles = new DetalleItinerario();

            try
            {
                detalles.Salida = DateTime.Now;
                db.DetallesItinerarios.Add(detalles);

                await db.SaveChangesAsync();
            }
            catch (Exception e) {
                var a = e.Message;
            }
            itinerario.DetalleItinerarioId = detalles.Id;
            db.Itinerarios.Add(itinerario);

            await db.SaveChangesAsync();

            return(CreatedAtRoute("DefaultApi", new { id = itinerario.Id }, itinerario));
        }
Beispiel #9
0
 public List <Entidad> ConsultarItinerarios(int id_usuario)
 {
     try
     {
         comando = FabricaComando.CrearComandoConsultarItinerarios(id_usuario);
         comando.Ejecutar();
         List <Itinerario> listaItinerarios = new List <Itinerario>();
         foreach (Entidad item in comando.RetornarLista())
         {
             Itinerario itinerarioNew = (Itinerario)item;
             listaItinerarios.Add(itinerarioNew);
         }
         return(comando.RetornarLista());
     }
     catch (NpgsqlException)
     {
         throw new HttpResponseException(HttpStatusCode.InternalServerError);
     }
     catch (ArgumentException)
     {
         throw new HttpResponseException(HttpStatusCode.InternalServerError);
     }
     catch (InvalidCastException)
     {
         throw new HttpResponseException(HttpStatusCode.BadRequest);
     }
     catch (Exception)
     {
         throw new HttpResponseException(HttpStatusCode.Ambiguous);
     }
 }
Beispiel #10
0
        public async Task <ActionResult> AddorEdit(int id = 0)
        {
            IEnumerable <Repartidor> repartidores;

            repartidores = await repartidoresService.obtenerRepartidores();

            IEnumerable <Zona> zonas;

            zonas = await zonasService.obtenerZonas();

            //IEnumerable<DetalleItinerario> detalles;
            //detalles = await detallesService.obtenerDetalleItinerarios();

            ViewBag.RepartidoresListItems = repartidores.ToList();
            ViewBag.ZonasListItems        = zonas.ToList();



            if (id == 0)
            {
                return(View(new Itinerario()));
            }
            else
            {
                Itinerario itinerario = await itinerariosService.obtenerItinerario(id);

                return(View(itinerario));
            }
        }
Beispiel #11
0
 /// <summary>
 /// Metodo encargado de actualizar los datos de un itinerario
 /// </summary>
 /// <param name="objeto">Metodo que contiene el id del itinerario y los datos nuevos</param>
 public override void Actualizar(Entidad objeto)
 {
     try
     {
         Itinerario itinerario = (Itinerario)objeto;
         base.Conectar();
         comando             = new NpgsqlCommand("mod_itinerario", base.SqlConexion);
         comando.CommandType = CommandType.StoredProcedure;
         comando.Parameters.AddWithValue(NpgsqlTypes.NpgsqlDbType.Integer, itinerario.Id);
         comando.Parameters.AddWithValue(NpgsqlTypes.NpgsqlDbType.Varchar, itinerario.Nombre);
         comando.Parameters.AddWithValue(NpgsqlTypes.NpgsqlDbType.Date, itinerario.FechaInicio);
         comando.Parameters.AddWithValue(NpgsqlTypes.NpgsqlDbType.Date, itinerario.FechaFin);
         comando.Parameters.AddWithValue(NpgsqlTypes.NpgsqlDbType.Integer, itinerario.IdUsuario);
         respuesta = comando.ExecuteReader();
         respuesta.Read();
         base.Desconectar();
     }
     catch (NpgsqlException e)
     {
         base.Desconectar();
         throw e;
     }
     catch (InvalidCastException e)
     {
         base.Desconectar();
         throw e;
     }
     catch (Exception e)
     {
         base.Desconectar();
         throw e;
     }
 }
        private void agregarAsignacionRecorrido(Itinerario itinerario)
        {
            objControladorItinerario = new ControladorItinerario();
            List <Itinerario> itinerariosRegistrados = objControladorItinerario.traerItinerario();

            Boolean validarDiaChofer  = objControladorItinerario.validarDiadelViajeChofer(itinerariosRegistrados, itinerario);
            Boolean validarDiaOmnibus = objControladorItinerario.validarDiadeReservaOmnibus(itinerariosRegistrados, itinerario);

            if (validarDiaChofer == true && validarDiaOmnibus == true)
            {
                objControladorItinerario.agregarItinerario(itinerario);
                Console.WriteLine("La Asignacion del Recorrido fue Dado de Alta Correctamente.");
            }
            else if (validarDiaChofer == false && validarDiaOmnibus == true)
            {
                Console.WriteLine("El Chofer ya Realiza un Viaje ese Dia.");
            }
            else if (validarDiaChofer == true && validarDiaOmnibus == false)
            {
                Console.WriteLine("El Omnibus ya esta Reservado ese Dia.");
            }
            else
            {
                Console.WriteLine("El Chofer y el Omnibus no estan Disponible para ese Dia.");
            }

            presioneTeclaParaContinuar();
        }
Beispiel #13
0
 private void GerarEntregasNoItinerario(List <EntregaCommand> entregas, Itinerario itinerario)
 {
     foreach (var item in entregas)
     {
         itinerario.AdicionarEntrega(item.Destinatario.Nome, item.Destinatario.Endereco, DateTime.Now);
     }
 }
Beispiel #14
0
        public Itinerario UpdateItinerario(Itinerario entity, Itinerario toUpd)
        {
            var itinerario = _itinerarioDbAccess.Update(entity, toUpd);

            _context.Commit();
            return(itinerario);
        }
        public async Task <IActionResult> Edit(DateTime id, [Bind("HuespedId,FechaRecogida,CantidasDeDias,Jefe,Recorrido,Resumen")] Itinerario itinerario)
        {
            if (id != itinerario.FechaRecogida)
            {
                return(NotFound());
            }

            if (ModelState.IsValid)
            {
                try
                {
                    _context.Update(itinerario);
                    await _context.SaveChangesAsync();
                }
                catch (DbUpdateConcurrencyException)
                {
                    if (!ItinerarioExists(itinerario.FechaRecogida))
                    {
                        return(NotFound());
                    }
                    else
                    {
                        throw;
                    }
                }
                return(RedirectToAction(nameof(Index)));
            }
            ViewData["HuespedId"] = new SelectList(_context.Huesped, "HuespedId", "Nombre", itinerario.HuespedId);
            return(View(itinerario));
        }
Beispiel #16
0
        public List <Itinerario> traerItinerario()
        {
            SqlConnection     objConexion         = new SqlConnection(ConexionSQLServer.getConexion());
            DataTable         objTablaDatos       = new DataTable();
            List <Itinerario> recorridosAsignados = new List <Itinerario>();

            SqlCommand objComando = new SqlCommand();

            objComando.Connection  = objConexion;
            objComando.CommandText = "SELECT * FROM ITINERARIO";
            objComando.CommandType = CommandType.Text;

            objConexion.Open();
            SqlDataReader objReader = objComando.ExecuteReader();

            objTablaDatos.Load(objReader);
            objConexion.Close();

            foreach (DataRow recorridoAsignado in objTablaDatos.Rows)
            {
                Itinerario objRecorridoAsignado = new Itinerario();
                objRecorridoAsignado.IdItinerario = Convert.ToInt32(recorridoAsignado["ID"]);
                objRecorridoAsignado.IdChofer     = Convert.ToInt32(recorridoAsignado["ID_CHOFER"]);
                objRecorridoAsignado.IdOmnibus    = Convert.ToInt32(recorridoAsignado["ID_OMNIBUS"]);
                objRecorridoAsignado.IdRecorrido  = Convert.ToInt32(recorridoAsignado["ID_RECORRIDO"]);
                objRecorridoAsignado.IdDia        = Convert.ToInt32(recorridoAsignado["ID_DIA"]);

                recorridosAsignados.Add(objRecorridoAsignado);
            }
            return(recorridosAsignados);
        }
        public ActionResult RegistrarItinerario(HttpPostedFileBase fileUpload, HttpPostedFileBase fileUpload2, HttpPostedFileBase fileUpload3, string dia, string desayuno, string almuerzo, string cena)
        {
            try
            {
                string path = Server.MapPath("~/Content/img/");
                if (!Directory.Exists(path))
                {
                    Directory.CreateDirectory(path);
                }
                fileUpload.SaveAs(path + Path.GetFileName(fileUpload.FileName));
                fileUpload2.SaveAs(path + Path.GetFileName(fileUpload2.FileName));
                fileUpload3.SaveAs(path + Path.GetFileName(fileUpload3.FileName));
                ENTIDAD.Itinerario galeria = new Itinerario();

                galeria.dia            = dia;
                galeria.desayuno       = desayuno;
                galeria.almuerzo       = almuerzo;
                galeria.cena           = cena;
                galeria.imgUrlDesayuno = "\\Content\\img\\" + fileUpload.FileName;
                galeria.imgUrlAlmuerzo = "\\Content\\img\\" + fileUpload2.FileName;
                galeria.imgUrlCena     = "\\Content\\img\\" + fileUpload3.FileName;
                itinerario.registrarItinerario(galeria);
                return(View("ItinerarioAdm", itinerario.listadoItinerario2()));
            }
            catch (Exception e)
            {
                return(Json(new { Value = false, Message = "Error" + e.Message }, JsonRequestBehavior.AllowGet));
            }
        }
Beispiel #18
0
 /// <summary>
 /// Elimina el itinerario con el id
 /// </summary>
 /// <param name="objeto">objeto con el id del itinerario</param>
 public override void Eliminar(Entidad objeto)
 {
     try
     {
         Itinerario itinerario = (Itinerario)objeto;
         base.Conectar();
         comando             = new NpgsqlCommand("del_itinerario", base.SqlConexion);
         comando.CommandType = CommandType.StoredProcedure;
         comando.Parameters.AddWithValue(NpgsqlTypes.NpgsqlDbType.Integer, itinerario.Id);
         respuesta = comando.ExecuteReader();
         respuesta.Read();
         Boolean resp = respuesta.GetBoolean(0);
         base.Desconectar();
         //return resp;
     }
     catch (NpgsqlException e)
     {
         base.Desconectar();
         throw e;
     }
     catch (Exception e)
     {
         base.Desconectar();
         throw e;
     }
 }
Beispiel #19
0
 public Itinerario AgregarItinerario(Itinerario it)
 {
     try
     {
         comando = FabricaComando.CrearComandoAgregarItinerario(it.IdUsuario, it.Nombre);
         comando.Ejecutar();
         Itinerario itNew = (Itinerario)comando.Retornar();
         return(itNew);
     }
     catch (NpgsqlException e)
     {
         throw new HttpResponseException(HttpStatusCode.InternalServerError);
     }
     catch (InvalidCastException)
     {
         throw new HttpResponseException(HttpStatusCode.BadRequest);
     }
     catch (NullReferenceException)
     {
         throw new HttpResponseException(HttpStatusCode.BadRequest);
     }
     catch (Exception)
     {
         throw new HttpResponseException(HttpStatusCode.Ambiguous);
     }
 }
        public ActionResult CargarIti(Itinerario itiner)
        {
            if (Session["listitinerarios"] != null)
            {
                listitinerarios = (List <Itinerario>)Session["listitinerarios"];
            }
            else
            {
                listitinerarios = new List <Itinerario>();
            }

            Itinerario itiadd = new Itinerario();

            // iter.itinerarios= new List<Itinerario>();
            itiadd = new Itinerario {
                origen = itiner.origen, destino = itiner.destino, fechaServicio = itiner.fechaServicio, horaSalida = itiner.horaSalida, tipoAccion = itiner.tipoAccion, cantidad = itiner.cantidad
            };

            listitinerarios.Add(itiadd);
            //return RedirectToAction("Index", "SolicitudProgramacion");
            ViewData["listitinerarios"] = listitinerarios;

            Session["listitinerarios"] = listitinerarios;
            // if (Request.IsAjaxRequest())
            return(PartialView());
            // else return View();
        }
        public void QuandoCrioUmProcessoDeCotacaoDeFreteAsPropriedadesFicamCorretas()
        {
            Produto         produto             = DefaultObjects.ObtemProdutoPadrao();
            UnidadeDeMedida unidadeDeMedida     = DefaultObjects.ObtemUnidadeDeMedidaPadrao();
            Itinerario      itinerario          = DefaultObjects.ObtemItinerarioPadrao();
            var             dataLimiteDeRetorno = DateTime.Today.AddDays(10);
            var             dataValidadeInicial = DateTime.Today.AddMonths(1);
            var             dataValidadeFinal   = DateTime.Today.AddMonths(2);
            var             processo            = new ProcessoDeCotacaoDeFrete("Requisitos do Processo de Cotação de Fretes",
                                                                               "10001", dataLimiteDeRetorno, dataValidadeInicial, dataValidadeFinal, itinerario);

            processo.AdicionarItem(produto, 100, unidadeDeMedida);

            var item = processo.Itens.First();

            //Assert.AreSame(produto, processo.Produto);
            //Assert.AreEqual(100, processo.Quantidade);
            //Assert.AreSame(unidadeDeMedida, processo.UnidadeDeMedida);
            Assert.AreSame(produto, item.Produto);
            Assert.AreEqual(100, item.Quantidade);
            Assert.AreSame(unidadeDeMedida, item.UnidadeDeMedida);

            Assert.AreEqual("Requisitos do Processo de Cotação de Fretes", processo.Requisitos);
            Assert.AreEqual("10001", processo.NumeroDoContrato);
            Assert.AreEqual(dataLimiteDeRetorno, processo.DataLimiteDeRetorno);
            Assert.AreEqual(dataValidadeInicial, processo.DataDeValidadeInicial);
            Assert.AreEqual(dataValidadeFinal, processo.DataDeValidadeFinal);
            Assert.AreSame(itinerario, processo.Itinerario);
        }
        public async Task <IActionResult> Edit(int id, [Bind("Id,Codigo,Duracion,Visitantes,Longitud")] Itinerario itinerario)
        {
            if (id != itinerario.Id)
            {
                return(NotFound());
            }

            if (ModelState.IsValid)
            {
                try
                {
                    _context.Update(itinerario);
                    await _context.SaveChangesAsync();
                }
                catch (DbUpdateConcurrencyException)
                {
                    if (!ItinerarioExists(itinerario.Id))
                    {
                        return(NotFound());
                    }
                    else
                    {
                        throw;
                    }
                }
                return(RedirectToAction(nameof(Index)));
            }
            return(View(itinerario));
        }
        private void cmd_Buscar_Click(object sender, EventArgs e)
        {
            List <Escala> escalas = new List <Escala>();

            if (this.cmb_itinerarios.SelectedIndex != -1 && !this.chk_todos.Checked)
            {
                List <Itinerario> itinerarios = new List <Itinerario>();
                int        id         = Convert.ToInt32(this.cmb_itinerarios.SelectedValue);
                Itinerario itinerario = itinerarioService.GetById(id);
                escalas = escalaService.getAllEscalasDeUnItinerario(id);
                itinerarios.Add(itinerario);
                cargar_grillaItinerarios(itinerarios);
                cargar_grillaEscalas(escalas);
            }
            else
            {
                if (this.chk_todos.Checked)
                {
                    int id = Convert.ToInt32(this.cmb_itinerarios.SelectedValue);
                    List <Itinerario> itinerariosList = itinerarioService.GetAll();
                    cargar_grillaItinerarios(itinerariosList);
                }
                else
                {
                    MessageBox.Show("No ha ingresado ningún dato para realizar la búsqueda", "Mensaje", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
                }
            }
        }
Beispiel #24
0
        /// <summary>
        /// Metodo utilizados para casos borde(excepciones) de AgregarItinerario
        /// </summary>
        public void Excepcion_Agregar2()
        {
            itinerario = new Itinerario("Michel", 0);
            Comando comando = FabricaComando.CrearComandoAgregarItinerario(itinerario.Id, itinerario.Nombre);

            comando.Ejecutar();
        }
Beispiel #25
0
        public Itinerario mapeoItinerario(DataRow row)
        {
            Itinerario oItinerario = new Itinerario();

            oItinerario.Codigo      = Convert.ToInt32(row["cod_intinerarios"].ToString());
            oItinerario.Descripcion = row["descripcion"].ToString();
            return(oItinerario);
        }
Beispiel #26
0
        public Boolean SetVisible(int idusuario, int iditinerario, Boolean visible)
        {
            comando = FabricaComando.CrearComandoSetVisibleItinerario(visible, idusuario, iditinerario);
            comando.Ejecutar();
            Itinerario itinerario = (Itinerario)comando.Retornar();

            return(itinerario.Visible);
        }
Beispiel #27
0
        internal Itinerario GenerarNuevoItinerarioConCambios(int semilla)
        {
            Itinerario clonadoBase = ItinerarioBase.Clonar(semilla);

            clonadoBase.AplicarCambiosEnTiemposProgramados(_tramos_por_avion);

            return(clonadoBase);
        }
Beispiel #28
0
 public ComandoSetVisibleItinerario(int idItinerario, int idUsuario,
                                    Boolean visible)
 {
     itinerario           = FabricaEntidad.CrearEntidadItinerario();
     itinerario.Id        = idItinerario;
     itinerario.IdUsuario = idUsuario;
     this.visible         = visible;
 }
Beispiel #29
0
 /// <summary>
 /// Constructor de objeto controlador de información
 /// </summary>
 /// <param name="itin"> Itinerario analizado</param>
 /// <param name="parametros">Objeto de parámetros de la simulación</param>
 /// <param name="disrupciones">Objeto de modelo de disrupciones</param>
 public ControladorInformacion(Itinerario itin, ParametrosSimuLAN parametros, ModeloDisrupciones disrupciones)
 {
     this._itinerario          = itin;
     this._parametros          = parametros;
     this._modelo_disrupciones = disrupciones;
     this._faltas = new Dictionary <TipoFaltaInformacion, List <Falta> >();
     CargarTiposFalta();
 }
Beispiel #30
0
 /// <summary>
 /// Constructr de la clase
 /// </summary>
 /// <param name="idUsuario">id del usuario</param>
 /// <param name="nombreItinerario">Nombre del nuevo itinerario</param>
 public ComandoAgregarItinerario(int idUsuario, string nombreItinerario)
 {
     itinerario           = FabricaEntidad.CrearEntidadItinerario();
     usuario              = FabricaEntidad.CrearEntidadUsuario();
     usuario.Id           = idUsuario;
     itinerario.Nombre    = nombreItinerario;
     itinerario.IdUsuario = idUsuario;
 }