Debian Codegraph @

django_pgschemas/routing/middleware.py

raw
1 import re
2 from typing import Callable, TypeAlias, cast
3
4 from asgiref.sync import iscoroutinefunction, sync_to_async
5 from django.conf import settings
6 from django.db.models import Q
7 from django.http import Http404, HttpRequest, HttpResponse
8 from django.shortcuts import redirect
9 from django.urls import clear_url_caches, set_urlconf
10 from django.utils.decorators import sync_and_async_middleware
11
12 from django_pgschemas.models import TenantModel as TenantModelBase
13 from django_pgschemas.routing.info import DomainInfo, HeadersInfo, SessionInfo
14 from django_pgschemas.routing.models import get_primary_domain_for_tenant
15 from django_pgschemas.routing.urlresolvers import get_urlconf_from_schema
16 from django_pgschemas.schema import Schema, activate, activate_public
17 from django_pgschemas.settings import get_tenant_header, get_tenant_session_key
18 from django_pgschemas.utils import get_domain_model, get_tenant_model, remove_www
19
20
21 def strip_tenant_from_path_factory(prefix: str) -> Callable[[str], str]:
22 def strip_tenant_from_path(path: str) -> str:
23 return re.sub(r"^/{}/".format(prefix), "/", path)
24
25 return strip_tenant_from_path
26
27
28 ResponseHandler: TypeAlias = Callable[[HttpRequest], HttpResponse]
29
30
31 def route_domain(request: HttpRequest) -> HttpResponse | None:
32 hostname = remove_www(request.get_host().split(":")[0])
33
34 activate_public()
35 tenant: Schema | None = None
36
37 # Checking for static tenants
38 for schema, data in settings.TENANTS.items():
39 if schema in ["public", "default"]:
40 continue
41 if hostname in data.get("DOMAINS", []):
42 tenant = Schema.create(
43 schema_name=schema,
44 routing=DomainInfo(domain=hostname),
45 )
46 break
47
48 # Checking for dynamic tenants
49 else:
50 DomainModel = get_domain_model()
51
52 prefix = request.path.split("/")[1]
53 domain = None
54
55 if DomainModel is not None:
56 try:
57 domain = DomainModel.objects.select_related("tenant").get(
58 domain=hostname, folder=prefix
59 )
60 except DomainModel.DoesNotExist:
61 try:
62 domain = DomainModel.objects.select_related("tenant").get(
63 domain=hostname, folder=""
64 )
65 except DomainModel.DoesNotExist:
66 pass
67
68 if domain is not None:
69 tenant = cast(TenantModelBase, domain.tenant)
70 tenant.routing = DomainInfo(domain=hostname)
71 request.strip_tenant_from_path = lambda x: x
72
73 if prefix and domain.folder == prefix:
74 tenant.routing = DomainInfo(domain=hostname, folder=prefix)
75 request.strip_tenant_from_path = strip_tenant_from_path_factory(prefix)
76 clear_url_caches() # Required to remove previous tenant prefix from cache (#8)
77
78 if domain.redirect_to_primary:
79 primary_domain = get_primary_domain_for_tenant(tenant)
80 if primary_domain:
81 path = request.strip_tenant_from_path(request.path)
82 return redirect(primary_domain.absolute_url(path), permanent=True)
83
84 # Checking fallback domains
85 if not tenant:
86 for schema, data in settings.TENANTS.items():
87 if schema in ["public", "default"]:
88 continue
89 if hostname in data.get("FALLBACK_DOMAINS", []):
90 tenant = Schema.create(
91 schema_name=schema,
92 routing=DomainInfo(domain=hostname),
93 )
94 break
95
96 # No tenant found from domain / folder
97 if not tenant:
98 raise Http404("No tenant for hostname '%s'" % hostname)
99
100 urlconf = get_urlconf_from_schema(tenant)
101
102 request.tenant = tenant
103 request.urlconf = urlconf
104 set_urlconf(urlconf)
105
106 activate(tenant)
107 return None
108
109
110 def route_session(request: HttpRequest) -> HttpResponse | None:
111 tenant_session_key = get_tenant_session_key()
112
113 if not hasattr(request, "session") or not (
114 tenant_ref := request.session.get(tenant_session_key)
115 ):
116 return None
117
118 tenant: Schema | None = None
119
120 # Checking for static tenants
121 for schema, data in settings.TENANTS.items():
122 if schema in ["public", "default"]:
123 continue
124 if tenant_ref == schema or tenant_ref == data.get("SESSION_KEY"):
125 tenant = Schema.create(schema_name=schema)
126 break
127
128 # Checking for dynamic tenants
129 else:
130 if (TenantModel := get_tenant_model()) is not None:
131 tenant = TenantModel._default_manager.filter(
132 Q(pk__iexact=tenant_ref) | Q(schema_name=tenant_ref)
133 ).first()
134
135 if tenant is not None:
136 tenant.routing = SessionInfo(reference=tenant_ref)
137 request.tenant = tenant
138 activate(tenant)
139
140 return None
141
142
143 def route_headers(request: HttpRequest) -> HttpResponse | None:
144 tenant_header = get_tenant_header()
145
146 if not (tenant_ref := request.headers.get(tenant_header)):
147 return None
148
149 tenant: Schema | None = None
150
151 # Checking for static tenants
152 for schema, data in settings.TENANTS.items():
153 if schema in ["public", "default"]:
154 continue
155 if tenant_ref == schema or tenant_ref == data.get("HEADER"):
156 tenant = Schema.create(schema_name=schema)
157 break
158
159 # Checking for dynamic tenants
160 else:
161 if (TenantModel := get_tenant_model()) is not None:
162 tenant = TenantModel._default_manager.filter(
163 Q(pk__iexact=tenant_ref) | Q(schema_name=tenant_ref)
164 ).first()
165
166 if tenant is not None:
167 tenant.routing = HeadersInfo(reference=tenant_ref)
168 request.tenant = tenant
169 activate(tenant)
170
171 return None
172
173
174 def middleware_factory(
175 handler: Callable[[HttpRequest], HttpResponse | None],
176 ) -> Callable[[ResponseHandler], ResponseHandler]:
177 @sync_and_async_middleware
178 def middleware(get_response: ResponseHandler) -> ResponseHandler:
179 if iscoroutinefunction(get_response):
180 async_base_middleware = sync_to_async(handler)
181
182 async def sync_middleware(request: HttpRequest) -> HttpResponse | None:
183 if response := await async_base_middleware(request):
184 return response
185
186 return await get_response(request)
187
188 return sync_middleware
189
190 else:
191
192 def async_middleware(request: HttpRequest) -> HttpResponse | None:
193 if response := handler(request):
194 return response
195
196 return get_response(request)
197
198 return async_middleware
199
200 return middleware
201
202
203 DomainRoutingMiddleware = middleware_factory(route_domain)
204 SessionRoutingMiddleware = middleware_factory(route_session)
205 HeadersRoutingMiddleware = middleware_factory(route_headers)