예제 #1
0
파일: Documento.cs 프로젝트: sabtvg/nabu
        public void save()
        {
            //guardo
            Grupo g = grupo;
            grupo = null; //referencia ciclica
            System.IO.StreamWriter fs = System.IO.File.CreateText(path);
            fs.Write(Tools.toJson(this));
            fs.Close();

            System.IO.File.WriteAllText(path, Tools.toJson(this));
            grupo = g;
        }
예제 #2
0
        string getResumen()
        {
            string ret = "<table style='font-size:16px;'>";

            ret += "<td style='text-align:center'><b>Grupo</b></td>";
            ret += "<td style='text-align:center'><b>Admin</b></td>";
            ret += "<td style='text-align:center'><b>Dias</b></td>";
            ret += "<td style='text-align:center'><b>Usuarios</b></td>";
            ret += "<td style='text-align:center'><b>Activos</b></td>";
            ret += "<td style='text-align:center'><b>Decisiones</b></td>";
            ret += "<td style='text-align:center'><b>Nodos</b></td>";
            ret += "<td style='text-align:center'><b>Last Login Dias</b></td>";
            foreach (string grupo in getGrupos())
            {
                try
                {
                    Grupo g = app.loadGrupo(grupo);
                    ret += "<tr>";
                    ret += "<td><b>" + g.nombre + "</b></td>";
                    ret += "<td>" + g.getAdmin().nombre + " " + g.getAdmin().email + "</td>";
                    ret += tdSize((int)DateTime.Now.Subtract(g.born).TotalDays);
                    ret += tdSize(g.usuarios.Count);
                    ret += tdSize(g.activos);
                    ret += tdSize(g.logDecisiones.Count);
                    ret += tdSize(g.arbol.toList().Count);
                    ret += tdSize((int)DateTime.Now.Subtract(g.lastLogin).TotalDays);
                    ret += "</tr>";
                }
                catch (Exception ex)
                {
                    ret += "<tr>";
                    ret += "<td><b>" + grupo + "</b></td>";
                    ret += "<td colspan=6 style='color:red;'>" + ex.Message + "</td>";
                    ret += "</tr>";
                }
            }
            return(ret + "</table>");
        }
예제 #3
0
        Usuario removeUsuario(string email, string grupo)
        {
            Grupo g = app.getGrupo(grupo);

            if (g == null)
            {
                throw new appException("El grupo no existe");
            }
            else
            {
                Usuario u;
                lock (g)
                {
                    g.ts = DateTime.Now;
                    u    = g.removeUsuario(email);
                }

                //guardo a disco
                app.saveGrupos();

                return(u);
            }
        }
예제 #4
0
        string doPrevista(string modeloID, string grupo, string email, int width, HttpRequest req)
        {
            string           ret = "";
            Grupo            g   = app.getGrupo(grupo);
            ModeloEvaluacion m   = g.organizacion.getModeloEvaluacion(modeloID);

            lock (g)
            {
                Propuesta prop = prepararDocumento(g, email, modeloID, req);

                //genro prevista para segurarme que defina etiqueta y titulo
                ret = m.toHTML(prop, g, email, width, ModeloEvaluacion.eModo.prevista);

                //guarpo prevista para poder crearla luego
                Usuario  u    = g.getUsuarioHabilitado(email);
                Prevista prev = new Prevista();
                prev.titulo = m.titulo;
                prev.propuestas.Clear();
                prev.propuestas.Add(prop);
                u.prevista = prev;
            }
            return(ret);
        }
예제 #5
0
        string HTMLDocumento(int id, string modeloID, string grupo, string email, int width)
        {
            string           ret = "";
            List <Propuesta> l   = new List <Propuesta>();
            Grupo            g   = app.getGrupo(grupo);

            lock (g)
            {
                Arbol a = g.arbol;
                g.ts = DateTime.Now;
                foreach (Nodo n in a.getPath(id))
                {
                    Propuesta op = a.getPropuesta(n); //comparo textox con hermanos y resalto palarbas nuevas
                    if (op != null)
                    {
                        l.Add(op);
                    }
                }
                Modelo m = g.organizacion.getModeloDocumento(modeloID);
                ret = m.toHTML(l, g, email, width, Modelo.eModo.editar); //las propuesta debe ir en orden de nivel
            }
            return(ret);
        }
