protected override void OnBindingContextChanged()
        {
            base.OnBindingContextChanged();
            ContactosDTO item = BindingContext as ContactosDTO;

            if (item == null)
            {
                return;
            }

            UrlImagenPerfil.Source = null;
            if (!string.IsNullOrWhiteSpace(item.PersonasContacto.UrlImagenPerfil))
            {
                UrlImagenPerfil.Source = item.PersonasContacto.UrlImagenPerfil;
            }
            else
            {
                UrlImagenPerfil.Source = App.Current.Resources["RutaDefaultImagenPerfil"] as string;
            }

            UrlImagenPais.Source = null;
            if (!string.IsNullOrWhiteSpace(item.PersonasContacto.Paises.UrlArchivo))
            {
                UrlImagenPais.Source = item.PersonasContacto.Paises.UrlArchivo;
            }
            else
            {
                UrlImagenPais.Source = App.Current.Resources["RutaDefaultImagen"] as string;
            }
        }
        public BiografiaTimeLineModel(ContactosDTO primerContacto, ContactosDTO segundoContacto)
        {
            PrimerContacto  = primerContacto;
            SegundoContacto = segundoContacto;

            TipoTimeLine = TipoItemTimeLine.Contacto;
        }
        public static List <BiografiaTimeLineModel> CrearListaBiografiaTimeLine(ICollection <ContactosDTO> contactos)
        {
            List <BiografiaTimeLineModel> listaContactos = new List <BiografiaTimeLineModel>();

            if (contactos != null && contactos.Count > 0)
            {
                ContactosDTO contactoPrimero = null;

                foreach (var contacto in contactos)
                {
                    if (contactoPrimero == null)
                    {
                        contactoPrimero = contacto;
                    }
                    else
                    {
                        listaContactos.Add(new BiografiaTimeLineModel(contactoPrimero, contacto));
                        contactoPrimero = null;
                    }
                }

                if (contactoPrimero != null && !listaContactos.Any(x => x.SegundoContacto == contactoPrimero))
                {
                    listaContactos.Add(new BiografiaTimeLineModel(contactoPrimero, null));
                }
            }

            return(listaContactos);
        }
        public async Task <JsonResult> GetMyContacts(ContactosDTO contact)
        {
            Result <ContactosDTO> result = new Result <ContactosDTO>();

            try
            {
                ChatsServices chatService = new ChatsServices();
                if (GetPersonToSearch() != null && GetPersonToSearch().Consecutivo != 0)
                {
                    contact.CodigoPersonaOwner = GetPersonToSearch().Consecutivo;
                }
                else
                {
                    contact.CodigoPersonaOwner = UserLoggedIn().PersonaDelUsuario.Consecutivo;
                }

                contact.CodigoIdiomaUsuarioBase = UserLoggedIn().PersonaDelUsuario.CodigoIdioma;
                result.list = await chatService.ListarContactos(contact);

                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));
            }
        }
Example #5
0
        public JsonResult GuardarContacto(int idContacto, int idClienteContacto, string Nombre_Contacto, string Puesto_Contacto, string Email_Contacto, string Skype_Contacto, string Telefono_Contacto, string Movil_Contacto, string Comentario_Contacto, int estado, int enviaFactura)
        {
            var contacto = new ContactosDTO();

            contacto.Id_Contacto           = idContacto;
            contacto.Id_Cliente            = idClienteContacto;
            contacto.Nombre_Contacto       = Nombre_Contacto;
            contacto.Puesto_Contacto       = Puesto_Contacto;
            contacto.Email_Contacto        = Email_Contacto;
            contacto.Telefono_Contacto     = Telefono_Contacto;
            contacto.Movil__Contacto       = Movil_Contacto;
            contacto.Skype_Contacto        = Skype_Contacto;
            contacto.EnviaFactura_Contacto = enviaFactura == 1;
            contacto.Comentario_Contacto   = Comentario_Contacto;
            contacto.Estado = estado == 1;

            var obj = new ClienteData().GuardarContactos(contacto);

            if (obj.Code != 0)
            {
                return(Json(new { success = false, message = obj.Message }, JsonRequestBehavior.AllowGet));
            }

            var objContactos = new ClienteData().GetContactosCliente(contacto.Id_Cliente);

            if (objContactos.Code != 0)
            {
                return(Json(new { success = false, message = objContactos.Message }, JsonRequestBehavior.AllowGet));
            }

            return(Json(new { success = true, contactos = objContactos.Result }, JsonRequestBehavior.AllowGet));
        }
