def TokenAuthMiddlewareStack(inner):
return CookieMiddleware(SessionMiddleware(TokenAuthMiddleware(inner)))
tenant = domain.tenant
schema_name = tenant.schema_name
except domain_model.DoesNotExist:
raise Http404('No tenant for hostname "%s"' % hostname)
break
else:
raise ValueError(
"The headers key in the scope is invalid. " +
"(make sure it is passed valid HTTP or WebSocket connections)")
return self.inner(
dict(scope, schema_name=schema_name, multitenant=True))
# MiddlewareStack to give access to user object in a multitenant environment
ChatterMTMiddlewareStack = lambda inner: CookieMiddleware(
SessionMiddleware(MTSchemaMiddleware(MTAuthMiddleware(inner))))
# Takes in a list of User objects and returns the UUID of the room created.
def create_room(user_list):
for user in user_list:
if type(user) != get_user_model():
raise TypeError(
"Parameters passed to create_room doesn't "
"match your project's user model. Please make sure the list "
"you passed contains valid User objects as defined in your "
"settings.AUTH_USER_MODEL parameter.")
rooms_with_member_count = Room.objects.annotate(
num_members=Count('members'))
rooms = rooms_with_member_count.filter(num_members=len(user_list))
class UserLazyObject(LazyObject):
"""
Throw a more useful error message when scope['user'] is accessed before it's resolved
"""
def _setup(self):
raise ValueError("Accessing scope user before it is ready.")
class AuthMiddleware(BaseMiddleware):
"""
Middleware which populates scope["user"] from a Django session.
Requires SessionMiddleware to function.
"""
def populate_scope(self, scope: Scope) -> None:
# Make sure we have a session
if "session" not in scope:
raise ValueError(
"AuthMiddleware cannot find session in scope. SessionMiddleware must be above it."
)
# Add it to the scope if it's not there already
if "user" not in scope:
scope["user"] = UserLazyObject()
async def resolve_scope(self, scope: Scope) -> None:
scope["user"]._wrapped = await get_user(scope)
# Handy shortcut for applying all three layers at once
AuthMiddlewareStack = lambda inner: CookieMiddleware(
SessionMiddleware(AuthMiddleware(inner)))
class TokenAuthMiddlewareInstance:
"""
Inner class that is instantiated once per scope.
"""
def __init__(self, scope, middleware):
self.middleware = middleware
self.scope = dict(scope)
self.inner = self.middleware.inner
async def __call__(self, receive, send):
# Look up user from query string (you should also do things like
# checking if it is a valid user ID, or if scope["user"] is already
# populated).
if settings.DEBUG:
print(self.scope)
if 'usertoken' in self.scope["cookies"]:
self.scope['user'] = await get_user(self.scope["cookies"])
else:
query_string = self.scope["query_string"].decode('utf-8')
self.scope['user'] = await get_user({'usertoken': query_string})
# Instantiate our inner application
inner = self.inner(self.scope)
return await inner(receive, send)
TokenMiddlewareStack = lambda inner: CookieMiddleware(
SessionMiddleware(TokenAuthMiddleware(inner)))
if "_cached_user" not in scope:
# We need to fake a request so the auth code works until we get to
# refactor it to take sessions, not requests.
fake_request = type("FakeRequest", (object, ), {"session": scope["session"]})
scope["_cached_user"] = auth.get_user(fake_request)
return scope["_cached_user"]
class AuthMiddleware:
"""
Middleware which populates scope["user"] from a Django session.
Requires SessionMiddleware to function.
"""
def __init__(self, inner):
self.inner = inner
def __call__(self, scope):
# Make sure we have a session
if "session" not in scope:
raise ValueError("AuthMiddleware cannot find session in scope. SessionMiddleware must be above it.")
# Add it to the scope if it's not there already
if "user" not in scope:
scope["user"] = SimpleLazyObject(lambda: get_user(scope))
# Pass control to inner application
return self.inner(scope)
# Handy shortcut for applying all three layers at once
AuthMiddlewareStack = lambda inner: CookieMiddleware(SessionMiddleware(AuthMiddleware(inner)))
def AuthorizationProcessorBasedMiddlewareStack(inner):
""" Handy shortcut for applying all three layers at once """
from channels.sessions import CookieMiddleware, SessionMiddleware
return CookieMiddleware(
SessionMiddleware(AuthorizationProcessorBasedMiddleware(inner)))
