コード例 #1
0
ファイル: ChatHub.cs プロジェクト: SergioStiven/Sport-Project
        public async Task SendMessageToPerson(ChatsDTO chatsDestino)
        {
            try
            {
                chatsDestino.UltimoMensaje.FechaMensaje = DateTime.Now;
                chatsDestino.EsNuevoMensaje             = true;

                Clients.Group(_prefixChatGroupName + chatsDestino.CodigoPersonaNoOwner.ToString()).receiveMessage(chatsDestino);
                Clients.Group(_prefixChatGroupName + chatsDestino.CodigoPersonaOwner.ToString()).receiveMessage(chatsDestino);

                FireBasePayLoad fireBasePayLoad = new FireBasePayLoad
                {
                    priority     = "high",
                    to           = "/topics/" + chatsDestino.CodigoPersonaNoOwner.ToString(),
                    notification = new NotificationFireBaseModel
                    {
                        title             = chatsDestino.PersonasOwner.NombreYApellido,
                        body              = chatsDestino.UltimoMensaje.Mensaje,
                        sound             = "default",
                        content_available = "true"
                    }
                };

                await _httpClient.PostAsJsonAsync(UrlFCM, fireBasePayLoad);
            }
            catch (Exception)
            {
                // The error may be because the target person is not connected
            }
        }
コード例 #2
0
 public async Task EnviarMensaje(ChatsDTO chatParaEnviar)
 {
     if (_hubConnection != null && _hubConnection.State == ConnectionState.Connected)
     {
         await _policy.ExecuteAsync(async() => await _hubProxy.Invoke("SendMessageToPerson", chatParaEnviar));
     }
 }
コード例 #3
0
        public async Task <ChatsDTO> BuscarChat(Chats chatParaBuscar)
        {
            using (SportsGoEntities context = new SportsGoEntities(false))
            {
                ChatsRepository chatsRepo   = new ChatsRepository(context);
                ChatsDTO        chatBuscado = await chatsRepo.BuscarChat(chatParaBuscar);

                return(chatBuscado);
            }
        }
コード例 #4
0
        public async Task <ChatsDTO> BuscarChatEntreDosPersonas(Chats chatParaBuscar)
        {
            using (SportsGoEntities context = new SportsGoEntities(false))
            {
                ChatsRepository chatsRepo   = new ChatsRepository(context);
                ChatsDTO        chatBuscado = await chatsRepo.BuscarChatEntreDosPersonas(chatParaBuscar);

                if (chatBuscado == null)
                {
                    chatBuscado = new ChatsDTO();
                }

                return(chatBuscado);
            }
        }
コード例 #5
0
        public override async void ReverseInit(object returnedData)
        {
            base.ReverseInit(returnedData);

            ChatsDTO chatBorrado = returnedData as ChatsDTO;

            if (chatBorrado != null && _chats != null && _chats.Count > 0)
            {
                using (await _lockeable.LockAsync())
                {
                    _chats.Remove(chatBorrado);
                    RaisePropertyChanged(nameof(Chats));
                }
            }
        }
コード例 #6
0
        public async Task <List <ChatsDTO> > ListarChats(ChatsDTO chatsParaListar)
        {
            if (chatsParaListar == null)
            {
                throw new ArgumentNullException("No puedes listar los chats si chatsParaListar es nulo!.");
            }
            if (chatsParaListar.CodigoPersonaOwner <= 0 || chatsParaListar.SkipIndexBase < 0 || chatsParaListar.TakeIndexBase <= 0)
            {
                throw new ArgumentException("chatsParaListar vacio y/o invalido!.");
            }

            IHttpClient client = ConfigurarHttpClient();

            List <ChatsDTO> listaChats = await client.PostAsync <ChatsDTO, List <ChatsDTO> >("Chats/ListarChats", chatsParaListar);

            return(listaChats);
        }