예제 #6
0
        string doRevisar(int id, string modeloID, string grupo, string email, int width)
        {
            string           ret   = "";
            List <Propuesta> props = new List <Propuesta>();
            Grupo            g     = app.getGrupo(grupo);
            Modelo           m     = g.organizacion.getModeloDocumento(modeloID);

            lock (g)
            {
                //preparo propuestas de nodos ancestros
                Arbol       a    = g.arbol;
                List <Nodo> path = a.getPath(id);
                g.ts = DateTime.Now;
                foreach (Nodo n in path)
                {
                    Propuesta op = a.getPropuesta(n); //comparo textox con hermanos y resalto palarbas nuevas
                    if (n.nivel > 0 && op != null)
                    {
                        props.Add(op);
                    }
                }

                //agrego las propuestas de prevista
                Usuario u = g.getUsuario(email);
                if (u.prevista != null)
                {
                    foreach (Propuesta p in u.prevista.propuestas)
                    {
                        props.Add(p);
                    }
                }

                //genro revision
                ret = m.toHTML(props, g, email, width, Modelo.eModo.revisar); //las propuesta debe ir en orden de nivel
            }
            return(ret);
        }
예제 #7
0
파일: Modelo.cs 프로젝트: ogvilla/nabu
        protected virtual string HTMLEncabezado(Propuesta prop, Grupo g, string email, int width)
        {
            string  ret         = "";
            Usuario u           = g.getUsuarioHabilitado(email);
            bool    tieneFlores = false;

            if (u != null)
            {
                tieneFlores = u.floresDisponibles().Count > 0;
            }

            titulo   = getText("s.titulo", prop);
            etiqueta = getText("s.etiqueta", prop);

            //titulo
            ret += "<div class='titulo1'><nobr>" + nombre + "</nobr></div><br><br>";

            ret += "<div class='titulo3'><nobr>" + Tools.tr("Titulo", g.idioma) + ":" + HTMLText("s.titulo", prop, 60 * 8, tieneFlores, g.idioma) + "</nobr></div>";

            //etiqueta
            ret += "<div class='titulo3'><nobr>" + Tools.tr("Etiqueta", g.idioma) + ":" + HTMLText("s.etiqueta", prop, 20 * 5, tieneFlores, g.idioma);
            if (prop == null)
            {
                ret += "<span style='color:gray;font-size:12px;'>" + Tools.tr("(Etiqueta en el arbol)", g.idioma) + "</span>";
            }
            ret += "</nobr></div>";

            //fecha
            if (modo == eModo.consenso)
            {
                ret += "<div class='titulo2'><nobr>" + Tools.tr("Fecha", g.idioma) + ":" + DateTime.Now.ToString("dd/MM/yy") + " " + DateTime.Now.ToShortTimeString() + "</nobr></div>";
            }

            ret += "<br>";
            ret += "<br>";
            return(ret);
        }
예제 #8
0
        public void simDebateLive(Grupo g, Nodo tema, float dias)
        {
            int cantDiscrepar = 0;

            for (int iu = 0; iu < g.usuarios.Count; iu++)
            {
                //limpio consensos
                Usuario u = g.usuarios[iu];
                foreach (Flor f in u.flores)
                {
                    if (f.id != 0)
                    {
                        Nodo n = g.arbol.getNodo(f.id);
                        if (n == null)
                        {
                            f.id = 0;
                        }
                        else if (n.consensoAlcanzado)
                        {
                            g.arbol.quitarFlor(n, u);
                        }
                    }
                }

                //actuo
                if (simHoyConsiente(dias / 30))
                {
                    simConsentir(g, u, tema);
                }
                else
                if (cantDiscrepar < 30)      //evito que discrepen todos de golpe al principio
                {
                    simDiscrepar(g, u, tema);
                    cantDiscrepar++;
                }
            }
        }
예제 #9
0
        public Nodo simAgregarNodo(Grupo g, Usuario u, Nodo selected, int generacion)
        {
            //agrego nodo
            //creo texto segun nivel y modelo de documento
            Modelo    m    = g.organizacion.getModeloDocumento("nabu.plataforma.modelos.Accion"); //modelo de simulacion (Accion)
            Propuesta prop = new Propuesta();

            prop.email    = u.email;
            prop.modeloID = m.id;
            prop.nivel    = selected.nivel + 1; //esta propuesta es para el hijo que voy a crear
            prop.nodoID   = selected.id;
            prop.niveles  = 5;
            prop.titulo   = Tools.tr("Documento simulado", g.idioma);
            prop.etiqueta = generacion.ToString();

            //lleno datos de prueba
            foreach (Variable v in m.getVariables())
            {
                if (v.id == "s.etiqueta")
                {
                    prop.bag.Add("s.etiqueta", "Sim");
                }
                else if (v.id == "s.titulo")
                {
                    prop.bag.Add("s.titulo", Tools.tr("Documento simulado", g.idioma));
                }
                else
                {
                    prop.bag.Add(v.id, Tools.tr("Simulacion", g.idioma));
                }
            }

            Nodo nuevoNodo = g.arbol.addNodo(selected, prop);

            return(nuevoNodo);
        }
