def getProfesores(self, unused_request):
        '''
        Devuelve una lista con todos los profesores registrados en el sistema, de forma simplificada (solo nombre y DNI)

        Llamada desde terminal:
        curl -X GET localhost:8001/_ah/api/helloworld/v1/profesores/getProfesores
        Llamada desde JavaScript:
        response =service.profesores.getProfesores().execute()
        '''
        #Identificación del módulo en el que estamos.
        module = modules.get_current_module_name()
        instance = modules.get_current_instance_id()

        #Leclear decimos a que microservicio queremos conectarnos (solo usando el nombre del mismo), GAE descubre su URL solo.
        url = "http://%s/" % modules.get_hostname(module="microservicio1")
        #Añadimos el recurso al que queremos conectarnos.
        url+="profesores"
        if v:
            print str(url)
        #Al no especificar nada se llama al método GET de la URL.
        result = urlfetch.fetch(url)
        if v:
            print result.content
        listaProfesores = jsonpickle.decode(result.content)

        #Creamos un vector
        profesoresItems= []
        #Que rellenamos con todo los profesores de la listaProfesores
        for profesore in listaProfesores:
            profesoresItems.append(Profesor( nombre=str(alumno.get('nombre')), dni=str(alumno.get('dni'))  ))

        #Los adaptamos al tipo de mensaje y enviamos
        #return Greeting(message=str(result.content))
        return ListaAlumnos(alumnos=alumnosItems)
Esempio n. 2
0
 def get(self):
   service = app_identity.get_application_id()
   version = modules.get_current_version_name()
   instance_id = hash(modules.get_current_instance_id()) % 10
   endpoint = MONACQ_ENDPOINT
   config.initialize(job_name=version, instance=instance_id,
                     service_name=service, endpoint=endpoint)
   self.response.set_status(200, 'Initialized instance of ts_mon.')
 def get(self):
     """A handler for /_ah/start, registering myself."""
     runtime.set_shutdown_hook(shutdown_hook)
     con = get_connection()
     with con:
         con.execute(CREATE_TABLE_SQL)
     instance_id = modules.get_current_instance_id()
     server = ActiveServer(key=ActiveServer.get_instance_key(instance_id))
     server.put()
Esempio n. 4
0
    def get(self):
        module = modules.get_current_module_name()
        instance = modules.get_current_instance_id()
        version = modules.get_current_version_name()

        self.complete('respond', {
            'module': module,
            'instance': instance,
            'version': version
        })
Esempio n. 5
0
    def get(self):
        module   = modules.get_current_module_name()
        instance = modules.get_current_instance_id()
        version  = modules.get_current_version_name()

        self.complete('respond', {
            'module': module,
            'instance': instance,
            'version': version
        })
Esempio n. 6
0
    def get(self):

        query = models.EmailHash.query()

        obj = [x for x in query.fetch() if x.uid is not None]

        self.response.headers['Content-Type'] = 'application/json'
        self.response.write(json.dumps(obj, cls=models.ModelEncoder))

        module = modules.get_current_module_name()
        instance_id = modules.get_current_instance_id()
Esempio n. 7
0
 def get(self):
     module = modules.get_current_module_name()
     instance = modules.get_current_instance_id()
     # self.response.write('Module {0}, instance {1}'.format(module, instance))
     current_games = games.Game.find_games()
     template_values = {
         'current_module_name': module,
         'current_instance_id': instance,
         'current_games': current_games
     }
     path = os.path.join(os.path.dirname(__file__), 'index.html')
     self.response.out.write(template.render(path, template_values))
Esempio n. 8
0
 def get(self):
     module = modules.get_current_module_name()
     instance = modules.get_current_instance_id()
     # self.response.write('Module {0}, instance {1}'.format(module, instance))
     current_games = games.Game.find_games()
     template_values = {
         'current_module_name': module,
         'current_instance_id': instance,
         'current_games': current_games
         }
     path = os.path.join(os.path.dirname(__file__), 'index.html')
     self.response.out.write(template.render(path, template_values))       