コード例 #7
0
        public async Task <ChatsDTO> BuscarChat(ChatsDTO chatParaBuscar)
        {
            if (chatParaBuscar == null)
            {
                throw new ArgumentNullException("No puedes buscar un chat si chatParaBuscar es nulo!.");
            }
            if (chatParaBuscar.Consecutivo <= 0)
            {
                throw new ArgumentException("chatParaBuscar vacio y/o invalido!.");
            }

            IHttpClient client = ConfigurarHttpClient();

            ChatsDTO chatBuscado = await client.PostAsync("Chats/BuscarChat", chatParaBuscar);

            return(chatBuscado);
        }
コード例 #8
0
        public async Task <ChatsDTO> BuscarChatEntreDosPersonas(ChatsDTO chatParaBuscar)
        {
            if (chatParaBuscar == null)
            {
                throw new ArgumentNullException("No puedes buscar un chat si chatParaBuscar es nulo!.");
            }
            if (chatParaBuscar.CodigoPersonaOwner <= 0 || chatParaBuscar.CodigoPersonaNoOwner <= 0)
            {
                throw new ArgumentException("chatParaBuscar vacio y/o invalido!.");
            }

            IHttpClient client = ConfigurarHttpClient();

            ChatsDTO chatBuscado = await client.PostAsync("Chats/BuscarChatEntreDosPersonas", chatParaBuscar);

            return(chatBuscado);
        }
コード例 #9
0
        public async Task <WrapperSimpleTypesDTO> CrearChat(ChatsDTO chatParaCrear)
        {
            if (chatParaCrear == null)
            {
                throw new ArgumentNullException("No puedes crear un chat si chatParaCrear es nula!.");
            }
            if (chatParaCrear.CodigoPersonaOwner <= 0 || chatParaCrear.CodigoPersonaNoOwner <= 0)
            {
                throw new ArgumentException("chatParaCrear vacia y/o invalida!.");
            }

            IHttpClient client = ConfigurarHttpClient();

            WrapperSimpleTypesDTO wrapperCrearChat = await client.PostAsync <ChatsDTO, WrapperSimpleTypesDTO>("Chats/CrearChat", chatParaCrear);

            return(wrapperCrearChat);
        }
コード例 #10
0
        public async Task <WrapperSimpleTypesDTO> EliminarChat(ChatsDTO chatParaEliminar)
        {
            if (chatParaEliminar == null)
            {
                throw new ArgumentNullException("No puedes eliminar un chat si chatParaEliminar es nulo!.");
            }
            if (chatParaEliminar.Consecutivo <= 0 || chatParaEliminar.CodigoChatRecibe <= 0 ||
                chatParaEliminar.CodigoPersonaOwner <= 0 || chatParaEliminar.CodigoPersonaNoOwner <= 0)
            {
                throw new ArgumentException("chatParaEliminar vacio y/o invalido!.");
            }

            IHttpClient client = ConfigurarHttpClient();

            WrapperSimpleTypesDTO wrapperEliminarChat = await client.PostAsync <ChatsDTO, WrapperSimpleTypesDTO>("Chats/EliminarChat", chatParaEliminar);

            return(wrapperEliminarChat);
        }
コード例 #11
0
        public async Task <IHttpActionResult> BuscarChatEntreDosPersonas(Chats chatParaBuscar)
        {
            if (chatParaBuscar == null || chatParaBuscar.CodigoPersonaOwner <= 0 || chatParaBuscar.CodigoPersonaNoOwner <= 0)
            {
                return(BadRequest("chatParaBuscar vacio y/o invalido!."));
            }

            try
            {
                ChatsDTO chatBuscado = await _chatBusiness.BuscarChatEntreDosPersonas(chatParaBuscar);

                return(Ok(chatBuscado));
            }
            catch (Exception ex)
            {
                return(InternalServerError(ex));
            }
        }
コード例 #12
0
        public async Task <IHttpActionResult> BuscarChat(Chats chatParaBuscar)
        {
            if (chatParaBuscar == null || chatParaBuscar.Consecutivo <= 0)
            {
                return(BadRequest("chatParaBuscar vacio y/o invalido!."));
            }

            try
            {
                ChatsDTO chatBuscado = await _chatBusiness.BuscarChat(chatParaBuscar);

                return(Ok(chatBuscado));
            }
            catch (Exception ex)
            {
                return(InternalServerError(ex));
            }
        }
