def namespace_manager_default_namespace_for_request():
if MULTITENANCY:
try:
return modules.get_current_version_name()
except:
return namespace_manager.google_apps_namespace()
else:
return namespace_manager.google_apps_namespace()
def namespace_manager_default_namespace_for_request():
try:
if get_current_user():
return get_current_user().user_id()
elif self.request.remote_addr:
return self.request.remote_addr
else:
return namespace_manager.google_apps_namespace()
except:
return namespace_manager.google_apps_namespace()
def namespace_manager_default_namespace_for_request():
"""Determine which namespace is to be used for a request.
The value of _NAMESPACE_PICKER has the following effects:
If _USE_SERVER_NAME, we read server name
foo.guestbook-isv.appspot.com and set the namespace.
If _USE_GOOGLE_APPS_DOMAIN, we allow the namespace manager to infer
the namespace from the request.
If _USE_COOKIE, then the ISV might have a gateway page that sets a
cookie called 'namespace', and we set the namespace to the cookie's value
"""
name = None
if _NAMESPACE_PICKER == _USE_SERVER_NAME:
name = os.environ['SERVER_NAME']
elif _NAMESPACE_PICKER == _USE_GOOGLE_APPS_DOMAIN:
name = namespace_manager.google_apps_namespace()
elif _NAMESPACE_PICKER == _USE_COOKIE:
cookies = os.environ.get('HTTP_COOKIE', None)
if cookies:
name = Cookie.BaseCookie(cookies).get('namespace')
return name
def namespace_manager_default_namespace_for_request():
session = sessions.get_store()
s = session.get_session()
name = s.get('school-id')
if name:
return name
else:
return namespace_manager.google_apps_namespace()
def get(self):
user = users.get_current_user()
authz = Authorize()
if not authz.authorize():
self.error(403)
return
class_id = self.request.get('class_id')
class_key = ndb.Key('Class', int(class_id))
the_class = class_key.get()
the_class.id = the_class.key.id()
date_ordinal = self.request.get('date')
errmsg = self.request.get('errmsg')
today_as_ordinal = self.today_as_ordinal(the_class.timezone)
if not date_ordinal:
date_ordinal = today_as_ordinal
if int(date_ordinal) == today_as_ordinal:
today = True
else:
today = False
date_struct = datetime.date.fromordinal(int(date_ordinal))
attendance_key = ndb.Key('Class', int(class_id), 'Attendance', int(date_ordinal))
attendance = attendance_key.get()
students = ndb.get_multi(the_class.enrolled)
students.sort(key= lambda x: x.first_name, reverse=False)
for student in students:
student.present = False
student.hours = the_class.default_hours
student.id = student.key.id()
if attendance:
for student_present in attendance.attending:
if student_present.student == student.key:
student.present = True
student.hours = student_present.hours
break
school = namespace_manager.google_apps_namespace()
if not school: school = 'Test school'
template_values = { 'students': students,
'date_ordinal': date_ordinal,
'today': today,
'class': the_class,
'school': school,
'date_struct': date_struct,
'username': authz.get_name(),
'errmsg': errmsg }
path = os.path.join(os.path.dirname(__file__), 'templates/students.html')
self.response.out.write(template.render(path, template_values))
def render_to_template(self,template_values, template_name=None):
values ={
'auth_formurl': admin_url('authorize-dropbox'),
'formurl': admin_url(),
'apps_namespace' : namespace_manager.google_apps_namespace(),
'current_namespace' : namespace_manager.get_namespace(),
'server_name' : os.environ['SERVER_NAME'],
'settings' : config.TEMPLATE_SETTINGS,
'user' : users.get_current_user(),
'login_url': users.create_login_url(admin_url()),
'logout_url': users.create_logout_url(admin_url()),
'request': self.request, #e.g. for request.url
}
values.update(template_values)
template_path=os.path.join('templates',template_name)
self.response.out.write( template.render(template_path, values))
def render_to_template(self, template_values, template_name=None):
values = {
'auth_formurl': admin_url('authorize-dropbox'),
'formurl': admin_url(),
'apps_namespace': namespace_manager.google_apps_namespace(),
'current_namespace': namespace_manager.get_namespace(),
'server_name': os.environ['SERVER_NAME'],
'settings': config.TEMPLATE_SETTINGS,
'user': users.get_current_user(),
'login_url': users.create_login_url(admin_url()),
'logout_url': users.create_logout_url(admin_url()),
'request': self.request, #e.g. for request.url
}
values.update(template_values)
template_path = os.path.join('templates', template_name)
self.response.out.write(template.render(template_path, values))
def get(self):
authz = Authorize()
if not authz.authorize():
self.error(403)
return
query = Class.query()
# Max classes that can be handled is 50 per school
classes = query.fetch(50)
for the_class in classes:
the_class.id = the_class.key.id()
school = namespace_manager.google_apps_namespace()
if not school: school = 'Test school'
template_values = { 'classes': classes,
'school': school,
'username': authz.get_name(),
'logout': users.create_logout_url("/") }
path = os.path.join(os.path.dirname(__file__), 'templates/classes.html')
self.response.out.write(template.render(path, template_values))
def __init__(self,config=False,**kwargs):
if config is False:
raise exceptions.ConfigRequired()
else:
self.config = config
# :: Namespace is usually extracted from subdomain - set via initialized keyword parameter
if self.config.get('enable','multitenancy',False):
_m_log = self.config.get('logging','multitenancy',False)
if self.config.get('force_namespace','multitenancy', False):
if isinstance(self.config.get('force_namespace','multitenancy',False), (str, unicode)) and self.config.get('force_namespace','multitenancy',False) is not '':
if namespace_manager.validate_namespace(self.config.get('force_namespace','multitenancy',False)):
if _m_log: logging.info('[i]: Setting request namespace to \''+config_get('force_namespace','multitenancy',False)+'\'.')
namespace_manager.set_namespace(self.config.get('force_namespace','multitenancy',False))
else:
if 'namespace' in kwargs or self.config.get('apps_mode_force', 'multitenancy', False):
if kwargs['namespace'] == self.config.get('apps_subdomain','multitenancy','apps') or self.config.get('apps_mode_force', 'multitenancy', False):
if _m_log: logging.info('[i]: Setting request namespace to \''+namespace_manager.google_apps_namespace()+'\' per APPS procedure.')
namespace_manager.set_namespace(namespace_manager.google_apps_namespace())
else:
if isinstance(kwargs['namespace'], (str, unicode)) and namespace_manager.validate_namespace(kwargs['namespace']):
if _m_log: logging.info('[i]: Setting request namespace to \''+kwargs['namespace']+'\' per domain split procedure.')
namespace_manager.set_namespace(kwargs['namespace'])
else:
if kwargs['namespace'] is not None:
if _m_log: logging.info('[i]: Given namespace \''+str(kwargs['namespace'])+'\' failed to pass validation. Ignoring.')
if 'version' in kwargs:
self.version = kwargs['version']
super(Platform, self).__init__()
def namespace_manager_default_namespace_for_request():
if namespace_manager:
return namespace_manager.google_apps_namespace()
else:
# In local development SDK, namespace_manager is None
return None
def namespace_manager_default_namespace_for_request():
from google.appengine.api import namespace_manager
return namespace_manager.google_apps_namespace()
def __init__(self,config_override=None, *args, **kwargs):
## Setup globals
global version_major
global version_minor
global config_module
global import_item
global build
version = {'major':version_major,'minor':version_minor,'full':str(version_major)+'.'+str(version_minor)+' '+str(build),'build':build}
## Path Inserts
if '.' not in sys.path:
sys.path.insert(0,'.')
sys.path.insert(1,'lib')
sys.path.insert(2, 'distlib')
## Setup capabilities sets
_cap = capabilities.CapabilitySet
## Setup object proxies
self.config = c_config.PCConfigProxy()
self.log = c_log.PCLogProxy()
self.clock = c_clock.PCClockProxy()
self.state = c_state.PCStateProxy()
self.api = c_api.PCAPIProxy()
self.ext = c_ext.PCExtProxy()
## Link up with Platform
self.api._setPlatformParent(self)
self.log._setPlatformParent(self)
self.state._setPlatformParent(self)
self.clock._setPlatformParent(self)
self.ext._setPlatformParent(self)
self.config._setPlatformParent(self)
## Setup initial state
self.state.set('env',os.environ)
self.state.set('quotas', None)
self.state.set('namespace',namespace_manager.get_namespace())
self.state.set('capabilities', {'api':{
'images':{
'enabled':_cap('images').is_enabled(),
'crop':_cap('images',methods=['crop']).is_enabled(),
'get_serving_url':_cap('images',methods=['get_serving_url']).is_enabled(),
'resize':_cap('images',methods=['resize']).is_enabled(),
'rotate':_cap('images',methods=['rotate']).is_enabled()},
'datastore_v3':{
'enabled':_cap('datastore_v3').is_enabled(),
'write':_cap('datastore_v3',capabilities=['write']).is_enabled(),
'read':_cap('datastore_v3',capabilities=['read']).is_enabled(),
'put':_cap('datastore_v3',methods=['put']).is_enabled(),
'delete':_cap('datastore_v3',methods=['delete']).is_enabled(),
'get':_cap('datastore_v3',methods=['get']).is_enabled(),
'run_in_transaction':_cap('datastore_v3',methods=['run_in_transaction']).is_enabled(),
'run_in_transaction_custom_retries':_cap('datastore_v3',methods=['run_in_transaction']).is_enabled()},
'users':{
'enabled':_cap('users').is_enabled(),
'get_current_user':_cap('users',methods=['get_current_user']).is_enabled(),
'is_current_user_admin':_cap('users',methods=['is_current_user_admin']).is_enabled()},
'mail':{
'enabled':_cap('mail').is_enabled(),
'send_mail':_cap('mail',methods=['send_mail']).is_enabled(),
'send_mail_to_admins':_cap('mail',methods=['send_mail_to_admins']).is_enabled()},
'memcache':{
'enabled':_cap('memcache').is_enabled(),
'get':_cap('memcache',methods=['get']).is_enabled(),
'set':_cap('memcache',methods=['set']).is_enabled(),
'delete':_cap('memcache',methods=['delete']).is_enabled()},
'oauth':{
'enabled':_cap('oauth').is_enabled(),
'get_current_user':_cap('oauth',methods=['get_current_user']).is_enabled(),
'is_current_user_admin':_cap('oauth',methods=['is_current_user_admin']).is_enabled()},
'multitenancy':{
'enabled':_cap('multitenancy').is_enabled(),
'get_namespace':_cap('multitenancy',methods=['get_namespace']).is_enabled(),
'set_namespace':_cap('multitenancy',methods=['set_namespace']).is_enabled()},
'blobstore':{
'enabled':_cap('blobstore').is_enabled(),
'get':_cap('blobstore',methods=['get']).is_enabled(),
'delete':_cap('blobstore',methods=['delete']).is_enabled()},
'xmpp':{
'enabled':_cap('xmpp').is_enabled(),
'send_message':_cap('xmpp',methods=['send_message']).is_enabled(),
'send_invite':_cap('xmpp',methods=['send_invite']).is_enabled()},
'urlfetch':{
'enabled':_cap('urlfetch').is_enabled(),
'fetch':_cap('urlfetch',methods=['fetch']).is_enabled()}
}
})
## Load/resolve Config
if config_override is None:
config_mod, props = import_helper(['ProvidenceClarity','pc_config'],['get','dump','config'])
elif config_override is False or config_override == '':
raise exceptions.ConfigRequired()
else:
if isinstance(config_override, type(os)):
config_mod = config_override
elif isinstance(config_override, (str, basestring, unicode)):
config_mod, props = import_helper(config_override,['get','dump','config'])
elif isinstance(config_override, list):
config_mod, props = import_helper('.'.join(config_override))
else:
try:
config_mod, props = import_helper(['ProvidenceClarity',config_override],['get','dump','config'])
except ImportError: raise exceptions.InvalidConfig()
## Set configuration
self.config.setConfig(config_mod)
## Environment Vars - Split for Namespace
software_t = '/'.split(os.environ['SERVER_SOFTWARE'])
if software_t[0].lower() == 'development': platform = 'Dev';
else: platform = 'Production'
domain = os.environ['HTTP_HOST'].split(':')[0].split('.')
if domain[-1] == 'com':
subdomain = domain[0]
else:
subdomain = None
# :: Namespace is usually extracted from subdomain - set via initialized keyword parameter
if self.config.get('enable','multitenancy',False):
_m_log = self.config.get('logging','multitenancy',False)
if self.config.get('force_namespace','multitenancy', False):
if isinstance(self.config.get('force_namespace','multitenancy',False), (str, unicode)) and self.config.get('force_namespace','multitenancy',False) is not '':
if namespace_manager.validate_namespace(self.config.get('force_namespace','multitenancy',False)):
if _m_log: self.log.info('Setting request namespace to "%s".' % config_get('force_namespace','multitenancy',False))
namespace_manager.set_namespace(self.config.get('force_namespace','multitenancy',False))
else:
if 'namespace' in kwargs or self.config.get('apps_mode_force', 'multitenancy', False):
if kwargs['namespace'] == self.config.get('apps_subdomain','multitenancy','apps') or self.config.get('apps_mode_force', 'multitenancy', False):
if _m_log: self.log.info('Setting request namespace to Google Apps domain "%s".' % namespace_manager.google_apps_namespace())
namespace_manager.set_namespace(namespace_manager.google_apps_namespace())
else:
if isinstance(kwargs['namespace'], (str, unicode)) and namespace_manager.validate_namespace(kwargs['namespace']):
if _m_log: self.log.info('Setting request namespace to split domain "%s".' % kwargs['namespace'])
namespace_manager.set_namespace(kwargs['namespace'])
else:
if kwargs['namespace'] is not None:
if _m_log: self.log.info('Given namespace "%s" failed to pass validation. Ignoring.' % str(kwargs['namespace']))
if 'version' in kwargs:
self.version = kwargs['version']
else:
self.version = version
super(Platform, self).__init__(*args, **kwargs)
def namespace_manager_default_namespace_for_request():
# The returned string will be used as the Google Apps domain.
return namespace_manager.google_apps_namespace()
def namespace_manager_default_namespace_for_request():
# The returned string will be used as the Google Apps domain.
return namespace_manager.google_apps_namespace()
def namespace_manager_default_namespace_for_request():
# name = os.environ['SERVER_NAME']
name = namespace_manager.google_apps_namespace()
return name
def namespace_manager_default_namespace_for_request():
# name = os.environ['SERVER_NAME']
name = namespace_manager.google_apps_namespace()
return name
def namespace_manager_default_namespace_for_request():
if namespace_manager:
return namespace_manager.google_apps_namespace()
else:
# In local development SDK, namespace_manager is None
return None