Esempio n. 9
0
 def get(self):
     self.response.headers['Content-Type'] = 'application/json'
     current_module = get_current_module_name()
     self.response.out.write(
         json.dumps({
             'modules': get_modules(),
             'current_module_versions': get_versions(current_module),
             'default_version': get_default_version(current_module),
             'current_module': current_module,
             'current_version': get_current_version_name(),
             'current_instance_id': get_current_instance_id()
         }))
 def get(self):
     """Display a 'Hello' message"""
     instance_id = modules.get_current_instance_id()
     message = 'Hello'
     if users.get_current_user():
         nick = users.get_current_user().nickname()
         message += ', %s' % nick
     template = JINJA_ENVIRONMENT.get_template('index.html')
     url, url_linktext = get_signin_navigation(self.request.uri)
     self.response.out.write(template.render(instance_url=get_url_for_instance(instance_id),
                                             url=url,
                                             url_linktext=url_linktext,
                                             message=message))
    def render(self, page, values):
        """
        Add module info to template values
        and render template
        """

        values['module'] = modules.get_current_module_name()
        values['instance'] = modules.get_current_instance_id()
        values['version'] = modules.get_current_version_name()
        values['handler'] = self.handlerName

        template = self.jinjaEnvironment.get_template(self.handlerName + '/' + page + '.html')

        self.response.out.write(template.render(values))
Esempio n. 12
0
 def get(self):
     """Display a 'Hello' message"""
     instance_id = modules.get_current_instance_id()
     message = 'Hello'
     if users.get_current_user():
         nick = users.get_current_user().nickname()
         message += ', %s' % nick
     template = JINJA_ENVIRONMENT.get_template('index.html')
     url, url_linktext = get_signin_navigation(self.request.uri)
     self.response.out.write(
         template.render(instance_url=get_url_for_instance(instance_id),
                         url=url,
                         url_linktext=url_linktext,
                         message=message))
    def getAlumno(self,request):
        print "GET CON PARÁMETROS EN ENDPOINT"

        #Cuando se llama a este recurso lo que se quiere es recibir toda la información
        #de una entidad Alumno, para ello primero vamos a recuperar la información del microsrevicio apropiado:

        #Conexión a un microservicio específico:
        module = modules.get_current_module_name()
        instance = modules.get_current_instance_id()

        #Le decimos al microservicio que queremos conectarnos (solo usando el nombre del mismo), GAE descubre su URL solo.
        url = "http://%s/" % modules.get_hostname(module="microservicio1")

        '''
        Según la doc. de urlfetch (ver arriba) no podemos pasar parámetros con el payload, así que como conocemos
        la api del microservicios al que vamos a llamr realizamos la petición bajo su especificacion, según la cual
        solo tenemos que llamar a /alumnos/<id_alumno> entonces concatenamos a la url esa id qu recibimos en la llamada
        a este procedimiento.
        '''
        #Recursos más entidad
        url+='alumnos/'+request.dni

        if v:
            print "calling: "+ url

        #Petición al microservicio
        result = urlfetch.fetch(url=url, method=urlfetch.GET)

        print "RESULTADO:"+str(result.status_code)
        #print result.content
        if v:
            print result.status_code
        if str(result.status_code) == '400':
            raise endpoints.BadRequestException('Peticion erronea')

        if str(result.status_code) == '404':
            raise endpoints.NotFoundException('Alumno con DNI %s no encontrado.' % (request.dni))

        alumno = jsonpickle.decode(result.content)

        return AlumnoCompleto(nombre=alumno.get('nombre'),
                                 dni=alumno.get('dni'),
                                 direccion=alumno.get('direccion'),
                                 localidad=alumno.get('localidad'),
                                 provincia=alumno.get('provincia'),
                                 fecha_nac=str(alumno.get('fecha_nac')),
                                 telefono=alumno.get('telefono')
                                )
 def getCursosAlumno(self, request):
     if v:
         print ("Ejecución de getCursosAlumno en apigateway")
     module = modules.get_current_module_name()
     instance = modules.get_current_instance_id()
     url = "http://%s/" % modules.get_hostname(module="microservicio1")
     url+='alumnos/'+request.dni+"/cursos"
     result = urlfetch.fetch(url)
     if v:
         print result.content
     listaCursos = jsonpickle.decode(result.content)
     print listaCursos
     cursosItems= []
     for curso in listaCursos:
         cursosItems.append(Curso(id=str(curso.get('id')),curso=str(curso.get('nombre')),grupo=str(curso.get('grupo')),nivel=str(curso.get('nivel'))))
     return ListaCursos(cursos=cursosItems)
 def getAsignaturasAlumno(self, request):
     if v:
         print ("Ejecución de getAsignaturasAlumno en apigateway")
     module = modules.get_current_module_name()
     instance = modules.get_current_instance_id()
     url = "http://%s/" % modules.get_hostname(module="microservicio1")
     url+='alumnos/'+request.dni+"/asignaturas"
     result = urlfetch.fetch(url)
     if v:
         print result.content
     listaAsignaturas = jsonpickle.decode(result.content)
     print listaAsignaturas
     asignaturasItems= []
     for asignatura in listaAsignaturas:
         asignaturasItems.append( Asignatura( id=str(asignatura.get('id')), nombre=str(asignatura.get('nombre')) ) )
     return ListaAsignaturas(asignaturas=asignaturasItems)