예제 #10
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();
        }
예제 #11
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);
        }
예제 #12
0
 public abstract string doAccion(Grupo g, string email, string accion, HttpRequest req);
예제 #13
0
파일: Modelo.cs 프로젝트: sabtvg/nabu
 protected abstract string toHTMLContenido(int nivel, Propuesta prop, Grupo g, string email, int width);
예제 #14
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();
        }
예제 #15
0
파일: Modelo.cs 프로젝트: sabtvg/nabu
        public string toHTMLComentarios(int nivel, Propuesta prop, Grupo g, string email, int width, bool agregar)
        {
            string ret = "";
            if (prop != null)
            {
                foreach (Comentario c in prop.comentarios)
                {
                    ret += "<div class='comentario' style='overflow: auto;width:" + (width - 15) + "px'>";
                    ret += toHTML(c.texto);
                    ret += "</div>";
                    //fecha
                    ret += "<div style='text-align:right;color:gray;font-size:10px;width:" + (width - 10) + "px'>";
                    ret += c.fecha.ToShortDateString();
                    ret += "</div>";
                }

                //agregar
                if (agregar && !prop.esPrevista())
                {
                    ret += "<textarea id='comentario" + prop.nodoID + "' maxlength='200' class='editar' style='width: " + (width - 15) + "px; height: 70px;'>";
                    ret += "</textarea><br>";
                    ret += "<input type='button' class='btn2' value='" + tr("Enviar") + "' onclick='doComentar(" + prop.nodoID + ");'>";
                    ret += "&nbsp;<font size='1'>(max: 200)</font>";
                }
            }

            return ret;
        }
