/// <summary>
        /// Método que corresponde al patrón Chain of Responsibility.
        /// En caso de que el precio minimo correspondiente al perfil que envía el mensaje
        /// esté fijado en el valor inicial de -1, se pide un valor de Precio Minimo,
        /// y se agrega el ID a la lista de UsuariosPreguntados.
        ///
        /// En caso de que el Perfil correspondiente tenga el valor inicial de Precio Minimo,
        /// y esté en la lista de preguntados, se procesa el valor ingresado en el
        /// último mensaje para validarlo.
        /// De ser correcto, se modifica el campo Precio Minimo de Perfil y se pasa al siguiente eslabón.
        /// De no ser correcto, se pide al usuario que ingrese un valor adecuado.
        ///
        ///
        /// Si al ingresar al método, el valor de Precio minimo no es el inicial, se asume que ya fue fijado por el usuario,
        /// por lo que se envía el mensaje hacia el siguiente eslabón.
        /// </summary>
        /// <param name="m">Mensaje que se transmite por patrón COR</param>
        public override async void Handle(Mensaje m)
        {
            Perfil perfil = BibliotecaPerfiles.GetUsuario(m.Id);

            if (perfil.PrecioMin == -1)
            {
                if (!perfil.RegistroPreguntas.PrecioMin)
                {
                    perfil.RegistroPreguntas.PrecioMin = true;
                    await Preguntar(m.Id, m.Plataforma);
                }
                else
                {
                    /// <summary>
                    /// Intento parsear el contenido del mensaje a un numero entero, si lo consigue pasa al siguiente eslabón.
                    /// </summary>

                    try
                    {
                        int precioMin = Int32.Parse(m.Contenido);
                        EditorPerfil.SetPrecioMin(m.Id, precioMin);
                        //Si está todo OK, paso al siguiente eslabón
                        Siguiente.Handle(m);
                    }
                    /// <summary>
                    /// Si el parseo falla, por ejemplo si recibo una letra, captura la excepción y envia un mensaje al usuario
                    /// pidiendo que ingrese un valor valido de edad
                    /// </summary>
                    catch (FormatException)
                    {
                        await Respuesta.PedirAclaracion(m.Id, m.Plataforma);
                        await Preguntar(m.Id, m.Plataforma);
                    }
                    catch (NullReferenceException)
                    {
                        await Respuesta.PedirAclaracion(m.Id, m.Plataforma);
                        await Preguntar(m.Id, m.Plataforma);
                    }
                    catch (ArgumentOutOfRangeException)
                    {
                        await Respuesta.ErrorPrecioMin(m.Id, m.Plataforma);
                        await Preguntar(m.Id, m.Plataforma);
                    }
                    catch (ArgumentNullException)
                    {
                        await Respuesta.PedirAclaracion(m.Id, m.Plataforma);
                        await Preguntar(m.Id, m.Plataforma);
                    }
                }
            }

            else
            {
                Siguiente.Handle(m);
            }
        }
Example #2
0
        /// <summary>
        /// Método que corresponde al patrón Chain of Responsibility.
        /// En caso de que el género correspondiente al Perfil que envía el mensaje
        /// esté fijado en el valor inicial de null, se pide un género,
        /// y se agrega el ID a la lista de UsuariosPreguntados.
        ///
        /// En caso de que el Perfil correspondiente tenga el valor nulo de Género,
        /// y esté en la lista de preguntados, se procesa el valor ingresado en el
        /// último mensaje para validarlo.
        /// De ser correcto, se modifica el campo Genero de Perfil y se pasa al siguiente eslabón.
        /// De no ser correcto, se pide al usuario que ingrese un valor adecuado.
        ///
        ///
        /// Si al ingresar al método, el valor de Genero no es el nulo, se asume que ya fue fijado por el usuario,
        /// por lo que se envía el mensaje hacia el siguiente eslabón.
        /// </summary>
        /// <param name="m">Mensaje que se transmite por patrón COR</param>
        public override async void Handle(Mensaje m)
        {
            Perfil perfil = BibliotecaPerfiles.GetUsuario(m.Id);

            if (perfil.Genero == TipoGenero.Vacio)
            {
                if (!perfil.RegistroPreguntas.Genero)
                {
                    perfil.RegistroPreguntas.Genero = true;
                    await Preguntar(m.Id, m.Plataforma);
                }
                else
                {
                    try
                    {
                        TipoGenero genero;
                        if (masculino.Contains(m.Contenido.ToLower()))
                        {
                            genero = TipoGenero.Masculino;
                        }
                        else if (femenino.Contains(m.Contenido.ToLower()))
                        {
                            genero = TipoGenero.Femenino;
                        }
                        else
                        {
                            genero = TipoGenero.Indefinido;
                        }

                        EditorPerfil.SetGenero(m.Id, genero);
                        Siguiente.Handle(m);
                    }
                    catch (NullReferenceException)
                    {
                        await Respuesta.PedirAclaracion(m.Id, m.Plataforma);
                        await Preguntar(m.Id, m.Plataforma);
                    }
                    catch (ArgumentNullException)
                    {
                        await Respuesta.PedirAclaracion(m.Id, m.Plataforma);
                        await Preguntar(m.Id, m.Plataforma);
                    }
                }
            }
            else
            {
                Siguiente.Handle(m);
            }
        }
