Python WebTemplates.unexpectedArguments方法代码示例

# 需要导入模块: from WebTemplates import WebTemplates [as 别名]
# 或者: from WebTemplates.WebTemplates import unexpectedArguments [as 别名]
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

# 需要导入模块: from WebTemplates import WebTemplates [as 别名]
# 或者: from WebTemplates.WebTemplates import unexpectedArguments [as 别名]
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

# 需要导入模块: from WebTemplates import WebTemplates [as 别名]
# 或者: from WebTemplates.WebTemplates import unexpectedArguments [as 别名]
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:
#.........这里部分代码省略.........

# 需要导入模块: from WebTemplates import WebTemplates [as 别名]
# 或者: from WebTemplates.WebTemplates import unexpectedArguments [as 别名]
class WebSchedules(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 los horarios 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 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])
                    msg = """<h2>""" + _('Administracion de horarios') + """</h2>""" + _('Selecciona las horas en las que el tutor se encuentra disponible.')
        # 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 propios horarios
        elif session.kind == TUTOR:
            user_id = session.userId
            msg = """<h2>""" + _('Seleccion de horarios') + """</h2>""" + _('Indica los horarios (en tu hora local) en los que te encuentras disponible.')
        # 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 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 printContent(self, request, d, userId, msg):
        # 1) Si se envían datos, se actualiza la base primero. 
        # La actualizacion consiste en eliminar todos los horarios previos, 
        # hace el packSchedule, e insertar los nuevos horarios. 
        _ = request.getSession()._
        if "submit" in request.args.keys():
            op = "delete from tutor_schedule where fk_tutor = %d"
            d.addCallback(lambda a: self.db.db.runOperation(op, (userId, )))

            d.addCallback(lambda a: self.packSchedule(request.args.get('sch', []), str(INSTANT), userId))
            #instants = self.packSchedule(request.args.get('sch', []), str(INSTANT), userId)
            d.addCallback(self.addSched, userId,INSTANT)
            
            d.addCallback(lambda a: self.packSchedule(request.args.get('sch', []), str(PRECOORD), userId))
            d.addCallback(self.addSched, userId,PRECOORD)
            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.requestScheduleData, userId)
        # 4) Se imprime un formulario con los datos actualizados
        d.addCallback(self.printForm, request, userId)
        return d
        
    def addSched(self, tipoH, userId,TIPO):
        for sched in tipoH:
            self.addSchedule(userId, sched, TIPO)
        return None
    
        

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

        scheds = []
        last_hour = None
        start_time = None
        end_time = None
#.........这里部分代码省略.........

# 需要导入模块: from WebTemplates import WebTemplates [as 别名]
# 或者: from WebTemplates.WebTemplates import unexpectedArguments [as 别名]
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')},
#.........这里部分代码省略.........

# 需要导入模块: from WebTemplates import WebTemplates [as 别名]
# 或者: from WebTemplates.WebTemplates import unexpectedArguments [as 别名]
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
#.........这里部分代码省略.........

