예제 #1
0
        protected void Page_Load(object sender, EventArgs e)
        {
            string actn = Request["actn"];

            //verifico lista global de arboles
            if (Application["aplicacion"] == null)
            {
                Application.Lock();
                Application["aplicacion"] = new Aplicacion(Server, Request);
                Application.UnLock();
            }
            app = (Aplicacion)Application["aplicacion"];

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

            try
            {
                //limpio flores caducadas periodicamente
                verifyFloresCaducadas();

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

                if (actn != null)
                {
                    switch (actn.ToLower())
                    {
                        case "docomentar":
                            //devuelvo las propuestas de toda la rama
                            Response.Write(doComentar(int.Parse(Request["id"]), Request["grupo"], Request["email"], Request["comentario"]));
                            app.addLog("doComentar", Request.UserHostAddress, Request["grupo"], "", Request["comentario"]);
                            break;

                        //case "getpropuestasresaltadas":
                        //    //devuelvo las propuestas de toda la rama
                        //    Response.Write(getPropuestasResaltadas(int.Parse(Request["id"]), Request["grupo"]));
                        //    break;

                        //case "getpropuestas":
                        //    //devuelvo las propuestas de toda la rama
                        //    Response.Write(getPropuestas(int.Parse(Request["id"]), Request["grupo"]));
                        //    break;

                        case "htmldocumento":
                            //devuelvo las propuestas de toda la rama
                            Response.Write(HTMLDocumento(int.Parse(Request["id"]), Request["modelo"], Request["grupo"], Request["email"], int.Parse(Request["width"])));
                            break;

                        case "htmlpropuesta":
                            //devuelvo las propuestas de toda la rama
                            Response.Write(HTMLPropuesta(int.Parse(Request["id"]), Request["grupo"], Request["email"], int.Parse(Request["width"])));
                            break;

                        case "getarbolpersonal":
                            grupo = app.getGrupo(Request["grupo"]);
                            lock (grupo)
                            {
                                //devuelvo el arbolPersonal
                                grupo.ts = DateTime.Now;
                                ret = Tools.toJson(grupo.arbol.getArbolPersonal(Request["email"]));
                            }
                            Response.Write(ret);
                            break;

                        case "variante":
                            Response.Write(doVariante(int.Parse(Request["id"]), Request["grupo"], Request["email"], int.Parse(Request["width"])));
                            break;

                        case "prevista":
                            Response.Write(doPrevista(int.Parse(Request["id"]), Request["modelo"], Request["grupo"], Request["email"], int.Parse(Request["width"]), Request));
                            break;

                        case "revisar":
                            Response.Write(doRevisar(int.Parse(Request["id"]), Request["modelo"], Request["grupo"], Request["email"], int.Parse(Request["width"])));
                            break;

                        case "proponer":
                            Response.Write(doProponer(int.Parse(Request["id"]), Request["modelo"], Request["grupo"], Request["email"]));
                            app.addLog("proponer", Request.UserHostAddress, Request["grupo"], Request["email"], "Nueva propuesta recibida");
                            break;

                        case "seguimiento":
                            Response.Write(doSeguimiento(int.Parse(Request["docID"]), Request["grupo"], int.Parse(Request["width"])));
                            break;

                        case "toggleflor":
                            Response.Write(doToggleFlor(Request["email"], int.Parse(Request["id"]), float.Parse(Request["x"]), Request["grupo"]));
                            app.addLog("toggleFlor", Request.UserHostAddress, Request["grupo"], Request["email"], "Cambio de voto");
                            break;

                        case "updatearbol":
                            a = updateArbol(Request["grupo"], int.Parse(Request["cantidadFlores"]), float.Parse(Request["minSiPc"]), float.Parse(Request["maxNoPc"]));
                            Response.Write("Arbol actualizado");
                            break;

                        //case "download":
                        //    Response.ContentType = "application/force-download";
                        //    grupo = app.getGrupo(Request["grupo"]);
                        //    a = grupo.arbol;
                        //    lock (a)
                        //    {
                        //        Nodo n = a.getNodo(int.Parse(Request["id"]));
                        //        Response.AddHeader("Content-Disposition", "Attachment;filename=" + a.nombre + "_" + n.nombre + ".txt");
                        //    }
                        //    Response.Write(download(int.Parse(Request["id"]), Request["grupo"]));
                        //    app.addLog("download", Request.UserHostAddress, Request["grupo"], "", "nodo=" + Request["id"]);
                        //    break;

                        case "simulacionlive":
                            string separador = (0.0f).ToString("0.0").Substring(1,1);
                            float coopProb = float.Parse(Request["coopProb"].Replace(".",separador));
                            string x = Request["x"];

                            //guardo las coordenadas x
                            if (x != "")
                            {
                                grupo = app.getGrupo(Request["grupo"]);
                                lock (grupo)
                                {
                                    a = grupo.arbol;
                                    foreach (string s in x.Split(','))
                                    {
                                        Nodo n = a.getNodo(int.Parse(s.Split('=')[0]));
                                        n.x = float.Parse(s.Split('=')[1]);
                                    }
                                }
                            }

                            //live
                            bool consensoAlcanzado = false;
                            grupo = app.getGrupo(Request["grupo"]);
                            lock (grupo)
                            {
                                for (int pasos = 0; pasos < 10 && !consensoAlcanzado; pasos++)
                                    consensoAlcanzado = consensoAlcanzado || doSimulacionLive(grupo, coopProb);
                            }
                            Response.Write("{\"stop\": " + (consensoAlcanzado ? "true" : "false") + ", \"arbolPersonal\":" + Tools.toJson(grupo.arbol.getArbolPersonal("Prueba")) + "}");
                            break;

                        case "crearsimulacion":
                            Grupo g = new Grupo();
                            g.nombre = getSimName();
                            g.path = Server.MapPath("grupos/" + g.nombre);
                            g.URL = Request.UrlReferrer.AbsoluteUri.Substring(0, Request.UrlReferrer.AbsoluteUri.LastIndexOf("/"));
                            g.objetivo = "simulacion";

                            a = new Arbol();
                            a.nombre = g.nombre;
                            a.simulacion = true;
                            a.raiz = new Nodo();
                            a.raiz.nombre = "Sim";
                            a.grupo = g;
                            g.arbol = a;

                            lock (app.grupos)
                            {
                                app.grupos.Add(g);
                            }
                            a.minSiPc = 60;
                            a.maxNoPc = 50;

                            //usuario de prueba
                            Usuario u1 = new Usuario();
                            u1.nombre = "Prueba";
                            u1.email = "Prueba";
                            g.usuarios.Add(u1);
                            a.lastSimUsuario = u1;

                            //escribo respuesta
                            List<Type> tipos = new List<Type>();
                            foreach (Modelo m in Modelo.getModelos())
                            {
                                tipos.Add(m.GetType());
                            }
                            Response.Write("{\"arbolPersonal\": " + Tools.toJson(a.getArbolPersonal("Prueba")) + ",\"modelos\":" + Tools.toJson(a.modelos, tipos) + "}");
                            app.addLog("crearSimulacion", Request.UserHostAddress, "", "", "Simulacion creada");
                            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);
                app.addLog("server exception", "", "", "", s);
            }
            Response.End();
        }
예제 #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();

                //limpio flores caducadas periodicamente de todos los usuarios
                //verifyFloresCaducadas(); se verifica al crear al arbol personal

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

                if (actn != null)
                {
                    switch (actn.ToLower())
                    {
                    case "docomentar":
                        //devuelvo las propuestas de toda la rama
                        VerificarUsuario(Request["grupo"], Request["email"], Request["clave"]);
                        Response.Write(doComentar(int.Parse(Request["id"]), Request["grupo"], Request["email"], Request["comentario"], Request["objecion"] == "true"));
                        app.addLog("doComentar", Request.UserHostAddress, Request["grupo"], "", Request["comentario"]);
                        break;

                    //case "crearacta":
                    //    //devuelvo las propuestas de toda la rama
                    //    VerificarUsuario(Request["grupo"], Request["email"], Request["clave"]);
                    //    Response.Write(crearActa(Request["grupo"], Request["email"], Request));
                    //    break;

                    case "htmldocumento":
                        //devuelvo las propuestas de toda la rama
                        VerificarUsuario(Request["grupo"], Request["email"], Request["clave"]);
                        Response.Write(HTMLDocumento(int.Parse(Request["id"]), Request["modelo"], Request["grupo"], Request["email"], int.Parse(Request["width"])));
                        break;

                    case "htmlpropuesta":
                        //devuelvo las propuestas de toda la rama
                        VerificarUsuario(Request["grupo"], Request["email"], Request["clave"]);
                        Response.Write(HTMLPropuesta(int.Parse(Request["id"]), Request["grupo"], Request["email"], int.Parse(Request["width"])));
                        break;

                    case "getarbolpersonal":
                        VerificarUsuario(Request["grupo"], Request["email"], Request["clave"]);
                        grupo = app.getGrupo(Request["grupo"]);
                        lock (grupo)
                        {
                            //devuelvo el arbolPersonal
                            grupo.ts = DateTime.Now;
                            ret      = Tools.toJson(grupo.arbol.getArbolPersonal(Request["email"]));
                        }
                        Response.Write(ret);
                        break;

                    case "variante":
                        VerificarUsuario(Request["grupo"], Request["email"], Request["clave"]);
                        Response.Write(doVariante(int.Parse(Request["id"]), Request["modeloID"], Request["grupo"], Request["email"], int.Parse(Request["width"])));
                        break;

                    case "prevista":
                        VerificarUsuario(Request["grupo"], Request["email"], Request["clave"]);
                        Response.Write(doPrevista(int.Parse(Request["id"]), Request["modelo"], Request["grupo"], Request["email"], int.Parse(Request["width"]), Request));
                        break;

                    case "revisar":
                        VerificarUsuario(Request["grupo"], Request["email"], Request["clave"]);
                        Response.Write(doRevisar(int.Parse(Request["id"]), Request["modelo"], Request["grupo"], Request["email"], int.Parse(Request["width"])));
                        break;

                    case "proponer":
                        VerificarUsuario(Request["grupo"], Request["email"], Request["clave"]);
                        Response.Write(doProponer(int.Parse(Request["id"]), Request["modelo"], Request["grupo"], Request["email"]));
                        app.addLog("proponer", Request.UserHostAddress, Request["grupo"], Request["email"], "Nueva propuesta recibida");
                        break;

                    case "seguimiento":
                        VerificarUsuario(Request["grupo"], Request["email"], Request["clave"]);
                        Response.Write(doSeguimiento(int.Parse(Request["docID"]), Request["grupo"], int.Parse(Request["width"])));
                        break;

                    case "toggleflor":
                        VerificarUsuario(Request["grupo"], Request["email"], Request["clave"]);
                        Response.Write(doToggleFlor(Request["email"], int.Parse(Request["id"]), float.Parse(Request["x"]), Request["grupo"]));
                        app.addLog("toggleFlor", Request.UserHostAddress, Request["grupo"], Request["email"], "Cambio de voto");
                        break;

                    case "updatearbol":
                        VerificarUsuario(Request["grupo"], Request["email"], Request["clave"]);
                        a = updateArbol(Request["grupo"], int.Parse(Request["cantidadFlores"]), float.Parse(Request["minSiPc"]), float.Parse(Request["maxNoPc"]), Request["padreURL"], Request["padreNombre"], Request["idioma"]);
                        Response.Write("Arbol actualizado");
                        break;

                    case "documentsubmit":
                        VerificarUsuario(Request["grupo"], Request["email"], Request["clave"]);
                        Response.Write(doDocumentSubmit(Request["accion"], Request["parametro"], Request["grupo"], Request["email"], Request["modelo"], int.Parse(Request["id"]), int.Parse(Request["width"]), Request));
                        break;

                    case "crearsimulacion":
                        //creo grupo
                        Grupo g = new Grupo();
                        g.nombre   = getSimName();
                        g.path     = Server.MapPath("grupos/" + g.nombre);
                        g.URL      = Request.UrlReferrer.AbsoluteUri.Substring(0, Request.UrlReferrer.AbsoluteUri.LastIndexOf("/"));
                        g.objetivo = "simulacion";

                        //organizacion
                        g.organizacion = new nabu.organizaciones.Plataforma();

                        //arbol
                        a             = new Arbol();
                        a.nombre      = g.nombre;
                        a.simulacion  = true;
                        a.raiz        = new Nodo();
                        a.raiz.nombre = "Sim";
                        a.grupo       = g;
                        g.arbol       = a;

                        a.minSiPc = 100;
                        a.maxNoPc = 0;

                        //usuarios de prueba
                        for (int i = 0; i < 50; i++)
                        {
                            Usuario u = new Usuario();
                            u.nombre = "u" + i;
                            u.email  = "u" + i;
                            for (int q = 0; q < 5; q++)
                            {
                                u.flores.Add(new Flor());
                            }
                            g.usuarios.Add(u);
                        }

                        //escribo respuesta
                        List <Type> tipos = new List <Type>();
                        foreach (Modelo m in g.organizacion.getModelosDocumento())
                        {
                            tipos.Add(m.GetType());
                        }
                        foreach (ModeloEvaluacion m in g.organizacion.getModelosEvaluacion())
                        {
                            tipos.Add(m.GetType());
                        }
                        ret  = "{\"arbolPersonal\": " + Tools.toJson(a.getArbolPersonal("u1")) + ",";
                        ret += "\"modelos\":" + Tools.toJson(g.organizacion.getModelosDocumento(), tipos) + ",";
                        ret += "\"modelosEvaluacion\":" + Tools.toJson(g.organizacion.getModelosEvaluacion(), tipos) + "}";
                        lock (app.grupos)
                        {
                            app.grupos.Add(g);
                        }
                        Response.Write(ret);
                        app.addLog("crearSimulacion", Request.UserHostAddress, "", "", "Simulacion creada");
                        break;

                    case "simulacionnuevodebate":
                        grupo = app.getGrupo(Request["grupo"]);
                        lock (grupo)
                        {
                            Usuario u = null;
                            //busco un usuario con flores
                            foreach (Usuario u2 in grupo.usuarios)
                            {
                                if (u2.floresDisponibles().Count > 0)
                                {
                                    u = u2;
                                    break;
                                }
                            }

                            //agergo nodos iniciales
                            if (u != null)
                            {
                                //el nombre de este nodo es la cantidad de dias
                                Nodo NuevoTema = simAgregarNodo(grupo, u, grupo.arbol.raiz, 0);     //introduccion al debate
                                //el nombre de este nodo es la generacion
                                Nodo n1 = simAgregarNodo(grupo, u, NuevoTema, 1);
                            }
                            ret = "{\"stop\": false, \"arbolPersonal\":" + Tools.toJson(grupo.arbol.getArbolPersonal("u1")) + "}";
                        }
                        Response.Write(ret);
                        break;

                    case "simulacionlive":
                        string x = Request["x"];

                        grupo = app.getGrupo(Request["grupo"]);
                        lock (grupo)
                        {
                            //guardo x
                            //&x=38=43,42=111,43=146
                            if (x != "")
                            {
                                a = grupo.arbol;
                                foreach (string s in x.Split(','))
                                {
                                    Nodo n = a.getNodo(int.Parse(s.Split('=')[0]));
                                    if (n != null)
                                    {
                                        n.x = float.Parse(s.Split('=')[1]);
                                    }
                                }
                            }

                            //para cada debate live
                            int i = 0;
                            while (i < grupo.arbol.raiz.children.Count)
                            {
                                Nodo n    = grupo.arbol.raiz.children[i];
                                int  dias = int.Parse(n.nombre);
                                simDebateLive(grupo, n, dias);
                                n.nombre = (dias + 1).ToString();
                                i++;
                            }
                            ret = "{\"stop\": false, \"arbolPersonal\":" + Tools.toJson(grupo.arbol.getArbolPersonal("u1")) + "}";
                        }
                        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);
                app.addLog("server exception", "", "", "", s);
            }
            Response.End();
        }