예제 #16
0
파일: Modelo.cs 프로젝트: sabtvg/nabu
        public string toHTML(List<Propuesta> props, Grupo g, string email, int width, eModo modo)
        {
            string ret = "";
            this.modo = modo;
            this.grupo = g;

            //reinicio el modelo
            errores.Clear();
            crearVariables();
            consensoAlcanzado = false;

            bool tieneFlores = false;
            Usuario u = g.getUsuario(email);
            if (u != null) tieneFlores = u.floresDisponibles().Count > 0;

            //ordeno las propuestas por nivel
            props.Sort();

            if (modo == eModo.consenso)
            {
                //header HTML
                ret += "<html>";
                ret += "<head>";
                ret += "<title></title>";
                ret += "<meta http-equiv='Content-Type' content='text/html; charset=ISO-8859-1' />";
                ret += "<link rel='stylesheet' type='text/css' href='styles.css'>";
                ret += "</head>";
                ret += "<body>";
            }

            //todo el documento
            for (int q = 1; q <= niveles; q++)
            {
                Propuesta prop = getProp(q, props);
                bool editar = (prop == null && tieneFlores && modo != eModo.prevista && modo != eModo.consenso)
                    || (prop != null && prop.esPrevista() && (modo == eModo.revisar || modo == eModo.editar));

                if (prop != null && prop.consensoAlcanzado) consensoAlcanzado = true;

                //veo si falta la propuesta anterior (se ha saltado una)
                if (prop != null && q > 1 && getProp(q - 1, props) == null)
                {
                    //se ha saltado una propuesta
                    addError(q, "Las propuestas deben completarse por niveles correlativos, te has saltado el nivel anterior."); //esto evita que pueda proponer
                }

                ret += "<table style='width: " + (width - 10) + "px;'>";
                //mensaje de nivel
                if (q > 1 && modo != eModo.consenso)
                {
                    ret += "<tr>";
                    ret += "<td><hr></td>";
                    ret += "<td><span style='color:gray;font-size:10px;'>" + tr("Nivel en el arbol:") + " " + q + "</span></td>";
                    ret += "</tr>";
                }

                ret += "<tr>";
                //contenido de la propuesta
                int contenidoWidth = modo == eModo.consenso ? width : width - 340;
                ret += "<td ";
                ret += "style='width: " + contenidoWidth + "px;vertical-align:top;' ";
                if (editar && !consensoAlcanzado)
                    ret += "class='editar'";
                ret += ">";
                ret += toHTMLContenido(q, prop, g, email, contenidoWidth);
                ret += "    </td>";

                //comentarios
                if (modo != eModo.consenso)
                {
                    if (prop != null && !prop.esPrevista())
                    {
                        //se puede comentar
                        ret += "<td id='comentarios" + prop.nodoID + "' style='width: " + 250 + "px;vertical-align:top;' class='comentarios'>";
                        ret += toHTMLComentarios(q, prop, g, email, 246, !consensoAlcanzado);
                        ret += "</td>";
                    }
                    else
                    {
                        ret += "<td style='width: " + (250) + "px;vertical-align:top;' >";
                        ret += "</td>";
                    }
                }
                ret += "</tr>";
                ret += "</table>";
            }

            //botones de poantalla o firma de consenso
            ret += "<br>";
            if (modo == eModo.consenso)
            {
                //firma
                ret += firmaConsenso;
                ret += "</body>";
                firmaConsenso = ""; //por las dudas
            }
            else if (modo == eModo.editar)
            {
                //modo muestra
                if (consensoAlcanzado)
                    ret += "<div class='comentario'><b>" + tr("Consenso alcanzado") + "</b></div><br>";

                ret += "<input type='button' class='btn' value='" + tr("Cerrar") + "' onclick='doCerrarDocumento();' />";

                if (tieneFlores && !consensoAlcanzado)
                    ret += "<input type='button' class='btn' value='" + tr("Prevista de propuesta") + "' title='" + tr("Enseña vista previa antes de proponer") + "' onclick='doPrevista();' />";

            }
            else if (modo == eModo.prevista)
            {
                ret += "<input type='button' class='btn' value='" + tr("Cancelar") + "' onclick='doCerrarDocumento();' />";
                ret += "<input type='button' class='btn' value='" + tr("Revisar propuesta") + "' title='" + tr("Permite corregir errores") + "' onclick='doRevisar();' />";
                if (!hayError() && props[props.Count - 1].esPrevista())
                    //permito crear
                    //tiene que haber almenos una propuesa nueva para poder crear algo
                    ret += "<input type='button' class='btn' value='" + tr("Crear propuesta") + "' title='" + tr("Crea la propuesta") + "' onclick='doProponer();' />";
            }
            else if (modo == eModo.revisar)
            {
                //permito prevista
                ret += "<input type='button' class='btn' value='" + tr("Cancelar") + "' onclick='doCerrarDocumento();' />";
                if (tieneFlores && !consensoAlcanzado)
                    ret += "<input type='button' class='btn' value='" + tr("Prevista de propuesta") + "' title='" + tr("Enseña vista previa antes de proponer") + "' onclick='doPrevista();' />";
            }

            //ret += "<a id='btnDownload' href='' target='_blank'><font size='1'>Descargar esta versi&oacute;n</font></a>";
            return ret;
        }
예제 #17
0
파일: Modelo.cs 프로젝트: sabtvg/nabu
 public string toHTML(Propuesta prop, Grupo g, string email, int width, eModo modo)
 {
     string ret = "";
     this.modo = modo;
     this.grupo = g;
     ret += toHTMLContenido(prop.nivel, prop, g, email, width);
     ret += "<br>Comentarios:";
     ret += toHTMLComentarios(prop.nivel, prop, g, email, width - 30, false);
     return ret;
 }
