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)
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()
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
})
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
})
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()
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))
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))
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))
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)
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)
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)
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)
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 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)
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)
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))
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())
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(),
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))
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:
def instance_key_id():
return '%s.%s.%s' % (
modules.get_current_instance_id(),
modules.get_current_version_name(),
modules.get_current_module_name())