Python WebTemplates.WebTemplates类代码示例

class WebLogout(Resource):
    def __init__(self):
        self.template = WebTemplates()
        Resource.__init__(self)

    def getChild(self, path, request):
        if path == "":
            return self
        else:
            return static.File.childNotFound

    def render_GET(self, request):
        session = request.getSession()
        _ = getTranslatorFromSession(request)

        if hasattr(session, 'username'):
            del(session.username)
            del(session.userId)
            del(session.kind)
            del(session.name)
            del(session.lastname)
            del(session.locale)
            request.write(self.template.startPage(session, _('Cerrar Sesion')))
            request.write('<div class="message"><h2>' +
                 _('La sesion ha sido cerrada') +
                 '</h2>' + _('Que tenga un buen dia.') + '</div>')
        else:
            request.write(self.template.startPage(session))
            request.write('<div class="warning"><h2>' +
                _('Sesion inexistente') + '</h2>' +
                _('Debe iniciar una sesion antes de cerrarla!') + '</div>')
        request.write(self.template.finishPage(session))
        del(session._)
        request.finish()
        return server.NOT_DONE_YET

class WebContent(Resource):

    def __init__(self):
        Resource.__init__(self)
        self.template = WebTemplates()
        self.pages = static.File('./htdocs/content/')

    def getChild(self, path, request):
        return self


    def render_GET(self, request):
        d = defer.maybeDeferred(getTranslatorFromSession, request)
        d.addCallback(self.writeContent, request)
        return server.NOT_DONE_YET

    def writeContent(self, trans, request):
        session = request.getSession()
        _ = trans
        request.write(self.template.startPage(session, \
            _('Beppo - Sistema de educacion a distancia')))
        page = self.pages.getChild(request.prepath[-1], request)
        if hasattr(page, 'getContent'):
            request.write(page.getContent())
        else:
            request.write(self.template.notFound(session))
        request.write(self.template.finishPage(session))
        request.finish()
        return

class WebSettings(Resource):
    _ = dummyTranslator
    def __init__(self):
        _ = dummyTranslator
        self.db = DBConnect()
        self.render_POST = self.render_GET
        self.template = WebTemplates()
        Resource.__init__(self)

    def getChild(self, path, request):
        if path == "":
            return self
        else:
            return static.File.childNotFound

    def render_GET(self, request):
        d = defer.maybeDeferred(getTranslatorFromSession, request)
        d.addCallback(self.doAuthentication, request)
        return server.NOT_DONE_YET

    def doAuthentication(self, trans, request):
        session = request.getSession()
        _ = trans
        d = defer.maybeDeferred(lambda: None)
        if not hasattr(session, 'username'):
            d.addCallback(lambda a: request.write(self.template.notAuthenticated(session)))
        elif session.kind == ADMIN:
            try:
                user_id = int(request.args.get('user_id', None)[0])
            except:
                user_id = session.userId
        else:
            user_id = session.userId
        message = False
        if "submit" in request.args.keys():
            try:
                time = int(request.args.get('fk_timezone')[0])
                lang = int(request.args.get('language')[0])
            except ValueError, TypeError:
                request.write(self.template.unexpectedArguments(session, \
                    _('Argumento no valido')))
            message = True
            query = "select * from language, timezone where \
                language.id = %d and timezone.id = %d"
            d.addCallback(lambda a: self.db.db.runQuery(query, (lang, time)))
            d.addCallback(self.updateDBAndSession, request, user_id)
        d.addCallback(self.printStartPage, request, message)
        d.addCallback(lambda a: self.printContent(request, user_id))
        # 4) Se termina la página
        d.addCallback(lambda a: request.write(self.template.finishPage(session)))
        d.addCallback(lambda a: request.finish())

        return d