예제 #18
0
        string crearEvaluacionAlPadre(string grupopadre, string grupohijo, string docnombre, string doctitulo, string docmodeloid, HttpPostedFile file)
        {
            //yo soy el padre
            string ret = "";
            Grupo  g   = app.getGrupo(grupopadre);

            lock (g)
            {
                //compruebo grupo hijo
                bool encontrado = false;
                foreach (Hijo h in g.hijos)
                {
                    if (h.nombre == grupohijo)
                    {
                        encontrado = true;
                    }
                }

                if (encontrado)
                {
                    //escribo documento recibido
                    int    docID   = g.queso.lastEvalID++;
                    string fname   = docmodeloid + "_" + docID.ToString("0000");
                    string docPath = "evaluaciones\\intergrupal\\" + grupohijo + "\\" + docID.ToString("0000");
                    string URL     = g.URL + "/grupos/" + g.nombre + "/" + docPath.Replace('\\', '/') + "/" + fname + ".html";

                    //creo carpeta se salida
                    if (!System.IO.Directory.Exists(g.path + "\\" + docPath))
                    {
                        System.IO.Directory.CreateDirectory(g.path + "\\" + docPath);
                        System.IO.Directory.CreateDirectory(g.path + "\\" + docPath + "\\res\\documentos");
                        System.IO.File.Copy(g.path + "\\..\\..\\styles.css", g.path + "\\" + docPath + "\\styles.css");
                        System.IO.DirectoryInfo di = new System.IO.DirectoryInfo(g.path + "\\..\\..\\res\\documentos");
                        foreach (System.IO.FileInfo fi in di.GetFiles())
                        {
                            System.IO.File.Copy(fi.FullName, g.path + "\\" + docPath + "\\res\\documentos\\" + fi.Name);
                        }
                    }
                    //guardo documento recibido
                    file.SaveAs(g.path + "\\" + docPath + "\\" + fname + ".html");

                    //creo modelos de evaluacion con datos identificatorios
                    ModeloEvaluacion m = g.organizacion.getModeloEvaluacion("nabu.plataforma.modelosEvaluacion.AlPadre");
                    m.evaluadoID = (g.queso.lastEvalID++).ToString();
                    m.temaNombre = grupohijo + ": " + doctitulo;
                    m.temaIcono  = "res/documentos/alpadre.png";
                    m.temaURL    = URL;
                    m.temaAutor  = grupohijo;

                    //creo evaluacion vacia para este documento nuevo
                    doCrearEvaluacion(m, g, "", null);

                    //alertas
                    foreach (Usuario u in g.getUsuariosHabilitados())
                    {
                        u.alertas.Add(new Alerta(Tools.tr("Nuevo documento intergrupal [%1]", doctitulo, g.idioma)));
                    }

                    ret = "ok";
                }
                else
                {
                    ret = "Hijo [" + grupohijo + "] no encontrado en [" + grupopadre + "]";
                }
            }

            //guardo
            //app.saveGrupos();

            return(ret);
        }
예제 #19
0
 public virtual void evaluacionSubmit(string accion, string parametro, Propuesta prop, Grupo g, string email)
 {
     //submit(accion, parametro, props, g, email, width, modo);
 }
예제 #20
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();
        }
예제 #21
0
 public abstract string getOperativo(Grupo g);
예제 #22
0
 protected abstract string toHTMLContenido(Propuesta prop, Grupo g, string email, int width);
예제 #23
0
파일: Modelo.cs 프로젝트: ogvilla/nabu
 public virtual string documentSubmit(string accion, string parametro, List <Propuesta> props, Grupo g, string email, int width, Modelo.eModo modo)
 {
     //submit(accion, parametro, props, g, email, width, modo);
     return(toHTML(props, g, email, width, modo));
 }
예제 #24
0
        public static Grupo newGrupo(string grupo, string organizacion, string nombreAdmin, string email, string clave, string idioma, string URL)
        {
            if (grupo == "")
            {
                throw new appException("Nombre de grupo no puede ser vacio");
            }
            if (email == "")
            {
                throw new appException("Email no puede ser vacio");
            }
            if (clave == "")
            {
                throw new appException("Clave no puede ser vacio");
            }
            if (Tools.HtmlEncode(grupo) != grupo)
            {
                throw new appException("Nombre de grupo inv&aacute;lido. Evite acentos y caracteres especiales");
            }
            if (Tools.HtmlEncode(email) != email)
            {
                throw new appException("Email inv&aacute;lido. Evite acentos y caracteres especiales");
            }
            if (Tools.HtmlEncode(clave) != clave)
            {
                throw new appException("Clave inv&aacute;lida. Evite acentos y caracteres especiales");
            }

            //veo que no exista ya
            System.IO.DirectoryInfo di = new System.IO.DirectoryInfo(Tools.MapPath("grupos"));

            foreach (System.IO.DirectoryInfo fi in di.GetDirectories())
            {
                if (fi.Name == grupo)
                {
                    //ya existe
                    throw new appException("El grupo ya existe");
                }
            }

            //creo
            Grupo g = new Grupo();

            g.nombre = grupo;
            g.path   = Tools.MapPath("grupos/" + g.nombre);
            g.URL    = URL;
            g.idioma = idioma;

            //organizacion
            switch (organizacion)
            {
            case "Plataforma":
                g.organizacion = new organizaciones.Plataforma();
                break;

            case "Cooperativa":
                g.organizacion = new organizaciones.Cooperativa();
                break;

            case "Colegio":
                g.organizacion = new organizaciones.Colegio();
                break;

            default:
                throw new Exception("Modelo organizativo [" + organizacion + "] no existe");
            }

            Arbol a = new Arbol();

            a.nombre      = grupo;
            a.raiz        = new Nodo();
            a.raiz.nombre = Tools.HtmlEncode(a.nombre);
            a.grupo       = g; //referencia ciclica, no se pude serializar
            g.arbol       = a;

            Queso q = new Queso();

            q.grupo = g; //referencia ciclica, no se pude serializar
            g.queso = q;

            //admin
            Usuario u = new Usuario(a.cantidadFlores);

            u.nombre  = Tools.HtmlEncode(nombreAdmin);
            u.email   = email;
            u.clave   = clave;
            u.isAdmin = true;
            g.usuarios.Add(u);

            return(g);
        }