Esempio n. 16
0
    def getAlumnos(self, unused_request):
        #Transformación de la llamada al endpoints a la llamada a la api rest del servicio.

        print("Llamando a una función específica")

        #Conexión a un microservicio específico:

        module = modules.get_current_module_name()
        instance = modules.get_current_instance_id()

        #Le decimos a que microservicio queremos conectarnos (solo usando el nombre del mismo), GAE descubre su URL solo.
        url = "http://%s/" % modules.get_hostname(module="microservicio1")
        #Añadimos el recurso al que queremos conectarnos.
        url += "alumnos"
        print str(url)
        #result = urllib2.urlopen(url)
        #print result

        #Llamamos al microservicio y recibimos los resultados con URLFetch
        #Al no especificar nada se llama al método GET de la URL.
        result = urlfetch.fetch(url)

        #Vamos a intentar consumir los datos en JSON y convertirlos a un mensje enviable :)

        print "IMPRESION DE LOS DATOS RECIBIDOS"
        print result.content
        listaAlumnos = jsonpickle.decode(result.content)

        for alumno in listaAlumnos:
            print "nombre: " + str(alumno.get('nombre'))
            print "dni: " + str(alumno.get('dni'))
        '''
        miListaAlumnos=ListaAlumnos()
        miListaAlumnos.alumnos = listaAlumnos
        '''

        #Creamos un vector
        alumnosItems = []
        #Que rellenamos con todo los alumnos de la listaAlumnos
        for alumno in listaAlumnos:
            alumnosItems.append(
                Alumno(nombre=str(alumno.get('nombre')),
                       dni=str(alumno.get('dni'))))

        #Los adaptamos al tipo de mensaje y enviamos
        #return Greeting(message=str(result.content))
        return ListaAlumnos(alumnos=alumnosItems)
