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