コード例 #13
0
        protected override void OnBindingContextChanged()
        {
            base.OnBindingContextChanged();
            ChatsDTO item = BindingContext as ChatsDTO;

            if (item == null)
            {
                return;
            }

            UrlImagenPerfil.Source = null;
            if (!string.IsNullOrWhiteSpace(item.PersonasNoOwner.UrlImagenPerfil))
            {
                UrlImagenPerfil.Source = item.PersonasNoOwner.UrlImagenPerfil;
            }
            else
            {
                UrlImagenPerfil.Source = App.Current.Resources["RutaDefaultImagenPerfil"] as string;
            }
        }
コード例 #14
0
        public async Task <JsonResult> DeleteConversation(ChatsDTO chat)
        {
            Result <WrapperSimpleTypesDTO> result = new Result <WrapperSimpleTypesDTO>();

            try
            {
                ChatsServices chatService = new ChatsServices();
                result.obj = await chatService.EliminarChat(chat);

                if (result.obj == null)
                {
                    return(Json(Helper.returnErrorDelete(UserLoggedIn().PersonaDelUsuario.CodigoIdioma), JsonRequestBehavior.AllowGet));
                }

                return(Json(Helper.returnDeleteSuccess(UserLoggedIn().PersonaDelUsuario.CodigoIdioma), JsonRequestBehavior.AllowGet));
            }
            catch (Exception)
            {
                return(Json(Helper.returnErrorDelete(UserLoggedIn().PersonaDelUsuario.CodigoIdioma), JsonRequestBehavior.AllowGet));
            }
        }
コード例 #15
0
        public async Task <JsonResult> SaveChat(ChatsDTO chat)
        {
            Result <WrapperSimpleTypesDTO> result = new Result <WrapperSimpleTypesDTO>();

            try
            {
                ChatsServices chatService = new ChatsServices();
                chat.CodigoPersonaOwner = UserLoggedIn().PersonaDelUsuario.Consecutivo;
                result.obj = await chatService.CrearChat(chat);

                if (result.list == null)
                {
                    return(Json(Helper.returnErrorSaveObj(UserLoggedIn().PersonaDelUsuario.CodigoIdioma), JsonRequestBehavior.AllowGet));
                }

                return(Json(result, JsonRequestBehavior.AllowGet));
            }
            catch (Exception)
            {
                return(Json(Helper.returnErrorSaveObj(UserLoggedIn().PersonaDelUsuario.CodigoIdioma), JsonRequestBehavior.AllowGet));
            }
        }
コード例 #16
0
        public async Task <JsonResult> GetAllChats(ChatsDTO chat)
        {
            Result <ChatsDTO> result = new Result <ChatsDTO>();

            try
            {
                ChatsServices chatService = new ChatsServices();
                chat.CodigoPersonaOwner = UserLoggedIn().PersonaDelUsuario.Consecutivo;
                result.list             = await chatService.ListarChats(chat);

                if (result.list == null)
                {
                    return(Json(Helper.returnErrorList(UserLoggedIn().PersonaDelUsuario.CodigoIdioma), JsonRequestBehavior.AllowGet));
                }

                return(Json(result, JsonRequestBehavior.AllowGet));
            }
            catch (Exception)
            {
                return(Json(Helper.returnErrorList(UserLoggedIn().PersonaDelUsuario.CodigoIdioma), JsonRequestBehavior.AllowGet));
            }
        }
コード例 #17
0
        public async Task <JsonResult> GetChatFromContact(ChatsDTO chat)
        {
            Result <ChatsDTO> result = new Result <ChatsDTO>();

            try
            {
                ChatsServices chatService = new ChatsServices();
                chat.CodigoPersonaOwner = UserLoggedIn().PersonaDelUsuario.Consecutivo;
                result.obj = await chatService.BuscarChatEntreDosPersonas(chat);

                if (result.obj == null)
                {
                    return(Json(Helper.returnErrorObj(UserLoggedIn().PersonaDelUsuario.CodigoIdioma), JsonRequestBehavior.AllowGet));
                }

                return(Json(result, JsonRequestBehavior.AllowGet));
            }
            catch (Exception)
            {
                return(Json(Helper.returnErrorObj(UserLoggedIn().PersonaDelUsuario.CodigoIdioma), JsonRequestBehavior.AllowGet));
            }
        }
