private void btnConectarCliente_Click(object sender, EventArgs e)
        {
            try
            {
                serverEndPoint = new IPEndPoint(ipServidor, intPort);
                cliente        = new TcpClient();
                cliente.Connect(serverEndPoint);

                MensajeSocket <string> mensajeConectar = new MensajeSocket <string> {
                    Mensaje = "Conectar", Valor = Convert.ToString(cliente.GetHashCode())
                };

                clienteStreamReader = new StreamReader(cliente.GetStream());
                clienteStreamWriter = new StreamWriter(cliente.GetStream());
                clienteStreamWriter.WriteLine(JsonConvert.SerializeObject(mensajeConectar));
                clienteStreamWriter.Flush();
                string mensaje = clienteStreamReader.ReadLine();
                MensajeSocket <bool> resultado;
                resultado = JsonConvert.DeserializeObject <MensajeSocket <bool> >(mensaje);
                modificartxtStatus(resultado.Mensaje);

                clienteConectado             = true;
                btnConectarCliente.Enabled   = false;
                btnIngresar.Enabled          = true;
                linkRegistrarse.Enabled      = true;
                btnRegistroConductor.Enabled = true;
            }
            catch (Exception ex)
            {
                modificartxtStatus("Problemas conectando el servidor.");
                modificartxtStatus(ex.ToString());
            }
        }
        private void btnSalir_Click(object sender, EventArgs e)
        {
            try
            {
                if (cliente != null)
                {
                    MensajeSocket <int> mensajeIngresar = new MensajeSocket <int> {
                        Mensaje = "Desconectar", Valor = cliente.GetHashCode()
                    };

                    clienteStreamReader = new StreamReader(cliente.GetStream());
                    clienteStreamWriter = new StreamWriter(cliente.GetStream());
                    clienteStreamWriter.WriteLine(JsonConvert.SerializeObject(mensajeIngresar));
                    clienteStreamWriter.Flush();
                    cliente.Close();
                }

                this.Close();
            }
            catch (Exception ex)
            {
                modificartxtStatus("Problema al salir.");
                modificartxtStatus(ex.ToString());
            }
        }
 private void CargarViajeActivo(Conductor conductor)
 {
     try
     {
         MensajeSocket <Conductor> mensajeViajeActivo = new MensajeSocket <Conductor> {
             Mensaje = "Viaje Activo", Valor = conductor
         };
         clienteStreamReader = new StreamReader(cliente.GetStream());
         clienteStreamWriter = new StreamWriter(cliente.GetStream());
         clienteStreamWriter.WriteLine(JsonConvert.SerializeObject(mensajeViajeActivo));
         clienteStreamWriter.Flush();
         string mensajeActivo = clienteStreamReader.ReadLine();
         MensajeSocket <Viaje> resultadoViajeActivo;
         resultadoViajeActivo = JsonConvert.DeserializeObject <MensajeSocket <Viaje> >(mensajeActivo);
         if (resultadoViajeActivo.Valor != null)
         {
             tabViajes.Parent   = tabMain;
             tabIngreso.Parent  = tabTrash;
             lblGUIDActivo.Text = resultadoViajeActivo.Valor.Id_viaje;
         }
         else
         {
             tabIngresoViajes.Parent = tabMain;
             tabIngreso.Parent       = tabTrash;
         }
     }
     catch (Exception ex)
     {
         modificartxtStatus("Problema cargar viaje activo.");
         modificartxtStatus(ex.ToString());
     }
 }
        public static void Desconectar(string pIdentificadorCliente)
        {
            MensajeSocket <string> mensajeDesconectar = new MensajeSocket <string> {
                Metodo = "Desconectar", Entidad = pIdentificadorCliente
            };

            clienteStreamWriter.WriteLine(JsonConvert.SerializeObject(mensajeDesconectar));
            clienteStreamWriter.Flush();
            //Se cierra la conexión del cliente
            cliente.Close();
        }
        private void btnIngresar_Click(object sender, EventArgs e)
        {
            try
            {
                if (cliente.Connected)
                {
                    Conductor conductor = new Conductor("", "", "", "", "", txtUsuario.Text, "", "", "", "");
                    MensajeSocket <Conductor> mensajeIngresar = new MensajeSocket <Conductor> {
                        Mensaje = "Login Conductor", Valor = conductor
                    };

                    clienteStreamReader = new StreamReader(cliente.GetStream());
                    clienteStreamWriter = new StreamWriter(cliente.GetStream());
                    clienteStreamWriter.WriteLine(JsonConvert.SerializeObject(mensajeIngresar));
                    clienteStreamWriter.Flush();
                    string mensaje = clienteStreamReader.ReadLine();
                    MensajeSocket <bool> resultado;
                    resultado = JsonConvert.DeserializeObject <MensajeSocket <bool> >(mensaje);

                    if (resultado.Valor)
                    {
                        modificartxtStatus("Ingreso de Conductor: " + txtUsuario.Text);

                        CargarViajeActivo(conductor);
                    }
                    else
                    {
                        modificartxtStatus("Ingreso de Conductor: " + txtUsuario.Text);
                        modificartxtStatus(resultado.Mensaje);
                    }
                }
            }
            catch (IOException iex) {
                modificartxtStatus("Problema ingreando usuario.");
                modificartxtStatus(iex.ToString());
                clienteConectado = false;
            }
            catch (SocketException sex)
            {
                modificartxtStatus("Problema ingreando usuario.");
                modificartxtStatus(sex.ToString());
                clienteConectado = false;
            }
            catch (Exception ex)
            {
                modificartxtStatus("Problema ingreando usuario.");
                modificartxtStatus(ex.ToString());
            }
        }
        private void btnFinalizarViaje_Click(object sender, EventArgs e)
        {
            try
            {
                string idviaje = Guid.NewGuid().ToString();
                Viaje  viaje   = new Viaje(idviaje
                                           , txtUsuario.Text.Trim()
                                           , txtLugarInicio.Text.Trim()
                                           , txtLugarFinal.Text.Trim()
                                           , txtDescripcionCarga.Text.Trim()
                                           , txtTiempoEstimado.Text.Trim()
                                           , "FINALIZADO");
                MensajeSocket <Viaje> mensajeRegistroConductor = new MensajeSocket <Viaje> {
                    Mensaje = "Finalizar Viaje", Valor = viaje
                };

                clienteStreamReader = new StreamReader(cliente.GetStream());
                clienteStreamWriter = new StreamWriter(cliente.GetStream());
                clienteStreamWriter.WriteLine(JsonConvert.SerializeObject(mensajeRegistroConductor));
                clienteStreamWriter.Flush();
                string mensaje = clienteStreamReader.ReadLine();
                MensajeSocket <bool> resultado;
                resultado = JsonConvert.DeserializeObject <MensajeSocket <bool> >(mensaje);

                if (resultado.Valor)
                {
                    lblGUIDActivo.Text = idviaje;
                    modificartxtStatus("Finalizar Viaje: " + txtIdentificacion.Text);

                    tabIngresoViajes.Parent = tabMain;
                    tabViajes.Parent        = tabTrash;
                }
                else
                {
                    modificartxtStatus("Finalizar Viaje: " + txtUsuario.Text);
                    modificartxtStatus(resultado.Mensaje);
                }
            }
            catch (SocketException sex)
            {
                modificartxtStatus("Error:");
                modificartxtStatus(sex.ToString());
            }
            catch (Exception ex)
            {
                modificartxtStatus("Error:");
                modificartxtStatus(ex.ToString());
            }
        }
        private void btnActualizarViaje_Click(object sender, EventArgs e)
        {
            try
            {
                if (!string.IsNullOrEmpty(txtNuevaUbicacion.Text.Trim()) || !string.IsNullOrWhiteSpace(txtNuevaUbicacion.Text.Trim()) ||
                    !string.IsNullOrEmpty(txtObservaciones.Text.Trim()) || !string.IsNullOrWhiteSpace(txtObservaciones.Text.Trim())
                    )
                {
                    Tracking tracking = new Tracking(lblGUIDActivo.Text.Trim(), txtNuevaUbicacion.Text.Trim(), txtObservaciones.Text.Trim());
                    MensajeSocket <Tracking> mensajeRegistroTracking = new MensajeSocket <Tracking> {
                        Mensaje = "Registro Tracking", Valor = tracking
                    };

                    clienteStreamReader = new StreamReader(cliente.GetStream());
                    clienteStreamWriter = new StreamWriter(cliente.GetStream());
                    clienteStreamWriter.WriteLine(JsonConvert.SerializeObject(mensajeRegistroTracking));
                    clienteStreamWriter.Flush();
                    string mensaje = clienteStreamReader.ReadLine();
                    MensajeSocket <bool> resultado;
                    resultado = JsonConvert.DeserializeObject <MensajeSocket <bool> >(mensaje);

                    if (resultado.Valor)
                    {
                        modificartxtStatus("Registro de Tracking: " + lblGUIDActivo.Text.Trim());
                    }
                    else
                    {
                        modificartxtStatus("Registro de Tracking: " + txtUsuario.Text);
                    }
                }
                else
                {
                    modificartxtStatus("Verifique los datos, todos los campos son obligatorios.");
                }
            }
            catch (SocketException sex)
            {
                modificartxtStatus("Error");
                modificartxtStatus(sex.ToString());
                clienteConectado = false;
            }
            catch (Exception ex)
            {
                modificartxtStatus("Error");
                modificartxtStatus(ex.ToString());
            }
        }
        private void btnEnviarMensaje_Click(object sender, EventArgs e)
        {
            try
            {
                MensajeSocket <string> mensajeNoticacion = new MensajeSocket <string> {
                    Mensaje = "Notificacion de Cliente"
                    , Valor = " Usuario: " + txtUsuario.Text + " - " + txtEnviarMensaje.Text.Trim()
                };

                clienteStreamReader = new StreamReader(cliente.GetStream());
                clienteStreamWriter = new StreamWriter(cliente.GetStream());
                clienteStreamWriter.WriteLine(JsonConvert.SerializeObject(mensajeNoticacion));
                clienteStreamWriter.Flush();
            }
            catch (Exception ex)
            {
                modificartxtStatus("Error:");
                modificartxtStatus(ex.ToString());
            }
        }