Esempio n. 17
0
    def getAlumno(self, request):
        print "GET CON PARÁMETROS EN ENDPOINT"

        #Cuando se llama a este recurso lo que se quiere es recibir toda la información
        #de una entidad Alumno, para ello primero vamos a recuperar la información del microsrevicio apropiado:

        #Conexión a un microservicio específico:
        module = modules.get_current_module_name()
        instance = modules.get_current_instance_id()

        #Le decimos al microservicio que queremos conectarnos (solo usando el nombre del mismo), GAE descubre su URL solo.
        url = "http://%s/" % modules.get_hostname(module="microservicio1")
        '''
        Según la doc. de urlfetch (ver arriba) no podemos pasar parámetros con el payload, así que como conocemos
        la api del microservicios al que vamos a llamr realizamos la petición bajo su especificacion, según la cual
        solo tenemos que llamar a /alumnos/<id_alumno> entonces concatenamos a la url esa id qu recibimos en la llamada
        a este procedimiento.
        '''
        #Recursos más entidad
        url += 'alumnos/' + request.dni

        if v:
            print "calling: " + url

        #Petición al microservicio
        result = urlfetch.fetch(url=url, method=urlfetch.GET)

        print "RESULTADO:" + str(result.status_code)
        #print result.content
        if v:
            print result.status_code
        if str(result.status_code) == '400':
            raise endpoints.BadRequestException('Peticion erronea')

        if str(result.status_code) == '404':
            raise endpoints.NotFoundException(
                'Alumno con DNI %s no encontrado.' % (request.dni))

        alumno = jsonpickle.decode(result.content)

        return AlumnoCompleto(nombre=alumno.get('nombre'),
                              dni=alumno.get('dni'),
                              direccion=alumno.get('direccion'),
                              localidad=alumno.get('localidad'),
                              provincia=alumno.get('provincia'),
                              fecha_nac=str(alumno.get('fecha_nac')),
                              telefono=alumno.get('telefono'))
    def getAlumnos(self, unused_request):
        #Transformación de la llamada al endpoints a la llamada a la api rest del servicio.

        print ("Llamando a una función específica")

        #Conexión a un microservicio específico:

        module = modules.get_current_module_name()
        instance = modules.get_current_instance_id()

        #Le decimos a que microservicio queremos conectarnos (solo usando el nombre del mismo), GAE descubre su URL solo.
        url = "http://%s/" % modules.get_hostname(module="microservicio1")
        #Añadimos el recurso al que queremos conectarnos.
        url+="alumnos"
        print str(url)
        #result = urllib2.urlopen(url)
        #print result

        #Llamamos al microservicio y recibimos los resultados con URLFetch
        #Al no especificar nada se llama al método GET de la URL.
        result = urlfetch.fetch(url)

        #Vamos a intentar consumir los datos en JSON y convertirlos a un mensje enviable :)

        print "IMPRESION DE LOS DATOS RECIBIDOS"
        print result.content
        listaAlumnos = jsonpickle.decode(result.content)

        for alumno in listaAlumnos:
            print "nombre: "+str(alumno.get('nombre'))
            print "dni: "+str(alumno.get('dni'))

        '''
        miListaAlumnos=ListaAlumnos()
        miListaAlumnos.alumnos = listaAlumnos
        '''

        #Creamos un vector
        alumnosItems= []
        #Que rellenamos con todo los alumnos de la listaAlumnos
        for alumno in listaAlumnos:
            alumnosItems.append(Alumno( nombre=str(alumno.get('nombre')), dni=str(alumno.get('dni'))  ))

        #Los adaptamos al tipo de mensaje y enviamos
        #return Greeting(message=str(result.content))
        return ListaAlumnos(alumnos=alumnosItems)
Esempio n. 19
0
 def getAsignaturasAlumno(self, request):
     if v:
         print("Ejecución de getAsignaturasAlumno en apigateway")
     module = modules.get_current_module_name()
     instance = modules.get_current_instance_id()
     url = "http://%s/" % modules.get_hostname(module="microservicio1")
     url += 'alumnos/' + request.dni + "/asignaturas"
     result = urlfetch.fetch(url)
     if v:
         print result.content
     listaAsignaturas = jsonpickle.decode(result.content)
     print listaAsignaturas
     asignaturasItems = []
     for asignatura in listaAsignaturas:
         asignaturasItems.append(
             Asignatura(id=str(asignatura.get('id')),
                        nombre=str(asignatura.get('nombre'))))
     return ListaAsignaturas(asignaturas=asignaturasItems)
    def getProfesoreAlumno(self, request):
        #Transformación de la llamada al endpoints a la llamada a la api rest del servicio.
        if v:
            print ("Ejecución de getProfesoresAlumno en apigateway")

        #Conexión a un microservicio específico:

        module = modules.get_current_module_name()
        instance = modules.get_current_instance_id()
        #Le decimos a que microservicio queremos conectarnos (solo usando el nombre del mismo), GAE descubre su URL solo.
        url = "http://%s/" % modules.get_hostname(module="microservicio1")

        #Añadimos a la url la coleccion (alumnos), el recurso (alumno dado por su dni) y el recurso anidado de este (profesores)
        url+='alumnos/'+request.dni+"/profesores"

        #Realizamos la petición
        result = urlfetch.fetch(url)

        #Vamos a intentar consumir los datos en JSON y convertirlos a un mensje enviable :)

        print "IMPRESION DE LOS DATOS RECIBIDOS"
        print result.content
        listaProfesores = jsonpickle.decode(result.content)

        #Creamos un vector
        profesoresItems= []
        #Que rellenamos con todo los alumnos de la listaAlumnos
        for profesor in listaProfesores:
            profesoresItems.append(ProfesorCompleto( nombre=str(profesor.get('nombre')),
                                           dni=str(profesor.get('dni')),
                                           direccion=str(profesor.get('direccion')),
                                           localidad=str(profesor.get('localidad')),
                                           provincia=str(profesor.get('provincia')),
                                           fecha_nac=str(profesor.get('fecha_nac')),
                                           telefonoA=str(profesor.get('telefonoA')),
                                           telefonoB=str(profesor.get('telefonoB'))
                                         )
                                )

        #Los adaptamos al tipo de mensaje y enviamos
        #return Greeting(message=str(result.content))
        return ListaProfesores(profesores=profesoresItems)