コード例 #18
0
        public async Task <ChatsDTO> BuscarChatEntreDosPersonas(Chats chatParaBuscar)
        {
            ChatsDTO chatBuscado = await _context.Chats.Where(chat => chat.CodigoPersonaOwner == chatParaBuscar.CodigoPersonaOwner && chat.CodigoPersonaNoOwner == chatParaBuscar.CodigoPersonaNoOwner)
                                   .Select(x => new ChatsDTO
            {
                Consecutivo          = x.Consecutivo,
                Creacion             = x.Creacion,
                CodigoEstado         = x.CodigoEstado,
                CodigoPersonaOwner   = x.CodigoPersonaOwner,
                CodigoPersonaNoOwner = x.CodigoPersonaNoOwner,
                CodigoChatRecibe     = _context.Chats.Where(y => y.CodigoPersonaNoOwner == x.CodigoPersonaOwner && y.CodigoPersonaOwner == x.CodigoPersonaNoOwner).Select(z => z.Consecutivo).FirstOrDefault(),
                PersonasNoOwner      = new PersonasDTO
                {
                    Consecutivo = x.PersonasNoOwner.Consecutivo,
                    Nombres     = x.PersonasNoOwner.Nombres,
                    Apellidos   = x.PersonasNoOwner.Apellidos,
                    CodigoArchivoImagenPerfil = x.PersonasNoOwner.CodigoArchivoImagenPerfil,
                }
            })
                                   .AsNoTracking()
                                   .FirstOrDefaultAsync();

            return(chatBuscado);
        }