class WebUserInfo(Resource):
    def __init__(self):
        self.db = DBConnect()
        self.template = WebTemplates()
        Resource.__init__(self)

    def getChild(self, path, request):
        if path == "":
            return self
        else:
            return static.File.childNotFound

    def render_GET(self, request):
        d = defer.maybeDeferred(getTranslatorFromSession, request)
        d.addCallback(self.doAuthentication, request)
        return server.NOT_DONE_YET

    def doAuthentication(self, trans, request):
        session = request.getSession()
        _ = trans
        info = WebGetUserInfo(self.db, session)
        # 0) Se empieza la página
        request.write(self.template.startPage(session, _('Informacion de usuario')))
        d = defer.maybeDeferred(lambda:None)
        # 1) Verificar que esté autenticado ante el sistema
        if not hasattr(session, 'username'):
            request.write(self.template.notAuthenticated(session))
        # 2) Si es Admin, puede ver todos los usuarios
        elif "user_id" in request.args.keys() and "kind" in request.args.keys():
            try:
                user_id = int(request.args['user_id'][0])
                kind = int(request.args['kind'][0])
                msg = '<h2>' + _('Informacion de usuario') + '</h2>'
                d.addCallback(lambda a: info.getUserInfo(user_id, kind))
            except ValueError:
                request.write(self.template.unexpectedArguments(session, \
                    _('Argumento no valido')))
                user_id = kind = msg = None
                d.addCallback(lambda a: None)
            d.addCallback(self.printContent, request, d, user_id, kind, session, msg)
        else:
            request.write(self.template.unexpectedArguments(session, \
                _('Falta algun argumento')))
        d.addCallback(lambda a: request.write(self.template.finishPage(session)))
        d.addCallback(lambda a: request.finish())
        return d


    def printContent(self, data, request, d, userId, kind, session, msg):
        d.addCallback(lambda a: request.write(msg))
        d.addCallback(lambda a: request.write(data))
        return

 def __init__(self, server):
     self.db = DBConnect
     self.rOpen = server.openRoomsAndLenQueues # clave room -> valor cant gente
     self.subjects = server.openRoomsAndSubjects # clave room -> valor lista materias
     self.sbOpen = server.shouldBeOpenAndClosedRooms
     self.template = WebTemplates()
     Resource.__init__(self)

 def __init__(self, server):
     Resource.__init__(self)
     self.db = DBConnect()
     self.template = WebTemplates()
     self.putChild("roominfo", WebRoomInfo(server))
     self.putChild("userinfo", WebUserInfo())
     self.putChild("login", WebLogin())
     self.putChild("logout", WebLogout())
     self.putChild("static",  static.File("./htdocs/"))
     self.putChild("board_archive", static.File("./archive/"))
     self.putChild("content", WebContent())
     self.putChild("calendar",  static.File("./calendar/"))
     self.putChild("subjects", WebSubjects())
     self.putChild("settings", WebSettings())
     self.putChild("subject_admin", WebSubjectAdmin())
     self.putChild("schedules", WebSchedules())
     self.putChild("admin", WebAdmin())
     self.putChild("archive", WebArchive())
     self.putChild("list", WebListUsers())
     self.putChild("tutor", WebTutor())
     self.putChild("tutor_info", WebTutorInfo())
     self.putChild("tutor_data", WebTutorData())
     self.putChild("tutor_sessions", WebTutorSessions())
     self.putChild("client", WebClient())
     self.putChild("report", WebClientReport())
     self.putChild("mail", WebSendMail())
     self.putChild("my_pupils", WebMyPupils())
     self.putChild("my_pupils_info", WebMyPupilsInfo())
     self.putChild("pupil_edit", WebPupilEdit())
     self.putChild("new_pupil", WebPupilInsert())
     self.putChild("pc_arrange", WebPCArrangeRoot())
     self.putChild("editadmin", WebEditAdmin())

 def __init__(self, table, title, kind, query, empty, xtra_fields):
     _ = dummyTranslator
     self.db = DBConnect()
     self.render_POST = self.render_GET
     self.template = WebTemplates()
     self.table = table
     self.title = title
     self.kind = kind
     
     self.query = query
     self.empty = empty
     self.fields = WebPerson.fields + xtra_fields
     Resource.__init__(self)

 def __init__(self):
     _ = dummyTranslator
     self.fields = [{'name': 'username', 'pos': 1, 'desc': _('Nombre de usuario'), \
         'required': True, 'type': 'text', 'maxlength': 80, 'query': "person"},
     {'name': 'password', 'pos': 2, 'desc': _('Contrasena'), 'required': False, \
         'type': 'password', 'maxlength': 80, 'query': "person"},
     {'name': 'password2', 'pos': 2, 'desc': _('Repita contrasena'), 'required': False, \
         'type': 'password', 'maxlength': 80, 'query': ""},
     {'name': 'first_name', 'pos': 3, 'desc': _('Nombre'), 'required': True, \
         'type': 'text', 'maxlength': 255, 'query': "person"},
     {'name': 'last_name', 'pos': 4, 'desc': _('Apellido'), 'required': True, \
         'type': 'text', 'maxlength': 255, 'query': "person"},
     {'name': 'email', 'pos': 5, 'desc': _('eMail'), 'required': True, \
         'type': 'text', 'maxlength': 255, 'query': "person"}]
     self.db = DBConnect()
     self.render_POST = self.render_GET
     self.template = WebTemplates()
     Resource.__init__(self)