# 需要导入模块: from WebTemplates import WebTemplates [as 别名]
# 或者: from WebTemplates.WebTemplates import unexpectedArguments [as 别名]
class WebTutorSessions(Resource):
    _ = dummyTranslator

    typeToString = {IACLASS: _('Acceso Instantaneo'), PACLASS: _('Clase Precoordinada'), WAITING: _('En espera'), OFFLINE_QUESTION: _('Pregunta offline'), EXTRA_IACLASS: _('AI (Fuera de turno)'), EXTRA_WAITING: _('Espera (Fuera de turno)'), DECIDING: _('Analizando pregunta'), ABSENT: _('Ausente'), POST_PROCESS: _('Postprocesado')}.get

    typeToStyle = {IACLASS: "ia_row", PACLASS: "pc_row", WAITING: "waiting_row", OFFLINE_QUESTION: "offline_row", EXTRA_IACLASS: "extra_ia_row", EXTRA_WAITING: "extra_waiting_row", DECIDING: "deciding_row", ABSENT: "absent_row", POST_PROCESS: "postprocess_row"}.get

    eCodeToString = {NORMAL: _('Fin horario'), TUTOR_ENTER: _('Arribo'), PUPIL_ENTER: _('Entrada de alumno'), TUTOR_END: _('Terminada por Tutor'), PUPIL_END: _('Terminada por alumno'), TUTOR_QUIT: _('Desconexion Tutor'), SERVER_RESTART: _('Reconexion servidor'), QUESTION_ANSWERED: _('Pregunta contestada'), QUESTION_NOT_ANSWERED: _('Pregunta no contestada'), ACCEPTED: _('Pregunta aceptada'), REJECTED: _('Pregunta no aceptada'), CORRECTED: _('Postprocesado'), NOT_CORRECTED: _('No postprocesado'), None: '-'}.get

    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, \
          _('Historial de sesiones del tutor')))
        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:
            if "user_id" in request.args.keys():
                try:
                    user_id = int(request.args['user_id'][0])
                    msg = '<h2>' + _('Sesiones del tutor') + '</h2>'
        # 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, ve sus propias sesiones
        elif session.kind == TUTOR:
            user_id = session.userId
            msg = '<h2>' + _('Tus sesiones') + '</h2>' + \
              _('Este es el detalle de tus sesiones en el sistema:') + '<br/>'
        # 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 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 printContent(self, request, d, user_id, msg):
        """Consulta las sesiones del tutor user_id en la
         base de datos y las manda a imprimir
         """
        try:
            pag = int(request.args['pag'][0])
                    
        except:
            pag = 0
        
        d.addCallback(lambda a: request.write(msg))
        now = DateTime.now()
        query =  """select s.session_type, s.time_start, s.time_end, s.error_code, \
         p.username, p.id, (select count(*) from session s left join person p on (p.id = s.fk_pupil) \
         where fk_tutor = %d and s.time_end < '%s') from session s left join person p on (p.id = s.fk_pupil) \
         where fk_tutor = %d and s.time_end < '%s' order by time_start desc LIMIT %d OFFSET %d"""
        d.addCallback(lambda a: self.db.db.runQuery(query, (user_id, now,user_id, now,ITEMS_PAG, ITEMS_PAG*pag)))
        d.addCallback(self.printData, request, pag)
        return d

    def printData(self, rows, request,pag):
        _ = request.getSession()._
                    
        if len(rows) == 0:
            string = _('No se registran sesiones') + '<br/>'
            def paginacion(): pass
        else:
            total = rows[0][-1:][0] #la ultima columna es el total de datos para la consulta
            try:            
                user_id = int(request.args['user_id'][0])
            except:
#.........这里部分代码省略.........

# 需要导入模块: from WebTemplates import WebTemplates [as 别名]
# 或者: from WebTemplates.WebTemplates import unexpectedArguments [as 别名]
class WebClientReport(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

    # Muestra un acceso a Listado de datos personales de alumnos (para recortar)
    # y Detalle de horas por alumno
    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, _('Reportes de alumnos')))
        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)
                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, administra sus propios horarios
        elif session.kind == CLIENT:
            user_id = session.userId
        # La función que imprime el contenido, pero con otros argumentos
            self.printContent(request, d, user_id)
        else:
        # 4) Si no es ni ni Admin, ni Cliente, ni nadie, es alguien que no está
        #    autorizado a administrar alumnos
            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):
        d.addCallback(lambda a: self.requestData(userId))
        d.addCallback(self.printData, request, userId)
        return d

    def requestData(self, userId):
        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, (str(userId),))
        return d

    def printData(self, data, request, userId):
        session = request.getSession()
        user = (session.kind == ADMIN) and "?user_id=%s" % (str(userId),) or ""
        _ = session._
        if len(data) != 1:
            string = '<div class="error">' + _('El usuario no existe en el sistema') \
                + '</div>'
        else:
            client = "%s %s (%s)" %(data[0][0], data[0][1], data[0][2])
            string = """<h2>""" + _('Reportes de alumnos de %s') % client \
                + """</h2>""" + _('Seguimiento de alumnos')
            string += "<div id='client_menu'><ul>" + \
            '<li> <a href="/my_pupils_info%s">' % user + \
                _('Datos personales:') +  ' </a> ' + \
                _('Listado de datos personales los alumnos a cargo') + \
                '</li><li> <a href="/my_pupils%s">' % user + _('Horas:') + ' </a> ' + \
                _('Detalle de las horas usadas y disponibles por alumno') + \
                '</li></ul></div>' + '<a href="javascript:history.back()" id="back">' + \
                _('Volver') + '</a>'
        request.write(string)
        return