Exemple #9
0
        public void SeleccionarMetodo(string pMetodo, string pMensaje, ref StreamWriter servidorStreamWriter)
        {
            switch (pMetodo)
            {
            case "Conectar":
                MensajeSocket <string> mensajeConectar = JsonConvert.DeserializeObject <MensajeSocket <string> >(pMensaje);// Se deserializa el objeto recibido mediante json
                Conectar(mensajeConectar.Entidad);
                break;

            case "CalcularPago":
                // MensajeSocket<Autor> mensajeCalcularPago = JsonConvert.DeserializeObject<MensajeSocket<Cliente>>(pMensaje);// Se deserializa el objeto recibido mediante json
                // CalcularPago(mensajeFrmMontoCancelar.Entidad);
                break;

            case "Desconectar":
                MensajeSocket <string> mensajeDesconectar = JsonConvert.DeserializeObject <MensajeSocket <string> >(pMensaje);//Se deserializa el objeto recibido mediante json
                Desconectar(mensajeDesconectar.Entidad);
                break;

            default:
                break;
            }
        }
        /// <summary>
        /// Conecta el cliente tcp con el servidor
        /// </summary>
        /// <param name="pIdentificadorCliente">Identificador o nombre del cliente</param>
        /// <returns>Retorna true si se conecta con el servidor</returns>
        ///
        public static bool Conectar(string pIdentificadorCliente)
        {
            try
            {
                ipServidor     = IPAddress.Parse("127.0.0.1");
                cliente        = new TcpClient();
                serverEndPoint = new IPEndPoint(ipServidor, 30000);
                cliente.Connect(serverEndPoint);
                MensajeSocket <string> mensajeConectar = new MensajeSocket <string> {
                    Metodo = "Conectar", Entidad = pIdentificadorCliente
                };

                clienteStreamReader = new StreamReader(cliente.GetStream());
                clienteStreamWriter = new StreamWriter(cliente.GetStream());
                clienteStreamWriter.WriteLine(JsonConvert.SerializeObject(mensajeConectar));
                clienteStreamWriter.Flush();
            }
            catch (SocketException)
            {
                return(false);
            }

            return(true);
        }