class WebMyPupilsInfo(Resource):
    def __init__(self):
        self.db = DBConnect()
        self.template = WebTemplates()
        Resource.__init__(self)

    def getChild(self, path, request):
        if path == "":
            return self
        else:
            return static.File.childNotFound

    # Si estamos autenticados como admin, sirve para ver los alumnos de cualquier cliente
    # Si somos cliente, sólo podremos ver los propios
    def render_GET(self, request):
        d = defer.maybeDeferred(getTranslatorFromSession, request)
        d.addCallback(self.doAuthentication, request)
        return server.NOT_DONE_YET

        msg = """<h2>""" + _('Cuentas de alumnos') + """</h2>"""

    def doAuthentication(self, trans, request):
        session = request.getSession()
        _ = trans
        # 0) Se empieza la página
        request.write(self.template.startPage(session, \
         _('Informacion de cuentas de usuarios')))
        d = defer.maybeDeferred(lambda:None)
        # 1) Verificar que esté autenticado ante el sistema
        if not hasattr(session, 'username'):
            request.write(self.template.notAuthenticated(session))
        # 2) Si es Admin, administra todos los usuarios
        elif session.kind == ADMIN:
        # 2.1) Admin debe proveer el argumento user_id
            if "user_id" in request.args.keys():
                try:
                    user_id = int(request.args['user_id'][0])
                    d.addCallback(lambda a: self.requestData(user_id))
                    d.addCallback(self.printTitle, request)
                    self.printContent(request, d, user_id)
        # La función que procesa e imprime el contenido de la pagina
                except ValueError:
                    request.write(self.template.unexpectedArguments(session, \
                     _('user_id deberia ser entero')))
            else:
                request.write(self.template.unexpectedArguments(session, \
                 _('falta el parametro user_id')))
        # 3) Si es cliente, muestra la información de alumnos propios
        elif session.kind == CLIENT:
            user_id = session.userId
            d.addCallback(lambda a: self.requestData(user_id))
            d.addCallback(self.printTitle, request)
            self.printContent(request, d, user_id)
        else:
        # 4) Si no, es alguien que no está autorizado
            request.write(self.template.notAuthorized(session))
        # 5) Se termina la página
        d.addCallback(lambda a: request.write(self.template.finishPage(session)))
        d.addCallback(lambda a: request.finish())
        return d

    def requestData(self, user_id):
        query = "select p.first_name, p.last_name, c.organization from person p, \
                 client c where c.id = p.id and p.id = %s"
        d = self.db.db.runQuery(query, (user_id,))
        return d

    def printTitle(self, data, request):
        _ = request.getSession()._
        if len(data) != 1:
            msg = """<h2>""" + _('Cuentas de alumnos') + """</h2>"""
        else:
            client = "%s %s (%s)" % (data[0][0], data[0][1], data[0][2])
            msg = """<h2>""" + _('Cuentas de alumnos de %s') % client + """</h2>"""
        request.write(msg)



    def printContent(self, request, d, userId):
        # 1) Si se envían datos, se actualiza la base primero
        _ = request.getSession()._
        # 3) Se buscan los datos en la base
        query = "select username, password, first_name, last_name, email, \
          ai_available, pc_available, expires from pupil a, person p \
          where p.id = a.id and fk_client= %d"
        d.addCallback(lambda a: self.db.db.runQuery(query, (userId, )))
        # 4) Se imprime los datos
        d.addCallback(self.printForm, request, userId)
        return d


    def printForm(self, rows, request, userId):
        _ = request.getSession()._
        string = ""
        fields = [{'pos': 0, 'desc': _('Nombre de usuario')},
                  {'pos': 1, 'desc': _('Constrasena')},
                  {'pos': 2, 'desc': _('Nombre')},
                  {'pos': 3, 'desc': _('Apellido')},
                  {'pos': 4, 'desc': _('eMail')},
                  {'pos': 5, 'desc': _('Hs. AI restantes')},
#.........这里部分代码省略.........

class WebTutorInfo(Resource):
    _ = dummyTranslator
    MAX_TYPE = POST_PROCESS + 1
    session_types = [{'code': IACLASS, 'desc': _('A.I.'), 'arr': 0},
    {'code': PACLASS, 'desc': _('C.P.'), 'arr': 1},
    {'code': EXTRA_IACLASS, 'desc': _('Sin turno'), 'arr': 2},
    {'code': OFFLINE_QUESTION, 'desc': _('Preguntas offline'), 'arr': 3},
    {'code': WAITING, 'desc': _('En espera'), 'arr': 4},
    {'code': EXTRA_WAITING, 'desc': _('En espera (Sin turno)'), 'arr': 5},
    {'code': ABSENT, 'desc': _('Ausente'), 'arr': 6},
    {'code': POST_PROCESS, 'desc': _('Postprocesado'), 'arr': 7}]

    def __init__(self):
        self.db = DBConnect()
        self.template = WebTemplates()
        Resource.__init__(self)

    def getChild(self, path, request):
        if path == "":
            return self
        else:
            return static.File.childNotFound

    # Si estamos autenticados como admin, sirve para modificar las materias de
    # cualquier tutor.
    # Si somos tutor, sirve para modificar solo los propios.
    def render_GET(self, request):
        d = defer.maybeDeferred(getTranslatorFromSession, request)
        d.addCallback(self.doAuthentication, request)
        return server.NOT_DONE_YET

    def doAuthentication(self, trans, request):
        session = request.getSession()
        _ = trans
        # 0) Se empieza la página
        header = """
<link rel="stylesheet" type="text/css" media="all" href="/calendar/calendar-win2k-cold-1.css" title="win2k-cold-1" />
<script type="text/javascript" src="/calendar/calendar.js"></script>
<script type="text/javascript" src="/calendar/lang/calendar-sp.js"></script>
<script type="text/javascript" src="/calendar/calendar-setup.js"></script>"""

        request.write(self.template.startPageWithHeader(session, header, \
         _('Informacion de tutores')))
        d = defer.maybeDeferred(lambda:None)
        # 1) Verificar que esté autenticado ante el sistema
        if not hasattr(session, 'username'):
            request.write(self.template.notAuthenticated(session))
        # 2) Si es Admin, administra todos los usuarios
        elif session.kind == ADMIN:
            msg = '<h2>' + _('Informacion de los tutores del sistema') + '</h2>'
        # La función que imprime el contenido, pero con otros argumentos
            self.printContent(request, d, msg)
        else:
        # 4) Si no es Admin es alguien que no está
        #    autorizado a ver la información de tutores
            request.write(self.template.notAuthorized(session))
        # 5) Se termina la página
        d.addCallback(lambda a: request.write(self.template.finishPage(session)))
        d.addCallback(lambda a: request.finish())
        return d

    def printContent(self, request, d, msg):
        """Consulta los datos de tutores de la base de datos y los manda
        a imprimir
        """
        args = self.checkRequest(d, request)
        try:
            pag = int(request.args['pag'][0])
        except:
            pag = 0
            
        d.addCallback(lambda a: request.write(msg))
        d.addCallback(lambda a: self.printForm(request, args))
        d.addCallback(lambda a: self.requestData(request, args['start'], args['end'],pag))
        d.addCallback(self.printData, request,pag)
        return d


    def requestData(self, request, time_start, time_end, pag):
        """Consulta los datos de los tutores en la tabla session con los límites de
        fecha dados por time_start y time_end
        """
        
        query = "select p.username, p.id, sum(dmin('%s', s.time_end) - \
          dmax('%s', s.time_start)) as total, s.session_type, (select count(*) \
          from person p, tutor t where p.id = t.id) from person p, \
          tutor t left join session s on (s.fk_tutor = t.id and \
          s.time_start < '%s' and s.time_end > '%s') where t.id = p.id \
          group by p.id, p.username, s.session_type \
          order by username, session_type"
        
        
        query += " LIMIT %d OFFSET %d" %  (ITEMS_PAG, ITEMS_PAG*pag)
        d = self.db.db.runQuery(query, ((time_end, time_start) * 2))
        d.addCallback(self.requestTotal, time_start, time_end)
        return d

    def requestTotal(self, rows, time_start, time_end):
        """recupera los totales de TODOS los tutores en una lista session_type | total"""
        
#.........这里部分代码省略.........

class WebPCArrangeCommon(Resource):
    def __init__(self):
        self.db = DBConnect()
        self.template = WebTemplates()
        Resource.__init__(self)

    # Si estamos autenticados como admin, sirve para coordinar clases para cualquier alumno.
    # Si somos alumno, sirve para coordinar clases propias.
    def render_GET(self, request):
        d = defer.maybeDeferred(getTranslatorFromSession, request)
        d.addCallback(self.doAuthentication, request)
        return server.NOT_DONE_YET

    def doAuthentication(self, trans, request):
        session = request.getSession()
        _ = trans

        msg = '<div id="pchelp"><h3>' + _('Pasos para precoordinar una clase') + \
              '</h3><ol class="steps"><li class="one">' + _('Elige la materia') + \
              '</li><li class="two">' + _('Elige el tutor') + '</li><li class="three">' + \
              _('Elige el horario') + '</li></ol></div>\n'

        msg = msg + self.stepMessage(session)

        # 0) Se empieza la página
        request.write(self.template.startPage(session, _('Modificacion de horarios')))
        d = defer.maybeDeferred(lambda:None)
        # 1) Verificar que esté autenticado ante el sistema
        if not hasattr(session, 'username'):
            request.write(self.template.notAuthenticated(session))
        # 2) Si es Admin, administra todos los usuarios
        elif session.kind == ADMIN:
        # 2.1) Admin debe proveer el argumento user_id
            if "user_id" in request.args.keys():
                try:
                    user_id = int(request.args['user_id'][0])
        # La función que procesa e imprime el contenido de la pagina
                    self.printContent(request, d, user_id, msg)
                except ValueError:
                    request.write(self.template.unexpectedArguments(session, _('user_id deberia ser entero')))
            else:
                request.write(self.template.unexpectedArguments(session, _('falta el parametro user_id')))
        # 3) Si es Pupil, coordina sus propias clases
        elif session.kind == PUPIL:
            user_id = session.userId
        # La función que imprime el contenido, pero con otros argumentos
            self.printContent(request, d, user_id, msg)
        else:
        # 4) Si no es ni ni Admin, ni Pupil, ni nadie, es alguien que no está
        #    autorizado a administrar horarios
            request.write(self.template.notAuthorized(session))
        # 5) Se termina la página
        d.addCallback(lambda a: request.write(self.template.finishPage(session)))
        d.addCallback(lambda a: request.finish())
        return d

    def packSchedule(self, checks):
        try: # Mapeamos a integer y filtramos valores inadecuados
            checks = [int(chk) for chk in checks]
        except ValueError:
            return []
        checks.sort()

        scheds = []
        last_hour = None
        start_time = None
        end_time = None
        for hour in checks:
            if last_hour is None:
                start_time = hour
            elif last_hour < hour - 1:
                scheds.append((start_time, end_time))
                start_time = hour
            last_hour = hour
            end_time = hour + 1
        # Falta el último span, que lo agregamos ahora:
        if end_time is not None:
            if end_time == LASTDAY_MIDNIGHT:
                if start_time == 0: # Este tipo labura 24/7!
                    scheds.append((0, end_time))
                elif len(scheds) > 0 and scheds[0][0] == 0: # El horario abarca las 0 del domingo
                    scheds.append((start_time, end_time + scheds[0][1]))
                    del(scheds[0])
                else:
                    scheds.append((start_time, end_time))
            else:
                scheds.append((start_time, end_time))
        # Convertimos a DateTime

        spans = []
        base = today() + 3
        def mktimestamp(x):
            day = base + x / 48

            #VER 
            #incluir DateTimeDelta del userId
            return DateTime(day.year, day.month, day.day, (x % 48) / 2, (x % 2) * 30)
        for sched in scheds:
            spans.append((mktimestamp(sched[0]), mktimestamp(sched[1])))
        return spans
#.........这里部分代码省略.........

class WebAdmin(Resource):
    def __init__(self):
        self.db = DBConnect()
        self.template = WebTemplates()
        Resource.__init__(self)

    def getChild(self, path, request):
        if path == "":
            return self
        else:
            return static.File.childNotFound

    # A esta pagina sólo se podrá acceder si tenemos permisos de administrador.
    # Mostrará un link para ver las listas de: clientes, tutores y alumnos
    def render_GET(self, request):
        d = defer.maybeDeferred(getTranslatorFromSession, request)
        d.addCallback(self.doAuthentication, request)
        return server.NOT_DONE_YET

    def doAuthentication(self, trans, request):
        _ = trans
        session = request.getSession()
        d = defer.maybeDeferred(lambda: None)
        # Se escribe el comienzo de la página
        request.write(self.template.startPage(session, _('Administracion de usuarios')))
        # Si no es admin o no esta loggeado, no seguimos
        if not hasattr(session, 'username') or session.kind != ADMIN:
            d.addCallback(lambda a: request.write(self.template.notAuthenticated(session)))
        else:
            d.addCallback(lambda a: self.sysStatus(request))
            d.addCallback(self.printContent, request)
        # Se escribe el final de la página
        d.addCallback(lambda a: request.write(self.template.finishPage(session)))
        d.addCallback(lambda a: request.finish())
        return server.NOT_DONE_YET


    def sysStatus(self, request):
        """Busca la información acerca de la cantidad de usuarios,
        alumnos y tutores que tiene el sistema.
        """
        query = "select count(*), kind from person group by kind order by kind asc"
        d = self.db.db.runQuery(query)
        return d

    def printContent(self, rows, request):
        _ = request.getSession()._
        subjects = _('Listado de materias disponibles y cantidad de tutores que la tienen como seleccionada para poder dar clases. Tambien se pueden realizar alta y bajas de materias')
        tutors = _('Tiempo que los tutores pasaron en el sistema, dividido por tipos de conexion. Detalle de las sesiones de cada tutor. Se puede elegir un rango de fechas para visualizar')
        rooms = _('Informacion de las aulas del sistema, cantidad de alumnos en el aula, los tutores que se encuentran a cargo y las materias que estan brindando. Listado de aulas que deberian estar abiertas y no lo estan, con la informacion del tutor correspondiente')
        board = _('Archivos en formato PDF (Portable Document Format) que contienen las pizarras de las clases brindadas por los tutores del sistema')
        admin = [{'id': 'subject_admin', 'item': _('Administrar materias'), \
                  'title': _('Materias'), 'alt': _('Materias'), 'desc': subjects, \
                  'link': '/subject_admin', 'image': '/static/graphics/subjects.gif', \
                  'width': '16', 'height': '16'},
         {'id': 'tutor_info', 'item': _('Informacion de tutores'), \
          'title': _('Tutores'), 'alt': _('Tutores'), 'desc': tutors, \
          'link': '/tutor_info', 'image': '/static/graphics/subjects.gif', \
          'width': '16', 'height': '16'},
         {'id': 'roominfo', 'item': _('Informacion de aulas'), \
          'title': _('Aulas'), 'alt': _('Aulas'), 'desc': rooms, \
          'link': '/roominfo', 'image': '/static/graphics/tutor_info.gif', \
          'width': '16', 'height': '16'},
         {'id': 'tutor', 'item': _('Agregar tutores'), 'title': _('Tutores'), \
          'alt': _('Tutores'), 'desc': _('Agregar nuevos tutores al sistema'), \
          'link': '/tutor', 'image': '/static/graphics/mortarboard.gif', \
          'width': '16', 'height': '16'},
         {'id': 'client', 'item': _('Agregar clientes'), 'title': _('Clientes'), \
          'alt': _('Clientes'), 'desc': _('Agregar nuevos clientes al sistema'), \
          'link': '/client', 'image': '/static/graphics/buddy.gif', \
          'width': '16', 'height': '16'},
         {'id': 'archive', 'item': _('Archivo de pizarras'), 'title': _('Archivo'), \
          'alt': _('Archivo'), 'desc': board, 'link': '/archive', \
          'image': '/static/graphics/ps.png', 'width': '16', 'height': '16'}]

        page = ''
        if len(rows) != 0:
            page += '<h2>' + _('Administracion del sistema:') \
                + '</h2><div style="padding-left: 40px"><table id="admin_table" border="0">'
            for item in admin:
                page += """<tr><td><a href='%s' id='%s'><img src='%s' width='%s'
                 height='%s' alt='%s' title='%s'/></a><a href='%s'>%s</a>
                 </td><td>%s</td> </tr>""" \
                 % (item['link'], item['id'], item['image'], item['width'], \
                    item['height'], item['alt'], item['title'], item['link'], \
                    item['item'], item['desc'])
            page += """</table></div><h2>""" + _('Informacion de usuarios en el sistema:') \
                    + """</h2><div style="padding-left: 40px" id='users'>""" \
                    + """<ul id="systemusers">"""

            for i in range(len(rows)):
                # row[0] es la cantidad de row[1] que hay en la base
                if rows[i][1] == TUTOR:
                    page += '<li>%d <a href="/list?kind=%d">' % (rows[i][0], TUTOR) \
                            + _('Tutores') + '</a> ' + _('en el sistema') + '</li>'
                elif rows[i][1] == PUPIL:
                    page += '<li>%d <a href="/list?kind=%d">' % (rows[i][0], PUPIL) \
                            + _('Alumnos') + ' </a> ' + _('en el sistema') + '</li>'
                elif rows[i][1] == CLIENT:
                    page += '<li>%d <a href="/list?kind=%d">' % (rows[i][0], CLIENT) \
#.........这里部分代码省略.........

class WebRoomInfo(Resource):
    def __init__(self, server):
        self.db = DBConnect
        self.rOpen = server.openRoomsAndLenQueues # clave room -> valor cant gente
        self.subjects = server.openRoomsAndSubjects # clave room -> valor lista materias
        self.sbOpen = server.shouldBeOpenAndClosedRooms
        self.template = WebTemplates()
        Resource.__init__(self)

    def getChild(self, path, request):
        if path == "":
            return self
        else:
            return static.File.childNotFound


    def render_GET(self, request):
        d = defer.maybeDeferred(getTranslatorFromSession, request)
        d.addCallback(self.doAuthentication, request)
        return server.NOT_DONE_YET

    def doAuthentication(self, trans, request):
        session = request.getSession()
        _ = trans
        request.write(self.template.startPage(session, \
            _('Informacion de Pizarras en el sistema')))
        d = defer.maybeDeferred(lambda :None)
        if not hasattr(session, 'username'):
            request.write(self.template.notAuthenticated(session))
        # 2) Si es Admin, administra todos los usuarios
        elif session.kind == ADMIN:
            msg = '<h2>' + _('Estado del sistema') + '</h2>' + \
            _('Aqui se muestran las aulas que se encuentran abiertas, una descripcion de ellas y la lista de aulas que deberian estar abiertas.')
        # La función que procesa e imprime el contenido de la pagina
        else:
            msg = '<h2>' + _('Estado del sistema') + '</h2>' + \
            _('Aqui se muestran las aulas que se encuentran abiertas y una descripcion de ellas')
        self.printContent(request, d, session, msg)
        # 5) Se termina la página
        d.addCallback(lambda a: request.write(self.template.finishPage(session)))
        d.addCallback(lambda a: request.finish())
        return d


    def printContent(self, request, d, session, msg):
        rOpen = self.rOpen()
        subjects = self.subjects()
        d.addCallback(lambda a: request.write(msg))
        d.addCallback(lambda a: self._getORoomInfo(rOpen))
        d.addCallback(self._printORoomTable, request, rOpen, subjects)
        if session.kind == ADMIN:
            d.addCallback(lambda a: self._getSBORoomInfo(self.sbOpen()))
            d.addCallback(self._printSBORoomTable, request)
        # 2) Se imprime un mensaje de bienvenida configurable
        return d


    def _getORoomInfo(self, openRooms):
        ids = tuple([int(b) for b in openRooms.keys() if b != GENERAL] + [0])
        if len(ids) > 1:
            query = "select username, id from person where id in %s"
            d = self.db.db.runQuery(query, (ids,))
        else:
            d = defer.maybeDeferred(lambda: [])
        return d

    def _getSBORoomInfo(self, sbopenRooms):
        if sbopenRooms != []:
            query = "select username, id from person where id in %s"
            d = self.db.db.runQuery(query, (tuple(sbopenRooms + [0]),))
        else:
            d = defer.maybeDeferred(lambda: [])
        return d

    def _printORoomTable(self, rows, request, openRooms, subjects):
        _ = request.getSession()._
        page = """<br/><br/>
<table class="table_list" id="opened_rooms">
 <caption>""" + _('Aulas abiertas:') + """</caption>
 <tr class="header_list">
  <th>""" + _('Aula') + """</th>
  <th>""" + _('Usuarios conectados') + """</th>
  <th>""" + _('Tutor a cargo') + """</th>
  <th>""" + _('Materias') + """</th>
 </tr>"""
        if len(openRooms) == 1:
            page += '<tr><td colspan ="4" style="text-align: center">' + \
                _('Ningun aula abierta') + ' </td></tr>'
        else:
            for room in rows:
                rm = room[1]
                connected = openRooms.get(str(room[1]))
                in_charge = "<a href='/tutor_data?user_id=%s'> %s </a>" % (room[1], room[0])
                sub = self.printSubjects(subjects.get(str(room[1])))
                page += """
 <tr>
  <td> %s </td>
  <td> %s </td>
  <td> %s </td>
  <td> %s </td></tr>""" % (rm, connected, in_charge, sub) + """ </td></tr>"""
#.........这里部分代码省略.........

class WebPerson(Resource):
    _ = dummyTranslator
    fields = [{'name': 'username', 'pos': 1, 'desc': _('Nombre de usuario'), \
         'required': True, 'isPass': False, 'maxlength': 80, 'query': "person"},
        {'name': 'password', 'pos': 2, 'desc': _('Contrasena'), \
         'required': True, 'isPass': True, 'maxlength': 80, 'query': "person"},
        {'name': 'password2', 'pos': 2, 'desc': _('Repita contrasena'), \
         'required': True, 'isPass': True, 'maxlength': 255, 'query': ""},
        {'name': 'first_name', 'pos': 3, 'desc': _('Nombre'), 'required': True, \
         'isPass': False, 'maxlength': 255, 'query': "person"},
        {'name': 'last_name', 'pos': 4, 'desc': _('Apellido'), 'required': True, \
         'isPass': False, 'maxlength': 255, 'query': "person"},
        {'name': 'email', 'pos': 5, 'desc': _('eMail'), 'required': True, \
         'isPass': False, 'maxlength': 255, 'query': "person"}]

    def __init__(self, table, title, kind, query, empty, xtra_fields):
        _ = dummyTranslator
        self.db = DBConnect()
        self.render_POST = self.render_GET
        self.template = WebTemplates()
        self.table = table
        self.title = title
        self.kind = kind
        
        self.query = query
        self.empty = empty
        self.fields = WebPerson.fields + xtra_fields
        Resource.__init__(self)
        

    def getChild(self, path, request):
        if path == "":
            return self
        else:
            return static.File.childNotFound

    def render_GET(self, request):
        d = defer.maybeDeferred(getTranslatorFromSession, request)
        d.addCallback(self.doAuthentication, request)
        return server.NOT_DONE_YET

    def doAuthentication(self, trans, request):
        session = request.getSession()
        _ = trans
        request.write(self.template.startPage(session, self.title))
        d = defer.maybeDeferred(lambda :None)

        if not hasattr(session, 'username'):
            request.write(self.template.notAuthenticated(session))
        elif session.kind == ADMIN:
            try:
                user_id = int(request.args.get('user_id', [-1])[0])
                msg = '<h2>' + self.title + ": " + _('Datos personales') + '</h2> ' + \
                    _('Recuerde que los campos indicados con <sup>*</sup> son obligatorios<br>') 
                if user_id!=-1: 
                    msg += _('Si desea conservar la contraseña actual deje los campos en blanco') + '<br/>' 
                

    # La función que procesa e imprime el contenido de la pagina
                self.printContent(request, d, user_id, msg)
            except ValueError:
                request.write(self.template.unexpectedArguments(session, \
                    _('user_id deberia ser entero')))
        # 3) Administra sus propios datos
        elif session.kind == self.kind:
            user_id = session.userId
            msg = '<h2>' + _('Tus Datos personales') + '</h2>' + \
                _('Recuerda que los campos indicados con <sup>*</sup> son obligatorios')
        # La función que imprime el contenido, pero con otros argumentos
            self.printContent(request, d, user_id, msg)
        else:
        # 4) Es alguien que no está autorizado a administrar materias
            request.write(self.template.notAuthorized(session))
        # 5) Se termina la página
        d.addCallback(lambda a: request.write(self.template.finishPage(session)))
        d.addCallback(lambda a: request.finish())

        return server.NOT_DONE_YET

    def checkRequest(self, d, request):
        session = request.getSession()
        _ = session._
        args = dict([(i, request.args[i][0]) for i in request.args.keys()])
        if "submit" in request.args.keys():
            for value in self.fields:
                if value['name'] not in args.keys():
                    args[value['name']] = ''
                    d.addCallback(lambda a: \
                        request.write(self.template.unexpectedArguments(session, \
                        _('Falta el argumento \'%s\'') % value['name'])))
                elif len(args[value['name']]) > value['maxlength']:
                    args[value['name']] = args[value['name']][:value['maxlength']]
                    d.addCallback(lambda a: \
                        request.write(self.template.unexpectedArguments(session, \
                        _('Longitud excesiva del argumento \'%s\'') % value['name'])))
            if(args['password'] != args['password2']):
                request.write(self.template.unexpectedArguments(session, \
                    _('Las contrasenas no coinciden')))

            if re.match("^.+\\@(\\[?)[a-zA-Z0-9\\-\\.]+\\.([a-zA-Z]{2,3}|[0-9]{1,3})(\\]?)$", args['email']) == None:
#.........这里部分代码省略.........

class WebSubjects(Resource):
    def __init__(self):
        self.db = DBConnect()
        self.template = WebTemplates()
        Resource.__init__(self)

    def getChild(self, path, request):
        if path == "":
            return self
        else:
            return static.File.childNotFound

    # Si estamos autenticados como admin, sirve para modificar las materias de cualquier tutor.
    # Si somos tutor, sirve para modificar solo los propios.
    def render_GET(self, request):
        d = defer.maybeDeferred(getTranslatorFromSession, request)
        d.addCallback(self.doAuthentication, request)
        return server.NOT_DONE_YET

    def doAuthentication(self, trans, request):
        session = request.getSession()
        _ = trans
        # 0) Se empieza la página
        request.write(self.template.startPage(session, _('Modificacion de materias')))
        d = defer.maybeDeferred(lambda:None)
        # 1) Verificar que esté autenticado ante el sistema
        if not hasattr(session, 'username'):
            request.write(self.template.notAuthenticated(session))
        # 2) Si es Admin, administra todos los usuarios
        elif session.kind == ADMIN:
        # 2.1) Admin debe proveer el argumento user_id
            if "user_id" in request.args.keys():
                try:
                    user_id = int(request.args['user_id'][0])
                    msg = '<h2>' + _('Administracion de materias') + '</h2>' + \
                     _('Selecciona las materias que el tutor sepa ensenar, para actualizar los datos en el sistema.')
        # La función que procesa e imprime el contenido de la pagina
                    self.printContent(request, d, user_id, msg)
                except ValueError:
                    request.write(self.template.unexpectedArguments(session, \
                       _('user_id deberia ser entero')))
            else:
                request.write(self.template.unexpectedArguments(session, \
                   _('falta el parametro user_id')))
        # 3) Si es Tutor, administra sus propias materias
        elif session.kind == TUTOR:
            user_id = session.userId
            msg = '<h2>' + _('Seleccion de materias') + '</h2>' + \
                _('Selecciona las materias que sepas ensenar, para actualizar tus datos en el sistema.')
        # La función que imprime el contenido, pero con otros argumentos
            self.printContent(request, d, user_id, msg)
        else:
        # 4) Si no es ni ni Admin, ni Tutor, ni nadie, es alguien que no está
        #    autorizado a administrar materias
            request.write(self.template.notAuthorized(session))
        # 5) Se termina la página
        d.addCallback(lambda a: request.write(self.template.finishPage(session)))
        d.addCallback(lambda a: request.finish())
        return d

    def printContent(self, request, d, userId, msg):
        _ = request.getSession()._
        # 1) Si se envían datos, se actualiza la base primero
        if "submit" in request.args.keys():
            op = "delete from tutor_subject where fk_tutor = %d"
            d.addCallback(lambda a: self.db.db.runOperation(op, (userId, )))
            for sbj in request.args.get('sbj', []):
                try:
                    sbj = int(sbj)
                    d.addCallback(self.addSubject, userId, sbj)
                except ValueError: # Alguien editó la url a mano?
                    d.addCallback(lambda a: \
                     request.write(self.template.unexpectedArguments(session, + \
                        _('sbj deberia tomar valores enteros.'))))
            d.addCallback(lambda a: request.write('<div class="message"><h2>' + \
                _('Cambios guardados.') + '</h2>' + \
                _('Se guardaron los cambios correctamente') + '</div>'))
        # 2) Se imprime un mensaje de bienvenida configurable
        d.addCallback(lambda a: request.write(msg))
        # 3) Se buscan los datos nuevos en la base
        d.addCallback(self.requestSubjectData, userId)
        # 4) Se imprime un formulario con los datos actualizados
        d.addCallback(self.printForm, request, userId)
        return d


    def requestSubjectData(self, data, userId):
        query = 'select s.id, s.name, t.fk_tutor from subject as s \
                 left join tutor_subject as t on (t.fk_subject = s.id \
                 and t.fk_tutor = %d)'
        return self.db.db.runQuery(query, (userId,))

    def printForm(self, rows, request, userId):
        _ = request.getSession()._
        string = """<form action="" method="GET">
  <select id="sbj" name="sbj" size="%d" multiple="multiple">""" % len(rows)
        for sbj in rows:
            selected = ''
            if sbj[2] is not None:
                selected = ' selected="selected"'
#.........这里部分代码省略.........