Example #6
0
        public MethodResponseDTO <int> GuardarContactos(ContactosDTO contactos)
        {
            using (var context = new DB_9F97CF_CatarsysSGCEntities())
            {
                try
                {
                    var response = new MethodResponseDTO <int>()
                    {
                        Code = 0, Result = 1
                    };


                    if (contactos.Id_Contacto == 0)
                    {
                        var objDB = Mapper.Map <Contactos>(contactos);
                        context.Contactos.Add(objDB);
                    }
                    else
                    {
                        var objDB = context.Contactos.SingleOrDefault(x => x.Id_Contacto == contactos.Id_Contacto);

                        objDB.Nombre_Contacto       = contactos.Nombre_Contacto;
                        objDB.Puesto_Contacto       = contactos.Puesto_Contacto;
                        objDB.Email_Contacto        = contactos.Email_Contacto;
                        objDB.Telefono_Contacto     = contactos.Telefono_Contacto;
                        objDB.Movil__Contacto       = contactos.Movil__Contacto;
                        objDB.Skype_Contacto        = contactos.Skype_Contacto;
                        objDB.Comentario_Contacto   = contactos.Comentario_Contacto;
                        objDB.EnviaFactura_Contacto = contactos.EnviaFactura_Contacto;
                        objDB.Estado = contactos.Estado;
                    }
                    context.SaveChanges();

                    return(response);
                }
                catch (DbEntityValidationException e)
                {
                    string Result = string.Empty;
                    foreach (var eve in e.EntityValidationErrors)
                    {
                        Result += string.Format("Entity of type \"{0}\" in state \"{1}\" has the following validation errors:", eve.Entry.Entity.GetType().Name, eve.Entry.State);
                        foreach (var ve in eve.ValidationErrors)
                        {
                            Result += string.Format("- Property: \"{0}\", Error: \"{1}\"", ve.PropertyName, ve.ErrorMessage);
                        }
                    }
                    Result += ("Code: -100, Mensaje: " + e.Message + ", InnerException: " + (e.InnerException != null ? e.InnerException.Message : ""));
                    return(new MethodResponseDTO <int> {
                        Code = -100, Result = 0, Message = e.Message
                    });
                }
                catch (Exception ex)
                {
                    return(new MethodResponseDTO <int> {
                        Code = -100, Result = 0, Message = "GuardarAsignacion: " + ex.Message
                    });
                }
            }
        }
        async Task VerificarSiPersonaEstaAgregada()
        {
            ContactosDTO contacto = new ContactosDTO
            {
                CodigoPersonaOwner    = App.Persona.Consecutivo,
                CodigoPersonaContacto = Persona.Consecutivo
            };

            if (IsNotConnected)
            {
                return;
            }
            ContactosDTO contactoBuscado = await _chatServices.VerificarSiLaPersonaEstaAgregadaContactos(contacto);

            EstaAgregadoContacto = contactoBuscado != null && contactoBuscado.Consecutivo > 0;
        }
Example #8
0
        public async Task <WrapperSimpleTypesDTO> EliminarContacto(ContactosDTO contactoParaEliminar)
        {
            if (contactoParaEliminar == null)
            {
                throw new ArgumentNullException("No puedes eliminar un contacto si contactoParaEliminar es nulo!.");
            }
            if (contactoParaEliminar.Consecutivo <= 0)
            {
                throw new ArgumentException("contactoParaEliminar vacio y/o invalido!.");
            }

            IHttpClient client = ConfigurarHttpClient();

            WrapperSimpleTypesDTO wrapperEliminarContacto = await client.PostAsync <ContactosDTO, WrapperSimpleTypesDTO>("Chats/EliminarContacto", contactoParaEliminar);

            return(wrapperEliminarContacto);
        }
Example #9
0
        public async Task <List <ContactosDTO> > ListarContactos(ContactosDTO contactoParaListar)
        {
            if (contactoParaListar == null)
            {
                throw new ArgumentNullException("No puedes listar los contactos si contactoParaListar es nulo!.");
            }
            if (contactoParaListar.CodigoPersonaOwner <= 0 || contactoParaListar.SkipIndexBase < 0 || contactoParaListar.TakeIndexBase <= 0)
            {
                throw new ArgumentException("contactoParaListar vacio y/o invalido!.");
            }

            IHttpClient client = ConfigurarHttpClient();

            List <ContactosDTO> listaContactos = await client.PostAsync <ContactosDTO, List <ContactosDTO> >("Chats/ListarContactos", contactoParaListar);

            return(listaContactos);
        }
Example #10
0
        public async Task <ContactosDTO> VerificarSiLaPersonaEstaAgregadaContactos(ContactosDTO contactoParaBuscar)
        {
            if (contactoParaBuscar == null)
            {
                throw new ArgumentNullException("No puedes buscar un contacto si contactoParaBuscar es nulo!.");
            }
            if (contactoParaBuscar.CodigoPersonaContacto <= 0 || contactoParaBuscar.CodigoPersonaOwner <= 0)
            {
                throw new ArgumentException("contactoParaBuscar vacio y/o invalido!.");
            }

            IHttpClient client = ConfigurarHttpClient();

            ContactosDTO contactoBuscado = await client.PostAsync("Chats/VerificarSiLaPersonaEstaAgregadaContactos", contactoParaBuscar);

            return(contactoBuscado);
        }
Example #11
0
        public async Task <ContactosDTO> BuscarContacto(ContactosDTO contactoParaBuscar)
        {
            if (contactoParaBuscar == null)
            {
                throw new ArgumentNullException("No puedes buscar un contacto si contactoParaBuscar es nulo!.");
            }
            if (contactoParaBuscar.Consecutivo <= 0)
            {
                throw new ArgumentException("contactoParaBuscar vacio y/o invalido!.");
            }

            IHttpClient client = ConfigurarHttpClient();

            ContactosDTO contactoBuscado = await client.PostAsync("Chats/BuscarContacto", contactoParaBuscar);

            return(contactoBuscado);
        }
