コード例 #1
0
        public static Nodo crearNodo(Grupo g)
        {
            Nodo nodo = new Nodo();

            nodo.nombre         = g.nombre;
            nodo.URL            = g.URL;
            nodo.objetivo       = g.objetivo;
            nodo.padreURL       = g.padreURL;
            nodo.padreNombre    = g.padreNombre;
            nodo.acceso         = "si";
            nodo.activos        = g.getUsuariosHabilitadosActivos().Count;
            nodo.colorPromedio  = g.queso.getColorPromedio();
            nodo.horizontalidad = g.getHorizontalidad();
            nodo.bloqueo        = Math.Min(g.arbol.minSiValue, g.arbol.maxNoValue);
            nodo.minSiPc        = g.arbol.minSiPc;
            nodo.maxNoPc        = g.arbol.maxNoPc;

            List <nabu.Usuario> usus = g.usuarios;

            usus.Sort(new nabu.Usuario.RolComparer());
            foreach (nabu.Usuario u in usus)
            {
                if (u.habilitado)
                {
                    Usuario p = new Usuario();
                    p.nombre          = u.nombre;
                    p.funcion         = u.funcion;
                    p.email           = u.email;
                    p.born            = u.born;
                    p.isAdmin         = u.isAdmin;
                    p.isSecretaria    = u.isSecretaria;
                    p.isFacilitador   = u.isFacilitador;
                    p.isRepresentante = u.isRepresentante;
                    p.isActive        = u.isActive;
                    p.apoyos          = u.apoyos; //cantidad de apoyos por parte de otros usuarios
                    p.readOnly        = u.readOnly;
                    p.grupoDesde      = u.grupoDesde;
                    nodo.usuarios.Add(p);
                }
            }

            if (g.organizacion.GetType().Name == "Plataforma")
            {
                organizaciones.Plataforma pl = (organizaciones.Plataforma)g.organizacion;

                foreach (plataforma.Seguimiento u in pl.seguimientos)
                {
                    Seguimiento p = new Seguimiento();
                    p.nombre      = u.nombre;
                    p.EID         = u.EID;
                    p.born        = u.born;
                    p.objetivo    = u.objetivo;
                    p.responsable = u.responsable;
                    p.icono       = u.icono;
                    nodo.seguimientos.Add(p);
                }
            }

            foreach (Hijo hijo in g.hijos)
            {
                Bosque.Nodo n = new Bosque.Nodo();
                n.URL    = hijo.URL;
                n.nombre = hijo.nombre;
                nodo.hijos.Add(n);
            }
            return(nodo);
        }