Exemple #11
0
        private void ComunicacionCliente(object cliente)
        {
            TcpClient    tcCliente            = (TcpClient)cliente;
            StreamReader reader               = new StreamReader(tcCliente.GetStream());
            StreamWriter servidorStreamWriter = new StreamWriter(tcCliente.GetStream());//El StreamWriter debe ser único por subproceso y por cliente por eso se pasa por referencia

            while (servidorIniciado)
            {
                try
                {
                    /*Esta sección se bloquea hasta que el cliente envíe unmensaje*/
                    var mensaje = reader.ReadLine();
                    MensajeSocket <object> mensajeRecibido = JsonConvert.DeserializeObject <MensajeSocket <object> >(mensaje);//Se deserializa el objeto recibido mediante json
                    SeleccionarMetodo(mensajeRecibido.Metodo, mensaje, ref servidorStreamWriter);
                }
                catch (Exception)
                {
                    //Ocurrió un error en el socket
                    break;
                }
            }

            tcCliente.Close();
        }
        private void btnIngresoViaje_Click(object sender, EventArgs e)
        {
            try
            {
                if (!string.IsNullOrEmpty(txtLugarInicio.Text.Trim()) || !string.IsNullOrWhiteSpace(txtLugarInicio.Text.Trim()) ||
                    !string.IsNullOrEmpty(txtLugarFinal.Text.Trim()) || !string.IsNullOrWhiteSpace(txtLugarFinal.Text.Trim()) ||
                    !string.IsNullOrEmpty(txtDescripcionCarga.Text.Trim()) || !string.IsNullOrWhiteSpace(txtDescripcionCarga.Text.Trim()) ||
                    !string.IsNullOrEmpty(txtTiempoEstimado.Text.Trim()) || !string.IsNullOrWhiteSpace(txtTiempoEstimado.Text.Trim())
                    )
                {
                    string idviaje = Guid.NewGuid().ToString();
                    Viaje  viaje   = new Viaje(idviaje
                                               , txtIdentificacion.Text.Trim()
                                               , txtLugarInicio.Text.Trim()
                                               , txtLugarFinal.Text.Trim()
                                               , txtDescripcionCarga.Text.Trim()
                                               , txtTiempoEstimado.Text.Trim()
                                               , "ACTIVO");
                    MensajeSocket <Viaje> mensajeRegistroConductor = new MensajeSocket <Viaje> {
                        Mensaje = "Registro Viaje", Valor = viaje
                    };

                    clienteStreamReader = new StreamReader(cliente.GetStream());
                    clienteStreamWriter = new StreamWriter(cliente.GetStream());
                    clienteStreamWriter.WriteLine(JsonConvert.SerializeObject(mensajeRegistroConductor));
                    clienteStreamWriter.Flush();
                    string mensaje = clienteStreamReader.ReadLine();
                    MensajeSocket <bool> resultado;
                    resultado = JsonConvert.DeserializeObject <MensajeSocket <bool> >(mensaje);

                    if (resultado.Valor)
                    {
                        //lblGUIDActivo.Invoke(new MethodInvoker(delegate {lblGUIDActivo.Text = idviaje;}));
                        lblGUIDActivo.Text = idviaje;

                        modificartxtStatus("Registro de Viaje: " + txtIdentificacion.Text);

                        tabViajes.Parent        = tabMain;
                        tabIngresoViajes.Parent = tabTrash;
                    }
                    else
                    {
                        modificartxtStatus("Registro de Conductor: " + txtUsuario.Text);
                    }
                }
                else
                {
                    modificartxtStatus("Verifique los datos, todos los campos son obligatorios.");
                }
            }
            catch (SocketException sex)
            {
                modificartxtStatus("Error: ");
                modificartxtStatus(sex.ToString());
                clienteConectado = false;
            }
            catch (Exception ex)
            {
                modificartxtStatus("Error: ");
                modificartxtStatus(ex.ToString());
            }
        }
        private void btnRegistroConductor_Click(object sender, EventArgs e)
        {
            try
            {
                if (!string.IsNullOrEmpty(txtIdentificacion.Text.Trim()) || !string.IsNullOrWhiteSpace(txtIdentificacion.Text.Trim()) ||
                    !string.IsNullOrEmpty(txtNombre.Text.Trim()) || !string.IsNullOrWhiteSpace(txtNombre.Text.Trim()) ||
                    !string.IsNullOrEmpty(txtPApellido.Text.Trim()) || !string.IsNullOrWhiteSpace(txtPApellido.Text.Trim()) ||
                    !string.IsNullOrEmpty(txtSApellido.Text.Trim()) || !string.IsNullOrWhiteSpace(txtSApellido.Text.Trim()) ||
                    !string.IsNullOrEmpty(txtUserName.Text.Trim()) || !string.IsNullOrWhiteSpace(txtUserName.Text.Trim()) ||
                    !string.IsNullOrEmpty(txtPlaca.Text.Trim()) || !string.IsNullOrWhiteSpace(txtPlaca.Text.Trim()) ||
                    !string.IsNullOrEmpty(cbMarca.Text.Trim()) || !string.IsNullOrWhiteSpace(cbMarca.Text.Trim())
                    )
                {
                    Conductor conductor = new Conductor(txtIdentificacion.Text.Trim(), txtNombre.Text.Trim(), txtPApellido.Text.Trim(),
                                                        txtSApellido.Text.Trim(), "", txtUserName.Text.Trim(), "PENDIENTE",
                                                        txtPlaca.Text.Trim(), numModelo.Value.ToString(), cbMarca.Text.Trim());

                    MensajeSocket <Conductor> mensajeRegistroConductor = new MensajeSocket <Conductor> {
                        Mensaje = "Registro Conductor", Valor = conductor
                    };

                    clienteStreamReader = new StreamReader(cliente.GetStream());
                    clienteStreamWriter = new StreamWriter(cliente.GetStream());
                    clienteStreamWriter.WriteLine(JsonConvert.SerializeObject(mensajeRegistroConductor));
                    clienteStreamWriter.Flush();
                    string mensaje = clienteStreamReader.ReadLine();
                    MensajeSocket <bool> resultado;
                    resultado = JsonConvert.DeserializeObject <MensajeSocket <bool> >(mensaje);

                    if (resultado.Valor)
                    {
                        modificartxtStatus("Registro de Conductor: " + txtIdentificacion.Text);
                        modificartxtStatus("Registro de Usuario: " + txtUserName.Text);
                        modificartxtStatus("Registro de Camion: " + txtPlaca.Text);

                        tabIngreso.Parent           = tabMain;
                        tabRegistroConductor.Parent = tabTrash;
                    }
                    else
                    {
                        modificartxtStatus("Registro de Conductor: " + txtIdentificacion.Text);
                        modificartxtStatus(resultado.Mensaje);
                    }
                }
                else
                {
                    modificartxtStatus("Verifique los datos, todos los campos son obligatorios.");
                }
            }
            catch (SocketException sex)
            {
                modificartxtStatus("Problema registro de conductor.");
                modificartxtStatus(sex.ToString());
                clienteConectado = false;
            }
            catch (Exception ex)
            {
                modificartxtStatus("Problema registro del conductor.");
                modificartxtStatus(ex.ToString());
            }
        }