# 需要导入模块: from WebTemplates import WebTemplates [as 别名]
# 或者: from WebTemplates.WebTemplates import unexpectedArguments [as 别名]
class WebListUsers(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á una lista de clientes, tutores, etc. de acuerdo a lo que se le pase por
    # direccion
    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
        # Se escribe el comienzo de la página
        request.write(self.template.startPage(session, \
             _('Listado de usuarios del sistema')))
        d = defer.maybeDeferred(lambda: None)
        keys = request.args.keys()
        # Si no es admin o no esta loggeado, no seguimos
        if not hasattr(session, 'username') or session.kind != ADMIN:
            request.write(self.template.notAuthenticated(session))
        else:
            if "kind" in request.args.keys():
                try:
                    kind = int(request.args['kind'][0])
                    if "del" in keys:
                        erase = DBDelete(self.db)
                        client = QuotedString(request.args['del'][0])
                        d.addCallback(lambda a: erase.deletePerson(client, kind))
                        d.addCallback(lambda a: request.write('<div class="message">' + \
                         _('El usuario ha sido borrado correctamente') + '</div>'))
                    elif ("ia" in keys or "pc" in keys) and "user_id" in keys and \
                        not ("ia" in keys and "pc" in keys):
                        hours = ("ia" in keys) and "ia" or "pc"
                        user = QuotedString(request.args['user_id'][0])
                        cant = float(request.args[hours][0].replace(",", "."))
                        d.addCallback(lambda a: self.setClientHours(user, cant, hours))
                        d.addCallback(lambda a: request.write('<div class="message">' + \
                         _('Se ha actualizado correctamente la cantidad de horas  disponibles') + '</div>'))
                    d.addCallback(lambda a: self.listClient(request))
                except ValueError:
                        d.addCallback(lambda a: \
                         request.write(self.template.unexpectedArguments(session, \
                         _('Argumento no valido'))))
            else:
                d.addCallback(lambda a: \
                 request.write(self.template.unexpectedArguments(session, \
                _('Falta el argumento \'kind\''))))
        # 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 d

    def setClientHours(self, user, cant, hours):
        if hours == "pc":
            query = "update client set pc_available = %f where id=%s """
        else:
            query = "update client set ai_available = %f where id=%s """
        d = self.db.db.runOperation(query, (cant, user))
        return d

    def listClient(self, request):
        """Busca la información para todos los usuarios del tipo dado por la request
        y llama a printContent con el resultado de la busqueda
        """
        kind = int(request.args['kind'][0])
        try:
            pag = int(request.args['pag'][0])
        except:
            pag = 0
        
        if kind == TUTOR:
            cols = "tutor.id, username, first_name, last_name"
            fromWhere = "from tutor, person where tutor.id = person.id"
            order = "order by id asc"
        elif kind == PUPIL:
            cols = "p.id, p1.username, p1.first_name, p1.last_name, p2.username, p.fk_client"
            fromWhere = "from person p1, person p2, pupil p where p.id = p1.id and p2.id = p.fk_client"
            order = "order by p.id asc"
        elif kind == CLIENT:
            cols = "client.id, username, first_name, \
             last_name, organization, client.ai_available, client.pc_available, \
             count(pupil.id)"
            fromWhere = "from client left join pupil on \
             (pupil.fk_client = client.id) left join person on (client.id = person.id) \
             group by client.id, person.username, person.first_name, person.last_name, \
             client.organization, client.ai_available, client.pc_available"
            order = "order by id asc"
        elif kind == ADMIN:
            cols = "person.id, username, first_name, last_name"
#.........这里部分代码省略.........

# 需要导入模块: from WebTemplates import WebTemplates [as 别名]
# 或者: from WebTemplates.WebTemplates import unexpectedArguments [as 别名]
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"'
#.........这里部分代码省略.........

# 需要导入模块: from WebTemplates import WebTemplates [as 别名]
# 或者: from WebTemplates.WebTemplates import unexpectedArguments [as 别名]
class WebMyPupils(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

    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
        msg = """<h2>""" + _('Cuentas de alumnos') + """</h2>"""
        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)
                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
        # La función que imprime el contenido, pero con otros argumentos
            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 printContent(self, request, d, userId):
        _ = request.getSession()._
        # 2) Si se envían datos, se actualiza la base primero
        d.addCallback(lambda a: self.requestData(userId))
        d.addCallback(self.printTitle, request)
        if "del" in request.args.keys():
            try:
                to_delete = int(request.args["del"][0])
                query3 = "select id from pupil where id = %d and fk_client = %d"
                d.addCallback(lambda a: self.db.db.runQuery(query3, (to_delete, userId)))
                d.addCallback(self.checkUser, userId, request)
            except ValueError:
                d.addCallback(lambda a: \
                 request.write(self.template.unexpectedArguments(session, \
                 _('user_id deberia ser entero'))))
        # 3) Se buscan los datos en la base
        query = "select c.ai_available, c.pc_available, count(p.id) \
          from client c left join pupil p on (p.fk_client = c.id) \
          where c.id = %d group by c.ai_available, c.pc_available"
        d.addCallback(lambda a: self.db.db.runQuery(query, (userId, )))
        d.addCallback(self.printClientInfo, request)
        query2 = "select a.id, last_name, first_name, ai_available, ai_total, \
           pc_available, pc_total, expires from person p, pupil a \
           where p.id = a.id and fk_client = %d"
        d.addCallback(lambda a: self.db.db.runQuery(query2, (userId, )))
        # 4) Se imprime los datos
        d.addCallback(self.printForm, request, userId)
        return d

    def checkUser(self, rows, userId, request):
        session = request.getSession()
        _ = session._
        d = defer.maybeDeferred(lambda: None)
        if len(rows) != 1:
            d.addCallback(lambda a: \
                 request.write(self.template.unexpectedArguments(session, \
                 _('No es alumno del cliente'))))
        else:
            erase = DBDelete(self.db)
            to_delete = str(rows[0][0])
            d.addCallback(lambda a: erase.deletePupil(to_delete))
            d.addCallback(lambda a: request.write('<div class="message">' + \
             _('El usuario ha sido borrado correctamente') + '</div>'))
#.........这里部分代码省略.........

# 需要导入模块: from WebTemplates import WebTemplates [as 别名]
# 或者: from WebTemplates.WebTemplates import unexpectedArguments [as 别名]
class WebSchedules(Resource):
    def __init__(self, db):
        self.db = db
        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 los horarios de cualquier tutor.
    # Si somos tutor, sirve para modificar solo los propios.
    def render_GET(self, request):
        session = request.getSession()
        _ = getTranslatorFromSession(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])
                    msg = '<h2>' + _('Administracion de horarios') + '</h2>' + _('Selecciona las horarios de acceso instantaneo para el tutor.')
        # 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 propios horarios
        elif session.kind == TUTOR:
            user_id = session.userId
            msg = '<h2>' + _('Seleccion de horarios') + '</h2>' + _('Selecciona los horarios en los que estas disponible para horas de acceso instantaneo.')
        # 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 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 server.NOT_DONE_YET

    def printContent(self, request, d, userId, msg):
        # 1) Si se envían datos, se actualiza la base primero
        _ = request.getSession()._
        if "submit" in request.args.keys():
            op = "delete from tutor_schedule where fk_tutor = %d"
            d.addCallback(lambda a: self.db.db.runOperation(op, (userId, )))
            instant = self.packSchedule(request.args.get('sched_ai', []))
            for sched in instant:
                d.addCallback(self.addSchedule, userId, sched, INSTANT)
            precoord = self.packSchedule(request.args.get('sched_pc', []))
            for sched in precoord:
                d.addCallback(self.addSchedule, userId, sched, PRECOORD)
            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.requestScheduleData, userId)
        # 4) Se imprime un formulario con los datos actualizados
        d.addCallback(self.printForm, request, userId)
        return d

    def packSchedule(self, checks):
        try: # Mapeamos a integer y filtramos valores inadecuados
            checks = filter(lambda x: 0 <= x  and x < LASTDAY_MIDNIGHT, map(int, 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:
#.........这里部分代码省略.........

# 需要导入模块: from WebTemplates import WebTemplates [as 别名]
# 或者: from WebTemplates.WebTemplates import unexpectedArguments [as 别名]
class WebPupilInsert(Resource):
    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': True, \
            'type': 'password', 'maxlength': 80, 'query': "person"},
        {'name': 'password2', 'pos': 2, 'desc': _('Repita contrasena'), 'required': True, \
            '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"},
        {'name': 'ai_total', 'pos': 6, 'desc': _('Horas de AI'), 'required': True, \
            'type': 'text', 'maxlength': 255, 'query': "pupil"},
        {'name': 'pc_total', 'pos': 7, 'desc': _('Horas de CP'), 'required': True, \
            'type': 'text', 'maxlength': 255, 'query': "pupil"}]
        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
        request.write(self.template.startPage(session, _('Pagina del Alumno')))
        d = defer.maybeDeferred(lambda :None)
        msg = '<h2>' + _('Nuevo alumno') + '</h2> ' + \
          _('Recuerde que los campos indicados con <sup>*</sup> son obligatorios')
        if not hasattr(session, 'username'):
            request.write(self.template.notAuthenticated(session))
        elif session.kind == ADMIN:
            if "user_id" in request.args.keys():
                try:
                    user_id = int(request.args.get('user_id', [-1])[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 argumento user_id')))
        elif session.kind == CLIENT:
            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 Cliente es alguien no autorizado a ver alumnos
            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 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:
                request.write(self.template.unexpectedArguments(session, \
                                    _('El email ingresado es incorrecto')))
            try:
                args['ai_total'] = float(args['ai_total'])
                args['pc_total'] = float(args['pc_total'])
            except ValueError:
                request.write(self.template.unexpectedArguments(session, \
                    _('El argumento de Hora debe ser numerico')))
        return args

#.........这里部分代码省略.........

# 需要导入模块: from WebTemplates import WebTemplates [as 别名]
# 或者: from WebTemplates.WebTemplates import unexpectedArguments [as 别名]
class WebTutorData(Resource):
    _ = dummyTranslator
    dateToString = {
        1: _("Domingo"),
        2: _("Lunes"),
        3: _("Martes"),
        4: _("Miercoles"),
        5: _("Jueves"),
        6: _("Viernes"),
        7: _("Sabado"),
        8: _("Domingo"),
        9: _("Lunes"),
        10: _("Martes"),
        11: _("Miercoles"),
        12: _("Jueves"),
        13: _("Viernes"),
        14: _("Sabado"),
    }.get

    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

    # muestra datos de un tutor (horarios disponibles, nombre, etc.)
    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, _("Datos del tutor")))
        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) debe proveerse el argumento user_id
        elif "user_id" in request.args.keys():
            page = """<h2>""" + _("Informacion del tutor") + """</h2>"""
            d.addCallback(lambda a: request.write(page))
            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)
            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")))
        # 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):
        _ = request.getSession()._
        query = "select p.id, p.first_name, p.last_name from person p, \
            tutor t where t.id = p.id and p.id = %d"
        d.addCallback(lambda a: self.db.db.runQuery(query, (userId,)))
        d.addCallback(self.printData, request)
        query2 = "select name from tutor_subject, subject where \
            fk_subject = subject.id and fk_tutor = %d order by subject.id"
        d.addCallback(lambda a: self.db.db.runQuery(query2, (userId,)))
        d.addCallback(self.printSubject, request)
        query3 = "select t.time_start, t.time_end, t.schedule_type from \
           tutor_schedule t where fk_tutor = %d \
           order by schedule_type, time_start asc"
        d.addCallback(lambda a: self.db.db.runQuery(query3, (userId,)))
        d.addCallback(self.printSchedule, request)
        return d

    def printData(self, rows, request):
        # rows[0]: id
        # rows[1]: first_name
        # rows[2]: last_name
        _ = request.getSession()._
        if len(rows) != 1:
            string = '<div class="error">' + _("El usuario solicitado no existe") + "</div>"
        else:
            last_name = rows[0][2]
            first_name = rows[0][1]

            string = (
                '<table class="table_info" id="tutordata">'
                + '<tr><th class="header_userinfo">'
                + _("Nombre:")
                + "</th><td>%s</td></tr>" % first_name
            )

            string += '<tr><th class="header_userinfo">' + _("Apellido:") + "</th><td>%s</td></tr>" % last_name
        request.write(string)
        return