예제 #25
0
파일: Modelo.cs 프로젝트: ogvilla/nabu
        protected string HTMLSeccion(string tituloid, string tipid, string id, bool editar, Propuesta prop, bool tieneFlores, Grupo g)
        {
            string ret;

            ret = "<div class='tema' style='vertical-align:top'><b>" + Tools.tr(tituloid, g.idioma) + "</b></div>";
            if (editar)
            {
                ret += "<div class='smalltip'>" + Tools.tr(tipid, g.idioma) + "</div>";
            }
            ret += "<div style='width:-webkit-fill-available'>" + HTMLArea(id, prop, 300, 120, tieneFlores, g.idioma) + "</div>";
            return(ret);
        }
예제 #26
0
        public int saveTime = 10; //guardar arboles cada x minutos

        #endregion Fields

        #region Methods

        //public string download(int id, string arbol)
        //{
        //    string ret = "";
        //    Grupo grupo = app.getGrupo(arbol);
        //    Arbol a = grupo.arbol;
        //    lock (a)
        //    {
        //        grupo.ts = DateTime.Now;
        //        List<Nodo> pathn = a.getPath(id);
        //        for(int i = pathn.Count - 1; i >=0 ; i--)
        //        {
        //            Nodo n = pathn[i];
        //            Propuesta op = a.getPropuesta(n.id);
        //            if (op != null)
        //            {
        //                if (ret == "")
        //                {
        //                    ModeloDocumento m = a.getModelo(op.modeloID);
        //                    ret += "Fecha: " + DateTime.Now.ToShortDateString() + " " + DateTime.Now.ToShortTimeString() + "\r\n";
        //                    ret += "Arbol: " + a.nombre + "\r\n";
        //                    ret += "Creado: " + a.born.ToShortDateString() + " " + a.born.ToShortTimeString() + "\r\n";
        //                    ret += "Objetivo: " + a.objetivo + "\r\n";
        //                    ret += "Consensos alcanzados: " + a.logDocumentos.Count + "\r\n";
        //                    ret += "Usuarios: " + a.usuarios.Count + "\r\n";
        //                    ret += "Admin: " + a.getAdmin().nombre + " (" + a.getAdmin().email + ")\r\n\r\n";
        //                    ret += "Modelo documento: " + m.nombre + "\r\n";
        //                    ret += "Titulo: " + op.titulo + "\r\n\r\n";
        //                }
        //                ret += "--------------------------------------------------------------- Nivel del arbol " + (pathn.Count - i - 1) + "\r\n";
        //                ret += "Fecha: " + op.ts.ToShortDateString() + " " + op.ts.ToShortTimeString() + "\r\n";
        //                foreach (TextoTema tt in op.textos)
        //                {
        //                    ret += "Titulo: " + tt.titulo + "\r\n";
        //                    ret += tt.texto.Replace("\n", "\r\n").Replace("&quot;", "\"") + "\r\n\r\n";
        //                }
        //                ret += "\r\n";
        //                ret += "\r\n";
        //            }
        //        }
        //   }
        //    return ret;
        //}
        public bool doSimulacionLive(Grupo g, float coopProb)
        {
            bool ret = false;
            lock (g)
            {
                Arbol a = g.arbol;
                float action = coopProb + (float)a.rnd.NextDouble() - 0.5f;

                if (action > 3f/4f) {
                    //cooperacion, muevo un voto del menor al mayor
                    Nodo mayor = a.getMayorAgregar(0);
                    Nodo menor = a.getMenorQuitar(mayor.id);

                    if (mayor != menor && menor.flores > 0 && !mayor.consensoAlcanzado)
                    {
                        Usuario u = a.quitarFlor(menor);
                        try { a.asignarflor(u, mayor); } catch {}
                        if (mayor.consensoAlcanzado) ret = true;
                    }
                }
                else if (action > 2f/4f) {
                    //voto a minorias, muevo un voto del mayor al menor
                    var mayor = a.getMayorQuitar(0);
                    var menor = a.getMenorAgregar(mayor.id);

                    if (mayor != menor && mayor.flores > 0 && !menor.consensoAlcanzado)
                    {
                        Usuario u = a.quitarFlor(mayor);
                        try { a.asignarflor(u, menor); } catch {}
                        if (menor.consensoAlcanzado) ret = true;
                    }
                }
                else if (action > 1f / 4f)
                {
                    //quito alguna flor
                    var mayor = a.getMayorQuitar(0);
                    if (mayor.flores > 0)
                    {
                        a.quitarFlor(mayor);
                    }
                }
                else
                {
                    //creo una rama nueva
                    //seleccion nodo al azar
                    List<Nodo> nodes = a.toList();
                    Nodo selected = a.rndElement(nodes);

                    //agrego nuevo nodo
                    if (!selected.consensoAlcanzado && selected.nivel < 5)
                    {
                        //agrego nodo
                        //creo texto segun nivel y modelo de documento
                        Modelo m = Modelo.getModelo("nabu.modelos.Accion");  //modelo de simulacion (Accion)
                        Propuesta prop = new Propuesta();
                        prop.email = g.usuarios[0].email;
                        prop.modeloID = m.id;
                        prop.nivel = selected.nivel + 1;  //esta propuesta es para el hijo que voy a crear
                        prop.nodoID = selected.id;
                        prop.titulo = "Documento simulado";

                        //lleno datos de prueba
                        foreach (Variable v in m.getVariables())
                        {
                            if (v.id == "s.etiqueta")
                                prop.bag.Add("s.etiqueta", "Sim");
                            else if (v.id == "s.titulo")
                                prop.bag.Add("s.titulo", "Documento simulado");
                            else
                                prop.bag.Add(v.id, "Simulacion!!!");
                        }

                        //me aseguro que el usuario tenga flores o agrego otro
                        if (a.lastSimUsuario.flores.Count < 5)
                            a.lastSimUsuario.flores.Add(new Flor());
                        else
                        {
                            //busco un usuario con flores
                            a.lastSimUsuario = a.getUsuarioConFloresDisponibles();
                        }
                        if (a.lastSimUsuario == null)
                        {
                            Usuario u = new Usuario();
                            u.nombre = "Sim" + g.usuarios.Count + 1;
                            u.email = "Sim" + g.usuarios.Count + 1;
                            u.flores.Add(new Flor());
                            g.usuarios.Add(u);
                            a.lastSimUsuario = u;
                        }

                        prop.email = a.lastSimUsuario.email;
                        Nodo nuevo = a.addNodo(selected, prop);

                        if (selected.nivel == 1)
                        {
                            selected.nombre = "Sim" + selected.id;
                        }
                    }
                }
            }
            return ret;
        }