コード例 #19
0
        public override async void Init(object initData)
        {
            base.Init(initData);

            try
            {
                if (_chats != null && _chats.Count > 0)
                {
                    await CargarConversaciones(0, 10, true);
                }
                else
                {
                    await CargarConversaciones(0, 10);
                }

                LastRefresh = DateTime.Now;
            }
            catch (Exception)
            {
            }

            ChatsServices.MensajeRecibido += async(obj, evt) =>
            {
                if (evt.ChatRecibido != null && evt.ChatRecibido.UltimoMensaje != null && !string.IsNullOrWhiteSpace(evt.ChatRecibido.UltimoMensaje.Mensaje))
                {
                    LastRefresh = DateTime.Now;
                    int numeroMensajesNuevos = 0;

                    using (await _lockeable.LockAsync())
                    {
                        if (_chats != null && _chats.Count > 0)
                        {
                            // Elimino el chat si ya existe para que no salga repetido
                            ChatsDTO chatExistente = _chats.Where(x => (x.CodigoPersonaOwner == evt.ChatRecibido.CodigoPersonaOwner && x.CodigoPersonaNoOwner == evt.ChatRecibido.CodigoPersonaNoOwner) || (x.CodigoPersonaOwner == evt.ChatRecibido.CodigoPersonaNoOwner && x.CodigoPersonaNoOwner == evt.ChatRecibido.CodigoPersonaOwner)).FirstOrDefault();

                            if (chatExistente != null)
                            {
                                _chats.Remove(chatExistente);
                                numeroMensajesNuevos = chatExistente.NumeroMensajesNuevos;
                            }
                        }

                        ChatsDTO chatRecibido = new ChatsDTO
                        {
                            Consecutivo          = evt.ChatRecibido.Consecutivo,
                            ChatsEstado          = evt.ChatRecibido.ChatsEstado,
                            ChatsMensajesEnvia   = evt.ChatRecibido.ChatsMensajesEnvia,
                            ChatsMensajesRecibe  = evt.ChatRecibido.ChatsMensajesRecibe,
                            CodigoChatRecibe     = evt.ChatRecibido.CodigoChatRecibe,
                            CodigoEstado         = evt.ChatRecibido.CodigoEstado,
                            CodigoPersonaNoOwner = evt.ChatRecibido.CodigoPersonaNoOwner,
                            CodigoPersonaOwner   = evt.ChatRecibido.CodigoPersonaOwner,
                            Creacion             = evt.ChatRecibido.Creacion,
                            EstadoChat           = evt.ChatRecibido.EstadoChat,
                            PersonasNoOwner      = evt.ChatRecibido.PersonasNoOwner,
                            PersonasOwner        = evt.ChatRecibido.PersonasOwner,
                            UltimoMensaje        = evt.ChatRecibido.UltimoMensaje
                        };

                        chatRecibido.UltimoMensaje.MensajeParaMostrar = chatRecibido.PersonasOwner.Nombres + ": " + chatRecibido.UltimoMensaje.Mensaje;

                        // Si este CodigoPersonaOwner es igual al consecutivo de App.Persona significa que ese mensaje es generado por mi
                        bool esMensajeGeneradoPorMi = chatRecibido.CodigoPersonaOwner == App.Persona.Consecutivo;

                        // Si recibo un mensaje de la persona con la que estoy hablando
                        bool esMensajeConElQueConverso = CodigoChatConElQueConverso.HasValue && CodigoChatConElQueConverso.Value == chatRecibido.Consecutivo;

                        // Si el mensaje no es generado por mi no lo marco como nuevo
                        chatRecibido.EsNuevoMensaje = !esMensajeGeneradoPorMi && !esMensajeConElQueConverso;
                        if (esMensajeGeneradoPorMi)
                        {
                            chatRecibido.UltimoMensaje.UltimoMensajeEsMio = true;
                        }
                        else
                        {
                            // Aqui entra cuando el mensaje no es mio, entonces hay que intercambiar las entidades
                            // Para que el chat sea tratado como es y se vea los mensajes con el nombre de quien hablo y eso

                            var personaNoOwnerTemporal = chatRecibido.PersonasNoOwner;
                            chatRecibido.PersonasNoOwner = chatRecibido.PersonasOwner;
                            chatRecibido.PersonasOwner   = personaNoOwnerTemporal;

                            var codigoPersonaNoOwnerTemporal = chatRecibido.CodigoPersonaNoOwner;
                            chatRecibido.CodigoPersonaNoOwner = chatRecibido.CodigoPersonaOwner;
                            chatRecibido.CodigoPersonaOwner   = codigoPersonaNoOwnerTemporal;

                            var codigoChatRecibidoTemporal = chatRecibido.CodigoChatRecibe;
                            chatRecibido.CodigoChatRecibe = chatRecibido.Consecutivo;
                            chatRecibido.Consecutivo      = codigoChatRecibidoTemporal;
                        }

                        chatRecibido.NumeroMensajesNuevos = numeroMensajesNuevos + 1;
                        if (_chats == null)
                        {
                            _chats = new ObservableRangeCollection <ChatsDTO>(new List <ChatsDTO> {
                                chatRecibido
                            });
                        }
                        else
                        {
                            _chats.Add(chatRecibido);
                        }

                        Device.BeginInvokeOnMainThread(() => RaisePropertyChanged(nameof(Chats)));

                        // Si el mensaje no es generado por mi (sea porque viene de otro cel o de la web)
                        // Si no estoy en la pantalla de conversacion
                        // Si el mensaje no es de la persona con la que estoy hablando
                        // Entonces emito sonido y subo notificacion
                        bool emiteSonido = !esMensajeGeneradoPorMi && (!App.EstoyEnPantallaConversacion || !esMensajeConElQueConverso);

                        // Si el mensaje es mio y estoy en pantalla de chat escribiendo no suena
                        if (emiteSonido)
                        {
                            App.InteractuarValorBadgeChat(1);

                            if (!App.AppIsInBackGround)
                            {
                                //Set or Get the state of the Effect sounds.
                                _audioManager.EffectsOn = true;

                                //Set the volume level of the Effects from 0 to 1.
                                _audioManager.EffectsVolume = esMensajeConElQueConverso ? 0.2f : 0.4f;

                                try
                                {
                                    //await _audioManager.PlaySound("notificationSound.mp3");
                                    await _audioManager.PlayNotificationDefaultSound();
                                }
                                catch (Exception)
                                {
                                }
                            }
                        }
                    }
                }
            };

            PerfilPageModel.OnPersonaBorrada += async(obj, evt) =>
            {
                if (_chats != null && _chats.Count > 0)
                {
                    using (await _lockeable.LockAsync())
                    {
                        ChatsDTO conversacionParaBorrar = _chats.Where(x => x.CodigoPersonaNoOwner == evt.CodigoPersonaBorrada).FirstOrDefault();

                        if (conversacionParaBorrar != null)
                        {
                            _chats.Remove(conversacionParaBorrar);

                            Device.BeginInvokeOnMainThread(() => RaisePropertyChanged(nameof(Chats)));
                        }
                    }
                }
            };

            ConnectionChanged += async(sender, args) =>
            {
                if (args.IsConnect && NecesitaRefrescar)
                {
                    try
                    {
                        await CargarConversaciones(0, 100, true, true);

                        NecesitaRefrescar = false;
                    }
                    catch (Exception)
                    {
                    }
                }

                if (!args.IsConnect)
                {
                    NecesitaRefrescar = true;
                }
            };
        }