Esempio n. 21
0
 def getCursosAlumno(self, request):
     if v:
         print("Ejecución de getCursosAlumno en apigateway")
     module = modules.get_current_module_name()
     instance = modules.get_current_instance_id()
     url = "http://%s/" % modules.get_hostname(module="microservicio1")
     url += 'alumnos/' + request.dni + "/cursos"
     result = urlfetch.fetch(url)
     if v:
         print result.content
     listaCursos = jsonpickle.decode(result.content)
     print listaCursos
     cursosItems = []
     for curso in listaCursos:
         cursosItems.append(
             Curso(id=str(curso.get('id')),
                   curso=str(curso.get('nombre')),
                   grupo=str(curso.get('grupo')),
                   nivel=str(curso.get('nivel'))))
     return ListaCursos(cursos=cursosItems)
Esempio n. 22
0
    def getProfesoreAlumno(self, request):
        #Transformación de la llamada al endpoints a la llamada a la api rest del servicio.
        if v:
            print("Ejecución de getProfesoresAlumno en apigateway")

        #Conexión a un microservicio específico:

        module = modules.get_current_module_name()
        instance = modules.get_current_instance_id()
        #Le decimos a que microservicio queremos conectarnos (solo usando el nombre del mismo), GAE descubre su URL solo.
        url = "http://%s/" % modules.get_hostname(module="microservicio1")

        #Añadimos a la url la coleccion (alumnos), el recurso (alumno dado por su dni) y el recurso anidado de este (profesores)
        url += 'alumnos/' + request.dni + "/profesores"

        #Realizamos la petición
        result = urlfetch.fetch(url)

        #Vamos a intentar consumir los datos en JSON y convertirlos a un mensje enviable :)

        print "IMPRESION DE LOS DATOS RECIBIDOS"
        print result.content
        listaProfesores = jsonpickle.decode(result.content)

        #Creamos un vector
        profesoresItems = []
        #Que rellenamos con todo los alumnos de la listaAlumnos
        for profesor in listaProfesores:
            profesoresItems.append(
                ProfesorCompleto(nombre=str(profesor.get('nombre')),
                                 dni=str(profesor.get('dni')),
                                 direccion=str(profesor.get('direccion')),
                                 localidad=str(profesor.get('localidad')),
                                 provincia=str(profesor.get('provincia')),
                                 fecha_nac=str(profesor.get('fecha_nac')),
                                 telefonoA=str(profesor.get('telefonoA')),
                                 telefonoB=str(profesor.get('telefonoB'))))

        #Los adaptamos al tipo de mensaje y enviamos
        #return Greeting(message=str(result.content))
        return ListaProfesores(profesores=profesoresItems)