#.........这里部分代码省略.........

# 需要导入模块: from WebTemplates import WebTemplates [as 别名]
# 或者: from WebTemplates.WebTemplates import unexpectedArguments [as 别名]
class WebSendMail(Resource):
    fields = [{'name': 'subject', 'maxlength': 255},
        {'name': 'body', 'maxlength': 64000},
        {'name': 'username', 'maxlength': 255},
        {'name': 'user_id', 'maxlength': 255}]

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

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

    #Formulario para mandar mail con sugerencias, bugs, etc
    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, _('Criticas y sugerencias')))
        d = defer.maybeDeferred(lambda:None)
        # 1) Verificar que esté autenticado ante el sistema
        msg = """<h2>""" + _('Criticas y sugerencias') + """</h2>""" \
            + _('Desde aqui puede mandar sus criticas, sugerencias y comentarios.') + " " \
            + _('La comunicacion se realizara mediante la casilla de mail con la cual se ha registrado.')
        if not hasattr(session, 'username'):
            request.write(self.template.notAuthenticated(session))
        else:
        # La función que procesa e imprime el contenido de la pagina
            self.printContent(request, d, msg)
        # 2) Se termina la página
        d.addCallback(lambda a: request.write(self.template.finishPage(session)))
        d.addCallback(lambda a: request.finish())
        return d

    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'])))
        return args

    def printContent(self, request, d, page):
        session = request.getSession()
        args = self.checkRequest(d, request)
        user_id = session.userId
        query = "select username, id, email from person where id = %d"
        d.addCallback(lambda a: self.db.db.runQuery(query, (user_id,)))
        d.addCallback(self.mail, args, request, page)
        return d

    def mail(self, rows, args, request, page):
        session = request.getSession()
        _ = session._
        if len(rows) == 1:
            if "submit" in args.keys():
                if args['body'] != "":
                    subject = "[%s][%s] %s" % (rows[0][1], rows[0][0], args['subject'])
                    msg = MIMEText(args['body'], _charset='utf-8')
                    msg['Subject'] = Header(subject, 'utf-8')
                    msg['From'] = rows[0][2]
                    msg['To'] = MAIL_TO
                    try:
                        s = smtplib.SMTP(host = MAIL_HOST, port = MAIL_PORT)
                    	s.sendmail(MAIL_FROM, [msg['To']], msg.as_string())
                    except:
                        request.write(self.template.serverError(session, \
                            _('Error al intentar establecer la comunicacion')))
                    else:
                        s.close()
                        request.write("""<div class="message"><h2>""" + \
                        _('Mail enviado correctamente') + """</h2>""" + \
                        _('Agradecemos su colaboracion') + """</div>""")
                else:
                    request.write(self.template.unexpectedArguments(session, \
                        _('El texto del mail no debe ser vacio')))
        else:
            request.write(self.template.unexpectedArguments(session, \
                        _('El usuario no existe en el sistema')))
        request.write(page)
#.........这里部分代码省略.........