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): 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): 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())