Esempio n. 23
0
    def getProfesores(self, unused_request):
        '''
        Devuelve una lista con todos los profesores registrados en el sistema, de forma simplificada (solo nombre y DNI)

        Llamada desde terminal:
        curl -X GET localhost:8001/_ah/api/helloworld/v1/profesores/getProfesores
        Llamada desde JavaScript:
        response =service.profesores.getProfesores().execute()
        '''
        #Identificación del módulo en el que estamos.
        module = modules.get_current_module_name()
        instance = modules.get_current_instance_id()

        #Leclear decimos a que microservicio queremos conectarnos (solo usando el nombre del mismo), GAE descubre su URL solo.
        url = "http://%s/" % modules.get_hostname(module="microservicio1")
        #Añadimos el recurso al que queremos conectarnos.
        url += "profesores"
        if v:
            print str(url)
        #Al no especificar nada se llama al método GET de la URL.
        result = urlfetch.fetch(url)
        if v:
            print result.content
        listaProfesores = jsonpickle.decode(result.content)

        #Creamos un vector
        profesoresItems = []
        #Que rellenamos con todo los profesores de la listaProfesores
        for profesore in listaProfesores:
            profesoresItems.append(
                Profesor(nombre=str(alumno.get('nombre')),
                         dni=str(alumno.get('dni'))))

        #Los adaptamos al tipo de mensaje y enviamos
        #return Greeting(message=str(result.content))
        return ListaAlumnos(alumnos=alumnosItems)
Esempio n. 24
0
 def get(self):
     # [START module_info]
     module = modules.get_current_module_name()
     instance_id = modules.get_current_instance_id()
     self.response.write('module_id={}&instance_id={}'.format(
         module, instance_id))
Esempio n. 25
0
def instance_key_id():
    return '%s.%s.%s' % (modules.get_current_instance_id(),
                         modules.get_current_version_name(),
                         modules.get_current_module_name())
def shutdown_hook():
    """A hook function for de-registering myself."""
    logging.info('shutdown_hook called.')
    instance_id = modules.get_current_instance_id()
    ndb.transaction(
        lambda: ActiveServer.get_instance_key(instance_id).delete())
Esempio n. 27
0
JINJA_ENVIRONMENT = jinja2.Environment(
    loader=jinja2.FileSystemLoader(os.path.dirname(__file__)),
    extensions=['jinja2.ext.autoescape'],
    autoescape=True)

UNIQUE_ID_LENGTH = 32
UID_LENGTH = 32
EPOCH_STRING_LENGTH = 10
GEOCELL_RESOLUTION = 10
MESSAGE_FORMAT_VERSION = '0'
MESSAGE_LIST_MAX_COUNT = 100
PERMANENT_GCM_ERRORS = {'InvalidRegistration', 'NotRegistered',
                        'InvalidPackageName', 'MismatchSenderId'}
VERSION = modules.get_current_version_name()
if modules.get_current_version_name() is None:
  VERSION = modules.get_current_instance_id()


def IsDevAppserver():
  return os.environ['SERVER_SOFTWARE'].startswith('Development/')

def GetSecretKeys():
  f = open('secret_keys.json', 'r')
  keys = json.loads(f.read())
  f.close()
  return keys

SECRET_KEYS = GetSecretKeys()
WEBAPP2_CONFIG = {
    'webapp2_extras.sessions': {
        'secret_key': SECRET_KEYS['webapp2_secret_key'].encode(),
Esempio n. 28
0
 def get(self):
     # [START module_info]
     module = modules.get_current_module_name()
     instance_id = modules.get_current_instance_id()
     self.response.write(
         'module_id={}&instance_id={}'.format(module, instance_id))
Esempio n. 29
0
from flask.ext.cors import CORS, cross_origin
from google.appengine.api import modules
import requests_toolbelt.adapters.appengine

# Use the App Engine Requests adapter. This makes sure that Requests uses URLFetch.
requests_toolbelt.adapters.appengine.monkeypatch()

app = Flask(__name__)

cors = CORS(app, resources={r"/*": {"origins": "*"}})

# Activating verbose mode
v = 1

module = modules.get_current_module_name()
instance = modules.get_current_instance_id()

from tdbms_segment.tdbms_api_segment import tdbms_segment_api
from scms_segment.scms_marks_api_segment import marks_api
from scms_segment.disciplinary_notes_api_segment import disciplinary_notes_api
from scms_segment.attendance_controls_api_segment import attendance_controls_api


@app.route('/helloworld', methods=['GET'])
def hello_world():
    """
     Test resource.

    :return:

     Example of use:
Esempio n. 30
0
def instance_key_id():
  return '%s.%s.%s' % (
      modules.get_current_instance_id(),
      modules.get_current_version_name(),
      modules.get_current_module_name())