예제 #3
0
        public int cleanTime = 20; //quito arbol de memoria si no se toca en 20 minutos

        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();

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

                if (actn != null)
                {
                    switch (actn.ToLower())
                    {
                    case "getquesopersonal":
                        VerificarUsuario(Request["grupo"], Request["email"], Request["clave"]);
                        grupo = app.getGrupo(Request["grupo"]);
                        lock (grupo)
                        {
                            //pruebas
                            //grupo.queso = new Queso();
                            //app.saveGrupos();

                            //devuelvo el queso
                            List <Type> tipos = new List <Type>();
                            foreach (Modelo m in grupo.organizacion.getModelosDocumento())
                            {
                                tipos.Add(m.GetType());
                            }
                            foreach (ModeloEvaluacion m in grupo.organizacion.getModelosEvaluacion())
                            {
                                tipos.Add(m.GetType());
                            }
                            ret = Tools.toJson(grupo.queso.getQuesoPersonal(Request["email"]), tipos);
                        }
                        Response.Write(ret);
                        app.addLog("getQuesoPersonal", Request.UserHostAddress, Request["grupo"], "", "");
                        break;

                    case "evaluartema":
                        //devuelvo las propuestas de toda la rama
                        VerificarUsuario(Request["grupo"], Request["email"], Request["clave"]);
                        Response.Write(doEvaluarTema(Request["idTema"], Request["grupo"], Request["email"], int.Parse(Request["width"])));
                        break;

                    case "getquesoresultado":
                        //devuelvo las propuestas de toda la rama
                        VerificarUsuario(Request["grupo"], Request["email"], Request["clave"]);
                        Response.Write(getQuesoResultado(Request["grupo"], int.Parse(Request["temaIndex"]), int.Parse(Request["preguntaIndex"])));
                        break;

                    case "htmlevaluacion":
                        //devuelvo las propuestas de toda la rama
                        VerificarUsuario(Request["grupo"], Request["email"], Request["clave"]);
                        Response.Write(HTMLEvaluacion(null, Request["modeloEvaluacion"], Request["grupo"], Request["email"], int.Parse(Request["width"])));
                        break;

                    case "prevista":
                        VerificarUsuario(Request["grupo"], Request["email"], Request["clave"]);
                        Response.Write(doPrevista(Request["modelo"], Request["grupo"], Request["email"], int.Parse(Request["width"]), Request));
                        break;

                    case "revisar":
                        VerificarUsuario(Request["grupo"], Request["email"], Request["clave"]);
                        Response.Write(doRevisar(Request["modelo"], Request["grupo"], Request["email"], int.Parse(Request["width"])));
                        break;

                    case "crearevaluacion":
                        VerificarUsuario(Request["grupo"], Request["email"], Request["clave"]);
                        Response.Write(doCrearEvaluacionUsuario(Request["modelo"], Request["grupo"], Request["email"], int.Parse(Request["width"])));
                        app.addLog("crearevaluacion", Request.UserHostAddress, Request["grupo"], Request["email"], "Nueva propuesta recibida");
                        break;

                    case "crearevaluacionalpadre":
                        Response.Write(crearEvaluacionAlPadre(Request["grupopadre"], Request["grupohijo"], Request["docnombre"], Request["doctitulo"], Request["docmodeloid"], Request.Files[0]));
                        app.addLog("crearevaluacion", Request.UserHostAddress, Request["grupo"], Request["email"], "Nueva propuesta recibida");
                        break;

                    case "crearevaluacionalhijo":
                        Response.Write(crearEvaluacionAlHijo(Request["grupopadre"], Request["grupohijo"], Request["docnombre"], Request["doctitulo"], Request["docmodeloid"], Request.Files[0]));
                        app.addLog("crearevaluacion", Request.UserHostAddress, Request["grupo"], Request["email"], "Nueva propuesta recibida");
                        break;

                    case "evaluacionsubmit":
                        VerificarUsuario(Request["grupo"], Request["email"], Request["clave"]);
                        Response.Write(doDocumentSubmit(Request["accion"], Request["parametro"], Request["grupo"], Request["email"], Request["modelo"], int.Parse(Request["width"]), Request));
                        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);
                app.addLog("server exception", "", "", "", s);
            }
            Response.End();
        }
예제 #4
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();
        }