Exemple #1
0
 public UsuarioNegocio(Go <Usuario> usuario)
 {
     Usuario = new Go <Usuario>(usuario);
     if (Usuario.Object.EspaciosAdministrador != null)
     {
         foreach (var x in Usuario.Object.EspaciosAdministrador)
         {
             UrlEspaciosAdministrador.Add(Url.AddKey(Url.Espacios,
                                                     Url.AddKey(Url.ConvertSavedUrlToFireUrl(x.Value.UrlEspacio),
                                                                x.Key)));
             UrlEspacios.Add(Url.AddKey(Url.Espacios,
                                        Url.AddKey(Url.ConvertSavedUrlToFireUrl(x.Value.UrlEspacio),
                                                   x.Key)));
         }
     }
     if (usuario.Object.EspaciosMiembro != null)
     {
         foreach (var x in usuario.Object.EspaciosMiembro)
         {
             UrlEspaciosMiembro.Add(Url.AddKey(Url.Espacios,
                                               Url.AddKey(Url.ConvertSavedUrlToFireUrl(x.Value.UrlEspacio),
                                                          x.Key)));
             UrlEspacios.Add(Url.AddKey(Url.Espacios,
                                        Url.AddKey(Url.ConvertSavedUrlToFireUrl(x.Value.UrlEspacio),
                                                   x.Key)));
         }
     }
 }
        public EspacioNegocio(Go <Espacio> espacio)
        {
            Espacio = new Go <Espacio>(espacio);

            if (Espacio.Object.UrlEspacio != null & Espacio.Object.UrlEspacio != "")
            {
                UrlEspacios = Url.AddKey(Url.Root,
                                         Url.ConvertSavedUrlToFireUrl(Espacio.Object.UrlEspacio));
            }
            else
            {
                UrlEspacios = Url.Root;
            }
            if (Espacio.Object.Administradores != null)
            {
                foreach (var x in Espacio.Object.Administradores)
                {
                    UrlUsuarios.Add(Url.AddKey(Url.Usuarios,
                                               Url.AddKey((string)x.Key, Url.Administradores)));
                }
            }
            if (Espacio.Object.Miembros != null)
            {
                foreach (var x in espacio.Object.Miembros)
                {
                    UrlUsuarios.Add(Url.AddKey(Url.Usuarios,
                                               Url.AddKey(x.Key, Url.Miembros)));
                }
            }
        }
        public async Task <IDictionary <string, Espacio> > GetAll()
        {
            IDictionary <string, Espacio> espacios = new Dictionary <string, Espacio>();
            List <string> urlEspacios = new List <string>
            {
                Url.Root
            };

            while (urlEspacios.Count > 0)
            {
                var espaciosx = await Db.Client()
                                .Child(urlEspacios[0])
                                .OnceAsync <Espacio>();

                if (espaciosx != null)
                {
                    foreach (var espaciox in espaciosx)
                    {
                        urlEspacios.Add(Url.AddKey(urlEspacios[0], espaciox.Key));
                        espacios.Add(espaciox.Key, espaciox.Object);
                    }
                }
                urlEspacios.Remove(urlEspacios[0]);
            }
            return(espacios);
        }
Exemple #4
0
        public async Task Update()
        {
            await Db.Update(Comentario.Object.ReturnSmallComentario(),
                            Url.AddKey(UrlEspacios, Comentario.Key));

            await Db.Update(Comentario.Object.ReturnSmallComentario(),
                            Url.AddKey(UrlUsuarios, Comentario.Key));
        }
        public async Task Update()
        {
            await Db.Update(Mensaje.Object.ReturnSmallMensaje(),
                            Url.AddKey(UrlEmisor, Mensaje.Key));

            await Db.Update(Mensaje.Object.ReturnSmallMensaje(),
                            Url.AddKey(UrlReceptor, Mensaje.Key));
        }