예제 #27
0
파일: Modelo.cs 프로젝트: ogvilla/nabu
        public string toHTML(List <Propuesta> props, Grupo g, string email, int width, eModo modo)
        {
            string ret = "";

            this.modo  = modo;
            this.grupo = g;

            //reinicio el modelo
            errores.Clear();
            consensoAlcanzado = false;

            bool    tieneFlores = false;
            Usuario u           = g.getUsuarioHabilitado(email);

            if (u != null)
            {
                tieneFlores = u.floresDisponibles().Count > 0;
            }

            //ordeno las propuestas por nivel
            props.Sort();

            if (modo == eModo.consenso)
            {
                //header HTML
                ret += "<html>";
                ret += "<head>";
                ret += "<title></title>";
                ret += "<meta http-equiv='Content-Type' content='text/html; charset=ISO-8859-1' />";
                ret += "<link rel='stylesheet' type='text/css' href='styles.css'>";
                ret += "</head>";
                ret += "<body>";
            }

            //todo el documento
            bool editar = false;

            for (int q = 1; q <= niveles; q++)
            {
                Propuesta prop = getProp(q, props);
                editar = (prop == null && tieneFlores && modo != eModo.prevista && modo != eModo.consenso) ||
                         (prop != null && prop.esPrevista() && (modo == eModo.revisar || modo == eModo.editar));

                if (prop != null && prop.consensoAlcanzado)
                {
                    consensoAlcanzado = true;
                }

                //veo si falta la propuesta anterior (se ha saltado una)
                if (prop != null && q > 1 && getProp(q - 1, props) == null)
                {
                    //se ha saltado una propuesta
                    addError(q, "Las propuestas deben completarse por niveles correlativos, te has saltado el nivel anterior."); //esto evita que pueda proponer
                }

                //mensaje de nivel
                if (q > 1 && modo != eModo.consenso)
                {
                    ret += "<div style='float:clear;float:left;color:gray;font-size:10px;width:-webkit-fill-available;border-top:1px solid gray;margin:3px;text-align:right;'>";
                    ret += Tools.tr("Nivel en el arbol", g.idioma) + ": " + q;
                    ret += "</div>";
                }


                //if (editar && !consensoAlcanzado)
                //    ret += "class='seccion'";
                //else
                //    ret += "class='seccion'";
                //contenido de la propuesta
                ret += "<div class='seccion'>";
                ret += toHTMLContenido(q, prop, g, email, 500);
                ret += "</div>";

                //comentarios
                if (modo != eModo.prevista && modo != eModo.consenso && prop != null && !prop.esPrevista() && !consensoAlcanzado)
                {
                    //se puede comentar
                    ret += "<div id='comentarios" + prop.nodoID + "' style='vertical-align:top;' class='comentarios'>";
                    ret += toHTMLComentarios(q, prop, g, email, 326, !consensoAlcanzado);
                    ret += "</div>";
                }
            }

            //botones de poantalla o firma de consenso
            ret += "<br>";
            ret += "<br>";

            if (modo == eModo.consenso)
            {
                //firma
                ret          += firmaConsenso;
                ret          += "</body>";
                firmaConsenso = ""; //por las dudas
            }
            else if (modo == eModo.editar)
            {
                //modo muestra
                if (consensoAlcanzado)
                {
                    ret += "<div class='mensaje' style='clear:left;float:left;width:100%'><b>" + Tools.tr("Consenso alcanzado", g.idioma) + "</b></div><br>";
                }

                ret += "<input type='button' style='clear:left;float:left;' class='btn' value='" + Tools.tr("Cerrar", g.idioma) + "' onclick='doCerrarDocumento();' />";

                if (tieneFlores && !consensoAlcanzado && editar)
                {
                    ret += "<input type='button' style='float:left;' class='btn' value='" + Tools.tr("Prevista de propuesta", g.idioma) + "' title='" + Tools.tr("Enseña vista previa antes de proponer", g.idioma) + "' onclick='doPrevista();' />";
                }
            }
            else if (modo == eModo.prevista)
            {
                ret += "<input type='button' style='clear:left;float:left;' class='btn' value='" + Tools.tr("Cancelar", g.idioma) + "' onclick='doCerrarDocumento();' />";
                ret += "<input type='button' style='float:left;' class='btn' value='" + Tools.tr("Revisar propuesta", g.idioma) + "' title='" + Tools.tr("Permite corregir errores", g.idioma) + "' onclick='doRevisar();' />";
                if (!hayError() && props.Count > 0 && props[props.Count - 1].esPrevista())
                {
                    //permito crear
                    //tiene que haber almenos una propuesa nueva para poder crear algo
                    ret += "<input type='button' style='float:left;' class='btn' value='" + Tools.tr("Crear propuesta", g.idioma) + "' title='" + Tools.tr("Crea la propuesta", g.idioma) + "' onclick='doProponer();' />";
                }
            }
            else if (modo == eModo.revisar)
            {
                //permito prevista
                ret += "<input type='button' style='clear:left;float:left;' class='btn' value='" + Tools.tr("Cancelar", g.idioma) + "' onclick='doCerrarDocumento();' />";
                if (tieneFlores && !consensoAlcanzado)
                {
                    ret += "<input type='button' style='float:left;' class='btn' value='" + Tools.tr("Prevista de propuesta", g.idioma) + "' title='" + Tools.tr("Enseña vista previa antes de proponer", g.idioma) + "' onclick='doPrevista();' />";
                }
            }

            //ret += "<a id='btnDownload' href='' target='_blank'><font size='1'>Descargar esta versi&oacute;n</font></a>";
            return(ret);
        }