コード例 #2
0
        protected void Page_Load(object sender, EventArgs e)
        {
            string actn = Request["actn"];

            Application.Lock();
            if (Application["aplicacion"] == null)
            {
                Application["aplicacion"] = new Aplicacion(Server, Request);
            }
            app = (Aplicacion)Application["aplicacion"];
            Application.UnLock();

            Tools.startupPath = Server.MapPath("");
            Tools.server      = Server;

            try
            {
                //guardo lista de arboles periodicamente
                app.verifySave();

                //envio algun mail si hay en cola
                app.mailBot.send();

                //proceso peticiones
                Grupo  grupo;
                Arbol  a;
                string ret = "";
                string msg;

                if (actn != null)
                {
                    switch (actn.ToLower())
                    {
                    case "cambiarclave":
                        grupo = app.getGrupo(Request["grupo"]);
                        lock (grupo)
                        {
                            grupo.ts = DateTime.Now;
                            Usuario u = grupo.getUsuarioHabilitado(Request["email"]);
                            if (u == null)
                            {
                                throw new appException(Tools.tr("El usuario no existe o no esta habilitado", grupo.idioma));
                            }
                            else
                            {
                                if (u.clave != Request["claveActual"])
                                {
                                    throw new appException(Tools.tr("La clave actual no corresponde", grupo.idioma));
                                }
                                else
                                {
                                    if (Request["nuevaClave"] == "")
                                    {
                                        throw new appException(Tools.tr("La clave nueva no puede ser vacia", grupo.idioma));
                                    }
                                    else
                                    {
                                        u.clave = Request["nuevaClave"];     //no devuelvo mensaje
                                    }
                                }
                            }
                        }
                        break;

                    case "resumen":
                        Response.Write(getResumen());
                        break;

                    case "borrargrupo":
                        VerificarUsuario(Request["grupo"], Request["email"], Request["clave"]);
                        grupo = app.getGrupo(Request["grupo"]);
                        lock (grupo)
                        {
                            Usuario u = grupo.getUsuario(Request["email"]);
                            if (u != null && u.isAdmin)
                            {
                                borrarCarpeta(Server.MapPath("grupos/" + grupo.nombre));
                            }
                            else
                            {
                                throw new Exception("Debe ser coordinador");
                            }
                        }

                        app.grupos.Remove(grupo);

                        Response.Write("Grupo borrado");
                        break;

                    case "borrarhijo":
                        VerificarUsuario(Request["grupo"], Request["email"], Request["clave"]);
                        grupo = app.getGrupo(Request["grupo"]);
                        lock (grupo)
                        {
                            foreach (Hijo hijo in grupo.hijos)
                            {
                                if (hijo.URL == Request["hijoURL"] && hijo.nombre == Request["hijoNombre"])
                                {
                                    grupo.hijos.Remove(hijo);
                                    break;
                                }
                            }
                            Response.Write(Tools.tr("Grupo hijo borrado", grupo.idioma));
                        }
                        break;

                    case "crearhijo":
                        VerificarUsuario(Request["grupo"], Request["email"], Request["clave"]);
                        grupo = app.getGrupo(Request["grupo"]);
                        lock (grupo)
                        {
                            string hijoURL = Request["hijoURL"];
                            if (hijoURL.EndsWith("/"))
                            {
                                hijoURL = hijoURL.Substring(0, hijoURL.Length - 1);
                            }
                            if (hijoURL == "")
                            {
                                hijoURL = Request.UrlReferrer.AbsoluteUri.Substring(0, Request.UrlReferrer.AbsoluteUri.LastIndexOf("/"));
                            }
                            grupo.hijos.Add(new Hijo(hijoURL, Request["hijoNombre"]));
                            Response.Write(Tools.tr("Nuevo grupo hijo agregado", grupo.idioma));
                        }
                        break;

                    case "getusuarios":
                        VerificarUsuario(Request["grupo"], Request["email"], Request["clave"]);
                        grupo = app.getGrupo(Request["grupo"]);
                        lock (grupo)
                        {
                            a        = grupo.arbol;
                            grupo.ts = DateTime.Now;
                            a.actualizarApoyos();
                            Response.Write(Tools.toJson(grupo.getUsuariosOrdenados()));
                        }
                        break;

                    case "crearusuarios":
                        grupo = app.getGrupo(Request["grupo"]);
                        List <Usuario> usuarios = Tools.fromJson <List <Usuario> >(Request["usuarios"]);
                        lock (grupo)
                        {
                            foreach (Usuario u in usuarios)
                            {
                                if (grupo.getUsuario(u.email) == null)
                                {
                                    //este no existe, lo creo
                                    actualizarUsuario(u.nombre, u.email, u.clave, grupo.nombre, true, false, false, false, false, false, "", u.grupoDesde);
                                }
                            }
                            Response.Write(Tools.tr("Usuarios creados desahibilitados", Request["grupo"], grupo.idioma));
                        }
                        break;

                    case "exception":
                        app.addLog("client exception", Request.UserHostAddress, Request["grupo"], Request["email"], Request["flag"] + " -- " + Request["message"] + " -- " + Request["stack"]);
                        break;

                    case "sendmailwelcome":
                        VerificarUsuario(Request["grupo"], Request["email"], Request["clave"]);
                        grupo = app.getGrupo(Request["grupo"]);
                        lock (grupo)
                        {
                            a = grupo.arbol;
                            string url = Request.UrlReferrer.OriginalString.Substring(0, Request.UrlReferrer.OriginalString.LastIndexOf("/"));
                            url += "/?grupo=" + Request["grupo"];
                            Usuario u = grupo.getUsuario(Request["usuarioemail"]);
                            msg = Tools.sendMailWelcome(grupo, Request["usuarioemail"], u.clave, url, Server.MapPath("mails/modelos/" + grupo.idioma));
                        }
                        Response.Write(msg);
                        break;

                    case "sendmail":
                        VerificarUsuario(Request["grupo"], Request["email"], Request["clave"]);
                        string email   = Request["usuarioemail"];
                        string body    = Request["body"];
                        string subject = Request["subject"];
                        msg = Tools.sendMail(email, subject, body.Replace("\n", "<br>"));
                        Response.Write(msg);
                        break;

                    case "sendmailalta":
                        //peticion de alta al coordinador
                        grupo = app.getGrupo(Request["grupo"]);
                        lock (grupo)
                        {
                            Usuario u = grupo.getAdmin();
                            msg = Tools.sendMailAlta(grupo, u.email, Request["nombre"], Request["usuarioemail"], Server.MapPath("mails/modelos"));
                        }
                        Response.Write(msg);
                        break;

                    case "getconfig":
                        //plataformas cliente reconocidas
                        //Type=Chrome45;Name=Chrome;Version=45.0;Platform=WinNT;Cookies=True
                        //Type=Safari5;Name=Safari;Version=5.1;Platform=Unknown;Cookies=True;width=1300;height=854
                        //Type=InternetExplorer11;Name=InternetExplorer;Version=11.0;Platform=WinNT;Cookies=True;width=784;height=537


                        Config cnf = getConfig();
                        cnf.browser = Request.Browser.Browser;
                        cnf.type    = Request.Browser.Type;
                        cnf.version = Request.Browser.Version;
                        cnf.width   = int.Parse(Request["width"]);
                        cnf.height  = int.Parse(Request["height"]);


                        ret = Tools.toJson(cnf);
                        Response.Write(ret);
                        app.addLog("getConfig", Request.UserHostAddress, "", "", getClientBrowser(Request) + ";width=" + Request["width"] + ";height=" + Request["height"]);
                        break;

                    //case "newgrupoadmins":
                    //    Grupo g = doNewGrupoFromPadre(Request["grupo"], Request["organizacion"], Request["admins"], Request["idioma"], Request["padreURL"], Request["idioma"]);
                    //    lock (app.grupos)
                    //    {
                    //        app.grupos.Add(g);
                    //        //guardo a disco
                    //        app.saveGrupos();
                    //    }
                    //    Response.Write("Grupo creado");
                    //    app.addLog("doNewGrupoFromPadre", Request.UserHostAddress, Request["grupo"], Request["email"], "");
                    //    break;

                    case "clearbosque":
                        //subo buscando al padre
                        //VerificarUsuario(Request["grupo"], Request["email"], Request["clave"]);
                        grupo = app.getGrupo(Request["grupo"]);
                        if (grupo.padreNombre == "")
                        {
                            grupo.bosque = new Bosque(grupo);
                            ret          = grupo.bosque.toJson();
                        }
                        else
                        {
                            //pido al padre
                            ret = Tools.getHttp(grupo.padreURL + "/doMain.aspx?actn=clearBosque&grupo=" + grupo.padreNombre);
                        }

                        Response.Write(ret);
                        break;

                    case "getbosque":
                        //subo buscando al padre
                        //VerificarUsuario(Request["grupo"], Request["email"], Request["clave"]);
                        ret   = "";
                        grupo = app.getGrupo(Request["grupo"]);

                        if (grupo.padreNombre == "")
                        {
                            //yo soy la cabeza del bosque
                            try
                            {
                                if (grupo.bosque == null || DateTime.Now.Subtract(grupo.bosque.born).TotalHours >= 24)
                                {
                                    grupo.bosque = new Bosque(grupo);
                                }
                                ret = grupo.bosque.toJson();
                            }
                            catch (Exception ex)
                            {
                                throw new Exception("Comunidad [" + grupo.nombre + "]> " + ex.Message);
                            }
                        }
                        else
                        {
                            //pido al padre
                            try
                            {
                                ret = Tools.getHttp(grupo.padreURL + "/doMain.aspx?actn=getBosque&grupo=" + grupo.padreNombre);
                            }
                            catch (Exception ex)
                            {
                                throw new Exception("No se puede alcanzar la cabeza de la comunidad desde [" + grupo.nombre + "]> " + ex.Message);
                            }
                        }

                        Response.Write(ret);
                        break;

                    case "getnodo":
                        //devuelvo configuracion de hijos
                        try
                        {
                            grupo = app.getGrupo(Request["grupo"]);
                            Bosque.Nodo nodo = Bosque.crearNodo(grupo);
                            ret = Tools.toJson(nodo);
                        }
                        catch (Exception ex)
                        {
                            throw new Exception("getNodo(" + Request["grupo"] + ") > " + ex.Message);
                        }
                        Response.Write(ret);
                        break;

                    case "organizacion":
                        VerificarUsuario(Request["grupo"], Request["email"], Request["clave"]);
                        Response.Write(doOperativoAccion(Request["grupo"], Request["email"], Request["accion"], Request));
                        break;

                    case "getoperativo":
                        VerificarUsuario(Request["grupo"], Request["email"], Request["clave"]);
                        Response.Write(getOperativo(Request["grupo"]));
                        break;

                    case "newgrupo":
                        Grupo g = Grupo.newGrupo(Request["grupo"],
                                                 Request["organizacion"],
                                                 Request["nombreAdmin"],
                                                 Request["email"],
                                                 Request["clave"],
                                                 Request["idioma"],
                                                 Request.UrlReferrer.AbsoluteUri.Substring(0, Request.UrlReferrer.AbsoluteUri.LastIndexOf("/")));
                        lock (app.grupos)
                        {
                            app.grupos.Add(g);
                            //guardo a disco
                            app.saveGrupos();
                        }
                        Response.Write(Tools.tr("Grupo creado", g.idioma));
                        app.addLog("newGrupo", Request.UserHostAddress, Request["grupo"], Request["email"], "");
                        break;

                    case "actualizarusuario":
                        VerificarUsuario(Request["grupo"], Request["email"], Request["clave"]);
                        grupo = app.getGrupo(Request["grupo"]);
                        Usuario u2 = actualizarUsuario(Server.HtmlEncode(Request["nuevonombre"]), Request["nuevoemail"], Request["nuevaclave"], Request["grupo"],
                                                       Request["habilitado"] == "true",
                                                       Request["readOnly"] == "true",
                                                       Request["isAdmin"] == "true",
                                                       Request["isSecretaria"] == "true",
                                                       Request["isRepresentante"] == "true",
                                                       Request["isFacilitador"] == "true",
                                                       Request["funcion"],
                                                       null);
                        Response.Write(Tools.tr("Usuario [%1] actualizado", u2.email, grupo.idioma));
                        app.addLog("actualizarUsuario", Request.UserHostAddress, Request["grupo"], Request["email"], Request["nombre"]);
                        break;

                    case "removeusuario":
                        VerificarUsuario(Request["grupo"], Request["email"], Request["clave"]);
                        Usuario u3 = removeUsuario(Request["usuarioemail"], Request["grupo"]);
                        grupo = app.getGrupo(Request["grupo"]);
                        Response.Write(Tools.tr("Usuario [%1] borrado", u3.email, grupo.idioma));
                        break;

                    //case "getgrupos":
                    //    Response.Write(getGrupos());
                    //    break;

                    case "login":
                        Response.Write(doLogin(Request["email"], Request["clave"], Request["grupo"]));
                        break;

                    case "borraralertas":
                        VerificarUsuario(Request["grupo"], Request["email"], Request["clave"]);
                        grupo = app.getGrupo(Request["grupo"]);
                        lock (grupo)
                        {
                            Usuario u = grupo.getUsuario(Request["email"]);
                            u.alertas.Clear();
                        }
                        Response.End();     //no hay respuesta
                        break;

                    case "getgrupopersonal":
                        VerificarUsuario(Request["grupo"], Request["email"], Request["clave"]);
                        grupo = app.getGrupo(Request["grupo"]);
                        GrupoPersonal gp = null;
                        lock (grupo)
                        {
                            gp = grupo.getGrupoPersonal(Request["email"]);
                        }
                        Response.Write(Tools.toJson(gp));
                        break;

                    case "dictionary":
                        List <string> eskeys = new List <string>();;
                        foreach (string item in Tools.dictionary)
                        {
                            if (item.Split('|')[1] == "es")
                            {
                                eskeys.Add(item.Split('|')[0]);
                            }
                        }
                        eskeys.Sort();
                        ret  = "";
                        ret += dictionaryFill("es", eskeys);
                        ret += dictionaryFill("ct", eskeys);
                        ret += dictionaryFill("en", eskeys);
                        ret += dictionaryFill("fr", eskeys);
                        Response.Write(ret);
                        break;

                    default:
                        throw new appException("Peticion no reconocida");
                    }
                }
                else
                {
                    throw new appException("Peticion no reconocida");
                }
            }
            catch (appException ex)
            {
                Response.Write("Error=" + ex.Message);
            }
            catch (Exception ex)
            {
                string s = "Actn:" + actn.ToLower() + "<br>";
                s += "Message:" + ex.Message + "<br>";
                s += "REMOTE_ADDR:" + Request.ServerVariables["REMOTE_ADDR"] + "<br>";
                s += "Querystring:" + Request.QueryString.ToString() + "<br>";
                s += "Form:" + Request.Form.ToString() + "<br>";
                s += "Stack:" + ex.StackTrace;

                Response.Write("Error=" + ex.Message + " [" + Tools.errordebug + "]");
                app.addLog("server exception", "", "", "", s);
            }
            Response.End();
        }