Exemple #6
0
        public async Task Update()
        {
            await Db.Update(Post.Object.ReturnSmallPost(),
                            Url.AddKey(UrlEspacios, Post.Key));

            await Db.Update(Post.Object.ReturnSmallPost(),
                            Url.AddKey(UrlUsuarios, Post.Key));
        }
        public async Task Create()
        {
            var x = await Db.Create(Mensaje.Object.ReturnSmallMensaje(), UrlReceptor);;

            if (x.Key != null)
            {
                await Db.Update(Mensaje.Object.ReturnSmallMensaje(), Url.AddKey(UrlEmisor, x.Key));
            }
        }
        public async Task Update()
        {
            await Db.Update(Espacio.Object, Url.AddKey(UrlEspacios, Espacio.Key));

            foreach (string urlaux in UrlUsuarios)
            {
                await Db.Update(Espacio.Object, Url.AddKey(urlaux, Espacio.Key));
            }
        }
        public async Task Delete()
        {
            await Db.Delete(Url.AddKey(UrlEspacios, Espacio.Key));

            foreach (string urlaux in UrlUsuarios)
            {
                await Db.Delete(Url.AddKey(urlaux, Espacio.Key));
            }
        }
Exemple #10
0
        public async Task Create()
        {
            Comentario.Key = null;
            var x = await Db.Create(Comentario.Object.ReturnSmallComentario(), UrlEspacios);;

            if (x.Key != null)
            {
                await Db.Update(Comentario.Object.ReturnSmallComentario(), Url.AddKey(UrlUsuarios, Comentario.Key));
            }
        }
Exemple #11
0
        public async Task <Go <Post> > Create(Post post)
        {
            string url = Url.AddKey(Url.Espacios,
                                    Url.AddKey(post.Espacio.Object.UrlEspacio,
                                               Url.AddKey(post.Espacio.Key,
                                                          Url.Root)));
            await Db.Create(post.ReturnSmallPost(), url);

            return(new Go <Post>(post));
        }
 public TagNegocio(Go <Tag> tag)
 {
     Tag = new Go <Tag>(tag);
     if (Tag.Object.Espacio.Object.UrlEspacio == null)
     {
         Tag.Object.Espacio.Object.UrlEspacio = "";
     }
     UrlEspacios = Url.AddKey(Url.Espacios,
                              Url.AddKey(Url.ConvertSavedUrlToFireUrl(Tag.Object.Espacio.Object.UrlEspacio),
                                         Url.AddKey(Tag.Object.Espacio.Key,
                                                    Url.Root)));
 }
Exemple #13
0
        public async Task Delete()
        {
            foreach (var urlAux in UrlEspacios)
            {
                await Db.Delete(Url.AddKey(urlAux,
                                           Url.AddKey(Url.Administradores, Usuario.Key)));

                await Db.Delete(Url.AddKey(urlAux,
                                           Url.AddKey(Url.Miembros, Usuario.Key)));
            }
            await Db.Delete(Url.AddKey(Url.Root, Usuario.Key));
        }
 public MensajeNegocio(Go <Mensaje> mensaje)
 {
     Mensaje   = new Go <Mensaje>(mensaje);
     UrlEmisor = Url.AddKey(Url.Usuarios,
                            Url.AddKey(Mensaje.Object.Emisor,
                                       Url.AddKey(Url.Root,
                                                  Mensaje.Object.Receptor)));
     UrlReceptor = Url.AddKey(Url.Usuarios,
                              Url.AddKey(Mensaje.Object.Receptor,
                                         Url.AddKey(Url.Root,
                                                    Mensaje.Object.Emisor)));
 }
        public async Task Create()
        {
            var x = await Db.Create(Espacio.Object, UrlEspacios);

            if (x != null)
            {
                Espacio.Key = x.Key;
                foreach (var urlaux in UrlUsuarios)
                {
                    await Db.Update(Espacio.Object.ReturnSmallEspacio(), Url.AddKey(urlaux, Espacio.Key));
                }
            }
        }
Exemple #16
0
        public async Task Update()
        {
            await Db.Update(Usuario.Object, Url.AddKey(Url.Root, Usuario.Key));

            foreach (string url in
                     UrlEspaciosAdministrador)
            {
                await Db.Update(Usuario.Object, Url.AddKey(url, Usuario.Key));
            }
            foreach (string url in UrlEspaciosMiembro)
            {
                await Db.Update(Usuario.Object, Url.AddKey(url, Usuario.Key));
            }
        }
Exemple #17
0
        public async Task <List <Go <Post> > > GetAllFromEspacio(string urlEspacio)
        {
            string url = Url.AddKey(Url.Espacios,
                                    Url.AddKey(urlEspacio,
                                               Url.Root));
            var data = await Db.Client()
                       .Child(url)
                       .OnceAsync <Post>();

            List <Go <Post> > posts = new List <Go <Post> >();

            foreach (FirebaseObject <Post> aux in data)
            {
                posts.Add(new Go <Post>(aux));
            }
            return(posts);
        }
