def process_request(self, request):
"""
Resets to public schema
Some nasty weird bugs happened at the production environment without this call.
connection.pg_thread.schema_name would already be set and then terrible errors
would occur. Any idea why? My theory is django implements connection as some sort
of threading local variable.
"""
connection.set_schema_to_public()
hostname_without_port = remove_www_and_dev(request.get_host().split(':')[0])
TenantModel = get_tenant_model()
request.tenant = get_object_or_404(TenantModel, domain_url=hostname_without_port)
connection.set_tenant(request.tenant)
# content type can no longer be cached as public and tenant schemas have different
# models. if someone wants to change this, the cache needs to be separated between
# public and shared schemas. if this cache isn't cleared, this can cause permission
# problems. for example, on public, a particular model has id 14, but on the tenants
# it has the id 15. if 14 is cached instead of 15, the permissions for the wrong
# model will be fetched.
ContentType.objects.clear_cache()
# do we have a public-specific token?
if hasattr(settings, 'PUBLIC_SCHEMA_URL_TOKEN') and request.tenant.schema_name == get_public_schema_name():
request.path_info = settings.PUBLIC_SCHEMA_URL_TOKEN + request.path_info
def get_tenant(self, host):
hostname_without_port = remove_www_and_dev(host.split(":")[0])
print hostname_without_port
try:
return self.TenantModel.objects.get(domain_url=hostname_without_port)
except Exception as e:
return self.TenantModel.objects.get(pk=1)
def process_request(self, request):
connection.set_schema_to_public()
hostname_without_port = remove_www_and_dev(
request.get_host().split(':')[0])
TenantModel = get_tenant_model()
try:
request.tenant = TenantModel.objects.get(
domain_url=hostname_without_port)
except utils.DatabaseError:
request.urlconf = settings.PUBLIC_SCHEMA_URLCONF
return
except TenantModel.DoesNotExist:
if hostname_without_port in ("127.0.0.1", "localhost", "multidemo.com"):
request.urlconf = settings.PUBLIC_SCHEMA_URLCONF
return
else:
raise Http404
connection.set_tenant(request.tenant)
ContentType.objects.clear_cache()
if hasattr(settings, "PUBLIC_SCHEMA_URLCONF") and request.tenant.schema_name == get_public_schema_name():
request.urlconf = settings.PUBLIC_SCHEMA_URLCONF
if hasattr(settings, "API_URLCONF") and request.tenant.name == 'API':
self.urlconf = settings.API_URLCONF
def process_request(self, request):
"""
Resets to public schema
Some nasty weird bugs happened at the production environment without this call.
connection.pg_thread.schema_name would already be set and then terrible errors
would occur. Any idea why? My theory is django implements connection as some sort
of threading local variable.
"""
connection.set_schema_to_public()
hostname_without_port = remove_www_and_dev(
request.get_host().split(':')[0])
TenantModel = get_tenant_model()
request.tenant = get_object_or_404(TenantModel,
domain_url=hostname_without_port)
connection.set_tenant(request.tenant)
# do we have tenant-specific URLs?
if hasattr(
settings, 'PUBLIC_SCHEMA_URL_TOKEN'
) and request.tenant.schema_name == "public" and request.path_info[
-1] == '/':
# we are not at the public schema, manually alter routing to schema-dependent urls
request.path_info = settings.PUBLIC_SCHEMA_URL_TOKEN + request.path_info
def process_request(self, request):
connection.set_schema_to_public()
hostname_without_port = remove_www_and_dev(
request.get_host().split(':')[0])
TenantModel = get_tenant_model()
try:
request.tenant = TenantModel.objects.get(
domain_url=hostname_without_port)
except utils.DatabaseError:
request.urlconf = settings.ROOT_URLCONF
return
except TenantModel.DoesNotExist:
if hostname_without_port in ("127.0.0.1", "localhost"):
request.urlconf = settings.ROOT_URLCONF
return
else:
raise Http404
connection.set_tenant(request.tenant)
# ContentType.objects.clear_cache()
# Session.objects.all().delete()
if hasattr(
settings, 'ROOT_URLCONF'
) and request.tenant.schema_name == get_public_schema_name():
request.urlconf = settings.ROOT_URLCONF
def auth_login(request):
# Documentação de autenticação na url abaixo:
# https://docs.djangoproject.com/en/dev/topics/auth/default/
context = {'hostname': remove_www_and_dev(request.get_host().split('.')[0])}
if request.method == 'POST':
username = request.POST['email']
password = request.POST['password']
user = authenticate(username=username, password=password)
if user is not None:
if user.is_active:
login(request, user)
return HttpResponseRedirect('/')
return render(request, 'customers/login.html', context)
else:
if request.user.is_authenticated():
return HttpResponseRedirect('/')
else:
return render(request, 'customers/login.html', context)
def process_request(self, request):
"""
Resets to public schema
Some nasty weird bugs happened at the production environment without this call.
connection.pg_thread.schema_name would already be set and then terrible errors
would occur. Any idea why? My theory is django implements connection as some sort
of threading local variable.
"""
connection.set_schema_to_public()
hostname_without_port = remove_www_and_dev(request.get_host().split(':')[0])
TenantModel = get_tenant_model()
request.tenant = get_object_or_404(TenantModel, domain_url=hostname_without_port)
connection.set_tenant(request.tenant)
# do we have tenant-specific URLs?
if settings.TENANT_URL_TOKEN and request.tenant.schema_name != "public" and request.path_info[-1] == '/':
# we are not at the public schema, manually alter routing to schema-dependent urls
request.path_info = settings.TENANT_URL_TOKEN + request.path_info
def get_context_data(self, **kwargs):
context = super(HomeView, self).get_context_data(**kwargs)
hostname_without_port = remove_www_and_dev(self.request.get_host().split(":")[0])
try:
Client.objects.get(schema_name="public")
except utils.DatabaseError:
context["need_sync"] = True
context["shared_apps"] = settings.SHARED_APPS
context["tenants_list"] = []
return context
except Client.DoesNotExist:
context["no_public_tenant"] = True
context["hostname"] = hostname_without_port
if Client.objects.count() == 1:
context["only_public_tenant"] = True
context["tenants_list"] = Client.objects.all()
return context
def process_request(self, request):
# connection needs first to be at the public schema, as this is where the
# tenant informations are saved
connection.set_schema_to_public()
hostname_without_port = remove_www_and_dev(request.get_host().split(':')[0])
request.tenant = get_object_or_404(get_tenant_model(), domain_url=hostname_without_port)
connection.set_tenant(request.tenant)
# content type can no longer be cached as public and tenant schemas have different
# models. if someone wants to change this, the cache needs to be separated between
# public and shared schemas. if this cache isn't cleared, this can cause permission
# problems. for example, on public, a particular model has id 14, but on the tenants
# it has the id 15. if 14 is cached instead of 15, the permissions for the wrong
# model will be fetched.
ContentType.objects.clear_cache()
# do we have a public-specific token?
if hasattr(settings, 'PUBLIC_SCHEMA_URLCONF') and request.tenant.schema_name == get_public_schema_name():
request.urlconf = settings.PUBLIC_SCHEMA_URLCONF
def get_context_data(self, **kwargs):
context = super(HomeView, self).get_context_data(**kwargs)
hostname_without_port = remove_www_and_dev(self.request.get_host().split(':')[0])
try:
Client.objects.get(schema_name='public')
except utils.DatabaseError:
context['need_sync'] = True
context['shared_apps'] = settings.SHARED_APPS
context['tenants_list'] = []
return context
except Client.DoesNotExist:
context['no_public_tenant'] = True
context['hostname'] = hostname_without_port
if Client.objects.count() == 1:
context['only_public_tenant'] = True
context['tenants_list'] = Client.objects.all()
return context
def process_request(self, request):
"""
Resets to public schema
Some nasty weird bugs happened at the production environment without this call.
connection.pg_thread.schema_name would already be set and then terrible errors
would occur. Any idea why? My theory is django implements connection as some sort
of threading local variable.
"""
connection.set_schema_to_public()
hostname_without_port = remove_www_and_dev(
request.get_host().split(':')[0])
TenantModel = get_tenant_model()
request.tenant = get_object_or_404(TenantModel,
domain_url=hostname_without_port)
connection.set_tenant(request.tenant)
# content type can no longer be cached as public and tenant schemas have different
# models. if someone wants to change this, the cache needs to be separated between
# public and shared schemas. if this cache isn't cleared, this can cause permission
# problems. for example, on public, a particular model has id 14, but on the tenants
# it has the id 15. if 14 is cached instead of 15, the permissions for the wrong
# model will be fetched.
ContentType.objects.clear_cache()
# do we have a public-specific token?
if hasattr(
settings, 'PUBLIC_SCHEMA_URL_TOKEN'
) and request.tenant.schema_name == get_public_schema_name():
request.path_info = settings.PUBLIC_SCHEMA_URL_TOKEN + request.path_info
warnings.warn(
"PUBLIC_SCHEMA_URL_TOKEN is deprecated. Use PUBLIC_SCHEMA_URLCONF instead.",
category=DeprecationWarning)
if hasattr(
settings, 'PUBLIC_SCHEMA_URLCONF'
) and request.tenant.schema_name == get_public_schema_name():
request.urlconf = settings.PUBLIC_SCHEMA_URLCONF
def process_request(self, request):
connection.set_schema_to_public()
hostname_without_port = remove_www_and_dev(request.get_host().split(':')[0])
TenantModel = get_tenant_model()
try:
request.tenant = TenantModel.objects.get(domain_url=hostname_without_port)
except utils.DatabaseError:
request.urlconf = settings.PUBLIC_SCHEMA_URLCONF
return
except TenantModel.DoesNotExist:
if hostname_without_port in ("127.0.0.1", "localhost"):
request.urlconf = settings.PUBLIC_SCHEMA_URLCONF
return
else:
raise Http404
connection.set_tenant(request.tenant)
ContentType.objects.clear_cache()
if hasattr(settings, 'PUBLIC_SCHEMA_URLCONF') and request.tenant.schema_name == get_public_schema_name():
request.urlconf = settings.PUBLIC_SCHEMA_URLCONF
def hostname_from_request(self, request):
""" Extracts hostname from request. Used for custom requests filtering.
By default removes the request's port and common prefixes.
"""
return remove_www_and_dev(request.get_host().split(':')[0])
def main(request):
context = {'hostname': remove_www_and_dev(request.get_host().split('.')[0])}
return render(request, 'customers/dashboard.html', context)