Example #3
0
        /// <summary>
        /// Método que corresponde al patrón Chain of Responsibility.
        /// En caso de que el atributo Interes correspondiente al Perfil que envía el mensaje
        /// esté fijado en el valor inicial de null, se pide un interés,
        /// y se agrega el ID a la lista de UsuariosPreguntados.
        ///
        /// En caso de que el Perfil correspondiente tenga el valor nulo de Interes,
        /// y esté en la lista de preguntados, se procesa el valor ingresado en el
        /// último mensaje para validarlo.
        /// De ser correcto, se modifica el campo Interes de Perfil y se pasa al siguiente eslabón.
        /// De no ser correcto, se pide al usuario que ingrese un valor adecuado.
        ///
        ///
        /// Si al ingresar al método, el valor de Interes no es el nulo, se asume que ya fue fijado por el usuario,
        /// por lo que se envía el mensaje hacia el siguiente eslabón.
        /// </summary>
        /// <param name="m">Mensaje que se transmite por patrón COR</param>

        public override async void Handle(Mensaje m)
        {
            Perfil perfil = BibliotecaPerfiles.GetUsuario(m.Id);

            if (perfil.Interes == null)
            {
                if (!perfil.RegistroPreguntas.Interes)
                {
                    await Preguntar(m.Id, m.Plataforma);

                    perfil.RegistroPreguntas.Interes = true;
                }
                else
                {
                    try
                    {
                        EditorPerfil.SetInteres(m.Id, m.Contenido);
                        Siguiente.Handle(m);
                    }
                    catch (NullReferenceException)
                    {
                        await Respuesta.PedirAclaracion(m.Id, m.Plataforma);
                        await Preguntar(m.Id, m.Plataforma);
                    }
                    catch (ArgumentNullException)
                    {
                        await Respuesta.PedirAclaracion(m.Id, m.Plataforma);
                        await Preguntar(m.Id, m.Plataforma);
                    }
                }
            }
            else
            {
                Siguiente.Handle(m);
            }
        }
Example #4
0
        /// <summary>
        /// Método que corresponde al patrón Chain of Responsibility.
        /// En caso de que el atributo Relacion correspondiente al Perfil que envía el mensaje
        /// esté fijado en el valor inicial de null, se pide una relación,
        /// y se agrega el ID a la lista de UsuariosPreguntados.
        ///
        /// En caso de que el Perfil correspondiente tenga el valor nulo de Relación,
        /// y esté en la lista de preguntados, se procesa el valor ingresado en el
        /// último mensaje para validarlo.
        /// De ser correcto, se modifica el campo Relacion de Perfil y se pasa al siguiente eslabón.
        /// De no ser correcto, se pide al usuario que ingrese un valor adecuado.
        ///
        ///
        /// Si al ingresar al método, el valor de Relacion no es el nulo, se asume que ya fue fijado por el usuario,
        /// por lo que se envía el mensaje hacia el siguiente eslabón.
        /// </summary>
        /// <param name="m">Mensaje que se transmite por patrón COR</param>
        public override async void Handle(Mensaje m)
        {
            Perfil perfil = BibliotecaPerfiles.GetUsuario(m.Id);

            if (perfil.Relacion == TipoAfinidad.Vacio)
            {
                if (!perfil.RegistroPreguntas.Relacion)
                {
                    perfil.RegistroPreguntas.Relacion = true;
                    await Preguntar(m.Id, m.Plataforma);
                }
                else
                {
                    try
                    {
                        TipoAfinidad afinidad = BuscoAfinidad(m.Contenido);
                        EditorPerfil.SetRelacion(m.Id, afinidad);
                        Siguiente.Handle(m);
                    }
                    catch (ArgumentException)
                    {
                        await Respuesta.PedirAclaracion(m.Id, m.Plataforma);
                        await Preguntar(m.Id, m.Plataforma);
                    }
                    catch (NullReferenceException)
                    {
                        await Respuesta.PedirAclaracion(m.Id, m.Plataforma);
                        await Preguntar(m.Id, m.Plataforma);
                    }
                }
            }
            else
            {
                Siguiente.Handle(m);
            }
        }