Exemple #18
0
        public async Task Create()
        {
            await FirebaseNewUser();

            if (Usuario.Key != null)
            {
                await Db.Update(Usuario.Object, Url.AddKey(Url.Root, Usuario.Key));

                foreach (string url in UrlEspaciosAdministrador)
                {
                    await Db.Update(Usuario.Object, Url.AddKey(url, Usuario.Key));
                }
                foreach (string url in UrlEspaciosMiembro)
                {
                    await Db.Update(Usuario.Object, Url.AddKey(url, Usuario.Key));
                }
            }
        }
        public async Task <List <Go <Tag> > > GetAllFromEspacios(string UrlEspacio)
        {
            UrlEspacio = Url.AddKey(Url.Espacios,
                                    Url.AddKey(UrlEspacio,
                                               Url.Root));

            List <Go <Tag> > tags = new List <Go <Tag> >();
            var data = await Db.Client()
                       .Child(UrlEspacio)
                       .OnceAsync <Tag>();

            foreach (var aux in data)
            {
                tags.Add(new Go <Tag>(aux));
            }

            return(tags);
        }
Exemple #20
0
        public async Task <IDictionary <string, Usuario> > GetAllFromEspacio()
        {
            IDictionary <string, Usuario> usuarios = new Dictionary <string, Usuario>();
            var data = await Db.Client()
                       .Child(Url.AddKey(UrlEspacios[0], Url.Administradores))
                       .OnceAsync <Usuario>();

            foreach (var aux in data)
            {
                usuarios.Add(aux.Key, aux.Object);
            }

            data = await Db.Client()
                   .Child(Url.AddKey(UrlEspacios[0], Url.Miembros))
                   .OnceAsync <Usuario>();

            foreach (var aux in data)
            {
                usuarios.Add(aux.Key, aux.Object);
            }
            return(usuarios);
        }
        public async Task <List <Go <Espacio> > > GetAllFromUsuario(string idUsuario)
        {
            List <Go <Espacio> > espacios = new List <Go <Espacio> >();

            var espaciosx = await Db.Client()
                            .Child(Url.AddKey(
                                       Url.Usuarios,
                                       Url.AddKey(idUsuario,
                                                  Url.Administradores)))
                            .OnceAsync <Espacio>();

            if (espaciosx != null)
            {
                foreach (var espaciox in espaciosx)
                {
                    this.UrlEspacios = Url.AddKey(Url.Root, espaciox.Object.UrlEspacio);
                    this.Espacio     = new Go <Espacio>(espaciox.Key, espaciox.Object);
                    espacios.Add(await GetObject());
                }
            }
            return(espacios);
        }
Exemple #22
0
 public ComentarioNegocio(Go <Comentario> comentario)
 {
     Comentario  = new Go <Comentario>(comentario);
     UrlUsuarios = Url.AddKey(Url.Usuarios, Comentario.Object.Usuario.Key);
     UrlEspacios = Url.RootInOneEspacio(Comentario.Object.Post.Object.Espacio);
 }
 public async Task Update()
 {
     await Db.Update(Noticia,
                     Url.AddKey(Url.Root,
                                this.Noticia.Key));
 }
        public async Task Delete()
        {
            await Db.Delete(Url.AddKey(UrlEmisor, Mensaje.Key));

            await Db.Delete(Url.AddKey(UrlReceptor, Mensaje.Key));
        }
Exemple #25
0
        public async Task Delete()
        {
            await Db.Delete(Url.AddKey(UrlEspacios, Post.Key));

            await Db.Delete(Url.AddKey(UrlUsuarios, Post.Key));
        }
Exemple #26
0
 public PostNegocio(Go <Post> post)
 {
     Post        = new Go <Post>(post);
     UrlEspacios = Url.RootInOneEspacio(Post.Object.Espacio);
     UrlUsuarios = Url.AddKey(Url.Usuarios, Post.Object.Usuario.Key);
 }
        public async Task <Go <Tag> > Update()
        {
            await Db.Update(Tag.Object.ReturnSmallTag(), Url.AddKey(UrlEspacios, Tag.Key));

            return(Tag);
        }