コード例 #20
0
 public ChatMensajeArgs(ChatsDTO chatRecibido)
 {
     ChatRecibido    = chatRecibido;
     MensajeRecibido = chatRecibido.UltimoMensaje.Mensaje;
 }
コード例 #21
0
        async Task CargarConversaciones(int skipIndex, int takeIndex, bool isRefresh = false, bool aumentarBadge = false)
        {
            if (!NoHayNadaMasParaCargar || isRefresh)
            {
                ChatsDTO buscador = new ChatsDTO
                {
                    CodigoPersonaOwner = App.Persona.Consecutivo,
                    SkipIndexBase      = skipIndex,
                    TakeIndexBase      = takeIndex,
                    ZonaHorariaGMTBase = _dateTimeHelper.DifferenceBetweenGMTAndLocalTimeZone
                };

                if (isRefresh && LastRefresh != DateTime.MinValue)
                {
                    buscador.FechaFiltroBase = LastRefresh;
                    LastRefresh = DateTime.Now;
                }

                if (IsNotConnected)
                {
                    return;
                }
                List <ChatsDTO> listaChats = await _chatsServices.ListarChats(buscador);

                if (listaChats != null)
                {
                    if (listaChats.Count > 0)
                    {
                        if (isRefresh && buscador.FechaFiltroBase != DateTime.MinValue)
                        {
                            foreach (ChatsDTO chat in listaChats)
                            {
                                if (chat.UltimoMensaje != null && chat.UltimoMensaje.FechaMensaje > buscador.FechaFiltroBase && !chat.UltimoMensaje.UltimoMensajeEsMio)
                                {
                                    chat.EsNuevoMensaje = true;
                                }
                            }
                        }

                        using (await _lockeable.LockAsync())
                        {
                            if (_chats == null)
                            {
                                _chats = new ObservableRangeCollection <ChatsDTO>(listaChats);
                            }
                            else
                            {
                                foreach (ChatsDTO chat in listaChats)
                                {
                                    ChatsDTO chatExistente = _chats.Where(x => x.Consecutivo == chat.Consecutivo).FirstOrDefault();

                                    if (chatExistente != null)
                                    {
                                        _chats.Remove(chatExistente);
                                    }

                                    _chats.Add(chat);
                                }
                            }

                            if (aumentarBadge)
                            {
                                App.InteractuarValorBadgeNotificacion(listaChats.Count);
                            }
                        }

                        RaisePropertyChanged("Chats");
                    }
                    else
                    {
                        NoHayNadaMasParaCargar = listaChats.Count <= 0 && !isRefresh;
                    }
                }
            }
        }