Example #12
0
        public async Task <WrapperSimpleTypesDTO> CrearContacto(ContactosDTO contactoParaCrear)
        {
            if (contactoParaCrear == null)
            {
                throw new ArgumentNullException("No puedes crear un contacto si contactoParaCrear es nula!.");
            }
            if (contactoParaCrear.CodigoPersonaContacto <= 0 || contactoParaCrear.CodigoPersonaOwner <= 0)
            {
                throw new ArgumentException("contactoParaCrear vacia y/o invalida!.");
            }

            IHttpClient client = ConfigurarHttpClient();

            WrapperSimpleTypesDTO wrapperCrearContacto = await client.PostAsync <ContactosDTO, WrapperSimpleTypesDTO>("Chats/CrearContacto", contactoParaCrear);

            return(wrapperCrearContacto);
        }
        async Task CargarContactos(int skipIndex, int takeIndex, bool isRefresh = false)
        {
            if (Persona != null && !NoHayNadaMasParaCargarContactos)
            {
                List <BiografiaTimeLineModel> listaTimeLine = new List <BiografiaTimeLineModel>();

                ContactosDTO contacto = new ContactosDTO
                {
                    CodigoPersonaOwner = Persona.Consecutivo,
                    SkipIndexBase      = skipIndex,
                    TakeIndexBase      = takeIndex
                };

                if (IsNotConnected)
                {
                    return;
                }
                List <ContactosDTO> listaContactos = await _chatServices.ListarContactos(contacto);

                listaTimeLine = BiografiaTimeLineModel.CrearListaBiografiaTimeLine(listaContactos);

                if (listaTimeLine != null)
                {
                    if (listaTimeLine.Count > 0)
                    {
                        if (_timeLine == null)
                        {
                            _timeLine = new ObservableRangeCollection <BiografiaTimeLineModel>(listaTimeLine);
                        }
                        else
                        {
                            _timeLine.AddRange(listaTimeLine);
                        }

                        NumeroContactosBuscados = listaContactos.Count;
                        RaisePropertyChanged(nameof(TimeLine));
                    }
                    else
                    {
                        NoHayNadaMasParaCargarContactos = listaTimeLine.Count <= 0;
                    }
                }
            }
        }
Example #14
0
        async Task CargarContactos(int skipIndex, int takeIndex)
        {
            if (!NoHayNadaMasParaCargar)
            {
                ContactosDTO buscador = new ContactosDTO
                {
                    CodigoPersonaOwner      = App.Persona.Consecutivo,
                    SkipIndexBase           = skipIndex,
                    TakeIndexBase           = takeIndex,
                    IdiomaBase              = App.IdiomaPersona,
                    IdentificadorParaBuscar = TextoBuscador
                };

                if (IsNotConnected)
                {
                    return;
                }
                List <ContactosDTO> listaContactos = await _chatsServices.ListarContactos(buscador);

                if (listaContactos != null)
                {
                    if (listaContactos.Count > 0)
                    {
                        if (_contactos == null)
                        {
                            _contactos = new ObservableRangeCollection <ContactosDTO>(listaContactos);
                        }
                        else
                        {
                            listaContactos = listaContactos.Where(x => !_contactos.Where(y => y.Consecutivo == x.Consecutivo).Any()).ToList();
                            _contactos.AddRange(listaContactos);
                        }

                        RaisePropertyChanged("Contactos");
                    }
                    else
                    {
                        NoHayNadaMasParaCargar = listaContactos.Count <= 0;
                    }
                }
            }
        }
        public async Task <JsonResult> DeleteContact(ContactosDTO contact)
        {
            Result <WrapperSimpleTypesDTO> result = new Result <WrapperSimpleTypesDTO>();

            try
            {
                ChatsServices chatService = new ChatsServices();
                result.obj = await chatService.EliminarContacto(contact);

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

                return(Json(Helper.returnSuccessDeleteObj(UserLoggedIn().PersonaDelUsuario.CodigoIdioma), JsonRequestBehavior.AllowGet));
            }
            catch (Exception)
            {
                return(Json(Helper.returnErrorSaveObj(UserLoggedIn().PersonaDelUsuario.CodigoIdioma), JsonRequestBehavior.AllowGet));
            }
        }
        public async Task <JsonResult> CreateContact()
        {
            Result <WrapperSimpleTypesDTO> result = new Result <WrapperSimpleTypesDTO>();

            try
            {
                ChatsServices chatService = new ChatsServices();
                ContactosDTO  contact     = new ContactosDTO();
                contact.CodigoPersonaContacto = GetPersonToSearchTemp().Consecutivo;
                contact.CodigoPersonaOwner    = UserLoggedIn().PersonaDelUsuario.Consecutivo;
                result.obj = await chatService.CrearContacto(contact);

                if (result.obj == 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));
            }
        }