from chathouse.rest.users.controller.get.strategy import GetUsersStrategy from chathouse.utilities.security.controller_strategy.controller import Controller ''' Initilizes a proper controller, by creating an instance of a Controller and providing an according Strategy. Thus the Controller must only call the handle method to basically handle the request based on the choosen Strategy. Pattern/Chain of calls: Controller.handle(request_headers,request_data) -> any decorators ( Strategy.accept(request_headers,request_data,kwargs) ). In this case the Controller is the - [Get][Users]Controller. [Get] - method GET. [Users] - REST endpoint - /users. ''' GetUsersController = Controller(GetUsersStrategy())
from chathouse.socket.chat.controller.connect.strategy import ConnectChatStrategy from chathouse.utilities.security.controller_strategy.controller import Controller ''' Initilizes a proper controller, by creating an instance of a Controller and providing an according Strategy. Thus the Controller must only call the handle method to basically handle the request based on the choosen Strategy. Pattern/Chain of calls: Controller.handle(request_headers,request_data,chat_id in the kwargs) -> any decorators ( Strategy.accept(request_headers,request_data,kwargs) ). In this case the Controller is the - [Connect][Chat]Controller. [Connect] - an event. [Chat] - a socket endpoint - /socket/chat. ''' ConnectChatController = Controller(ConnectChatStrategy())
from chathouse.rest.users.identified.participations.controller.get.strategy import GetIdentifiedUserParticipationsStrategy from chathouse.utilities.security.controller_strategy.controller import Controller ''' Initilizes a proper controller, by creating an instance of a Controller and providing an according Strategy. Thus the Controller must only call the handle method to basically handle the request based on the choosen Strategy. Pattern/Chain of calls: Controller.handle(request_headers,request_data) -> any decorators ( Strategy.accept(request_headers,request_data,kwargs) ). In this case the Controller is the - [Get][IdentifiedUserParticipations]Controller. [Get] - method GET. [IdentifiedUserParticipations] - REST endpoint - /users/<identification>/participations. ''' GetIdentifiedUserParticipationsController=Controller(GetIdentifiedUserParticipationsStrategy())
from chathouse.socket.chat.controller.discharge_messages.strategy import Discharge_MessagesChatStrategy from chathouse.utilities.security.controller_strategy.controller import Controller ''' Initilizes a proper controller, by creating an instance of a Controller and providing an according Strategy. Thus the Controller must only call the handle method to basically handle the request based on the choosen Strategy. Pattern/Chain of calls: Controller.handle(request_headers,request_data) -> any decorators ( Strategy.accept(request_headers,request_data,kwargs) ). In this case the Controller is the - [Discharge_Messages][Chat]Controller. [Discharge_Messages] - an event. [Chat] - a socket endpoint - /socket/chat. ''' Discharge_MessagesChatController=Controller(Discharge_MessagesChatStrategy())
from chathouse.rest.users.identified.controller.delete.strategy import DeleteIdentifiedUserStrategy from chathouse.utilities.security.controller_strategy.controller import Controller ''' Initilizes a proper controller, by creating an instance of a Controller and providing an according Strategy. Thus the Controller must only call the handle method to basically handle the request based on the choosen Strategy. Pattern/Chain of calls: Controller.handle(request_headers,request_data) -> any decorators ( Strategy.accept(request_headers,request_data,kwargs) ). In this case the Controller is the - [Delete][IdentifiedUser]Controller. [Delete] - method DELETE. [IdentifiedUser] - REST endpoint - /users/<identification>. ''' DeleteIdentifiedUserController=Controller(DeleteIdentifiedUserStrategy())
from chathouse.rest.chats.identified.messages.controller.get.strategy import GetIdentifiedChatMessagesStrategy
from chathouse.utilities.security.controller_strategy.controller import Controller
'''
Initilizes a proper controller, by creating an instance of a Controller and providing an according Strategy. Thus the Controller must only call the handle method to basically handle the request based on the choosen Strategy.
Pattern/Chain of calls:
Controller.handle(request_headers,request_data) -> any decorators ( Strategy.accept(request_headers,request_data,kwargs) ).
In this case the Controller is the - [Get][IdentifiedChatMessages]Controller.
[Get] - method GET.
[IndentifiedChatMessages] - REST endpoint - /chats/<identified>/messages.
'''
GetIdentifiedChatMessagesController = Controller(
GetIdentifiedChatMessagesStrategy())
from chathouse.socket.notification.controller.establish_a_chat.strategy import Establish_a_ChatNotificationStrategy
from chathouse.utilities.security.controller_strategy.controller import Controller
'''
Initilizes a proper controller, by creating an instance of a Controller and providing an according Strategy. Thus the Controller must only call the handle method to basically handle the request based on the choosen Strategy.
Pattern/Chain of calls:
Controller.handle(request_headers,request_data) -> any decorators ( Strategy.accept(request_headers,request_data,kwargs) ).
In this case the Controller is the - [Establish_a_Chat][Notification]Controller.
[Establish_a_Chat] - an event.
[Notification] - a socket endpoint - /socket/notification.
'''
Establish_a_ChatNotificationController = Controller(
Establish_a_ChatNotificationStrategy())
from chathouse.rest.chats.identified.public_keys.controller.get.strategy import GetIdentifiedChatPublicKeysStrategy
from chathouse.utilities.security.controller_strategy.controller import Controller
'''
Initilizes a proper controller, by creating an instance of a Controller and providing an according Strategy. Thus the Controller must only call the handle method to basically handle the request based on the choosen Strategy.
Pattern/Chain of calls:
Controller.handle(request_headers,request_data) -> any decorators ( Strategy.accept(request_headers,request_data,kwargs) ).
In this case the Controller is the - [Get][IdentifiedChatPublicKeys]Controller.
[Get] - method GET.
[IndentifiedChatPublicKeys] - REST endpoint - /chats/<identified>/public-keys.
'''
GetIdentifiedChatPublicKeysController = Controller(
GetIdentifiedChatPublicKeysStrategy())
from chathouse.socket.notification.controller.connect.strategy import ConnectNotificationStrategy from chathouse.utilities.security.controller_strategy.controller import Controller ''' Initilizes a proper controller, by creating an instance of a Controller and providing an according Strategy. Thus the Controller must only call the handle method to basically handle the request based on the choosen Strategy. Pattern/Chain of calls: Controller.handle(request_headers,request_data) -> any decorators ( Strategy.accept(request_headers,request_data,kwargs) ). In this case the Controller is the - [Connect][Notification]Controller. [Connect] - an event. [Notification] - a socket endpoint - /socket/notification. ''' ConnectNotificationController = Controller(ConnectNotificationStrategy())
from chathouse.rest.tokens.verification.controller.post.strategy import PostVerificationStrategy from chathouse.utilities.security.controller_strategy.controller import Controller ''' Initilizes a proper controller, by creating an instance of a Controller and providing an according Strategy. Thus the Controller must only call the handle method to basically handle the request based on the choosen Strategy. Pattern/Chain of calls: Controller.handle(request_headers,request_data) -> any decorators ( Strategy.accept(request_headers,request_data,kwargs) ). In this case the Controller is the - [Post][Verification]Controller. [Post] - method POST. [Verification] - REST endpoint - /tokens/verification. ''' PostVerificationController = Controller(PostVerificationStrategy())
from chathouse.utilities.security.controller_strategy.controller import Controller from chathouse.views.public.controller.confirm.strategy import ConfirmStrategy ''' Initilizes a proper controller, by creating an instance of a Controller and providing an according Strategy. Thus the Controller must only call the handle method to basically handle the request based on the choosen Strategy. Pattern/Chain of calls: Controller.handle(request_headers,request_data - empty) -> any decorators ( Strategy.accept(request_headers,request_data - empty,kwargs) ). In this case the View Controller has to be GET - [Confirm]Controller. [Confirm] - view route - /confirm/<string:token>. ''' ConfirmController = Controller(ConfirmStrategy())
from chathouse.rest.chats.identified.controller.get.strategy import GetIdentifiedChatStrategy from chathouse.utilities.security.controller_strategy.controller import Controller ''' Initilizes a proper controller, by creating an instance of a Controller and providing an according Strategy. Thus the Controller must only call the handle method to basically handle the request based on the choosen Strategy. Pattern/Chain of calls: Controller.handle(request_headers,request_data) -> any decorators ( Strategy.accept(request_headers,request_data,kwargs) ). In this case the Controller is the - [Get][IdentifiedChat]Controller. [Get] - method GET. [IndentifiedChat] - REST endpoint - /chats/<identified>. ''' GetIdentifiedChatController = Controller(GetIdentifiedChatStrategy())
from chathouse.rest.tokens.grant.controller.post.strategy import PostGrantStrategy from chathouse.utilities.security.controller_strategy.controller import Controller ''' Initilizes a proper controller, by creating an instance of a Controller and providing an according Strategy. Thus the Controller must only call the handle method to basically handle the request based on the choosen Strategy. Pattern/Chain of calls: Controller.handle(request_headers,request_data) -> any decorators ( Strategy.accept(request_headers,request_data,kwargs) ). In this case the Controller is the - [Post][Grant]Controller. [Post] - method POST. [Grant] - REST endpoint - /tokens/grant. ''' PostGrantController = Controller(PostGrantStrategy())
from chathouse.socket.notification.controller.discharge_a_chat.strategy import Discharge_a_ChatNotificationStrategy
from chathouse.utilities.security.controller_strategy.controller import Controller
'''
Initilizes a proper controller, by creating an instance of a Controller and providing an according Strategy. Thus the Controller must only call the handle method to basically handle the request based on the choosen Strategy.
Pattern/Chain of calls:
Controller.handle(request_headers,request_data) -> any decorators ( Strategy.accept(request_headers,request_data,kwargs) ).
In this case the Controller is the - [Discharge_a_Chat][Notification]Controller.
[Discharge_a_Chat] - an event.
[Notification] - a socket endpoint - /socket/notification.
'''
Discharge_a_ChatNotificationController = Controller(
Discharge_a_ChatNotificationStrategy())
from chathouse.utilities.security.controller_strategy.controller import Controller from chathouse.views.public.controller.verify.strategy import VerifyStrategy ''' Initilizes a proper controller, by creating an instance of a Controller and providing an according Strategy. Thus the Controller must only call the handle method to basically handle the request based on the choosen Strategy. Pattern/Chain of calls: Controller.handle(request_headers,request_data - empty) -> any decorators ( Strategy.accept(request_headers,request_data - empty,kwargs) ). In this case the View Controller has to be GET - [Verify]Controller. [Verify] - view route - /verify/<string:token>. ''' VerifyController = Controller(VerifyStrategy())
from chathouse.rest.users.identified.controller.get.strategy import GetIdentifiedUserStrategy from chathouse.utilities.security.controller_strategy.controller import Controller ''' Initilizes a proper controller, by creating an instance of a Controller and providing an according Strategy. Thus the Controller must only call the handle method to basically handle the request based on the choosen Strategy. Pattern/Chain of calls: Controller.handle(request_headers,request_data) -> any decorators ( Strategy.accept(request_headers,request_data,kwargs) ). In this case the Controller is the - [Get][IdentifiedUser]Controller. [Get] - method GET. [IdentifiedUser] - REST endpoint - /users/<identification>. ''' GetIdentifiedUserController = Controller(GetIdentifiedUserStrategy())
from chathouse.rest.tokens.confirmation.controller.post.strategy import PostConfirmationStrategy from chathouse.utilities.security.controller_strategy.controller import Controller ''' Initilizes a proper controller, by creating an instance of a Controller and providing an according Strategy. Thus the Controller must only call the handle method to basically handle the request based on the choosen Strategy. Pattern/Chain of calls: Controller.handle(request_headers,request_data) -> any decorators ( Strategy.accept(request_headers,request_data,kwargs) ). In this case the Controller is the - [Post][Confirmation]Controller. [Post] - method POST. [Confirmation] - REST endpoint - /tokens/confirmation. ''' PostConfirmationController = Controller(PostConfirmationStrategy())
from chathouse.socket.chat.controller.establish_a_message.strategy import Establish_a_MessageChatStrategy
from chathouse.utilities.security.controller_strategy.controller import Controller
'''
Initilizes a proper controller, by creating an instance of a Controller and providing an according Strategy. Thus the Controller must only call the handle method to basically handle the request based on the choosen Strategy.
Pattern/Chain of calls:
Controller.handle(request_headers,request_data) -> any decorators ( Strategy.accept(request_headers,request_data,kwargs) ).
In this case the Controller is the - [Establish_a_Message][Chat]Controller.
[Establish_a_Message] - an event.
[Chat] - a socket endpoint - /socket/chat.
'''
Establish_a_MessageChatController = Controller(
Establish_a_MessageChatStrategy())
from chathouse.utilities.security.controller_strategy.controller import Controller from chathouse.rest.key_parameters.controller.get.strategy import GetKeyParametersStrategy ''' Initilizes a proper controller, by creating an instance of a Controller and providing an according Strategy. Thus the Controller must only call the handle method to basically handle the request based on the choosen Strategy. Pattern/Chain of calls: Controller.handle(request_headers,request_data) -> any decorators ( Strategy.accept(request_headers,request_data,kwargs) ). In this case the Controller is the - [Get][KeyParameters]Controller. [Get] - method GET. [KeyParameters] - REST endpoint - /key-parameters. ''' GetKeyParametersController = Controller(GetKeyParametersStrategy())
from chathouse.utilities.security.controller_strategy.controller import Controller from chathouse.views.authorized.controller.chat.strategy import ChatStrategy ''' Initilizes a proper controller, by creating an instance of a Controller and providing an according Strategy. Thus the Controller must only call the handle method to basically handle the request based on the choosen Strategy. Pattern/Chain of calls: Controller.handle(request_headers,request_data) -> any decorators ( Strategy.accept(request_headers,request_data,kwargs) ). In this case the View Controller is the - [Chat]Controller. [Chat] - View route - /chat. ''' ChatController = Controller(ChatStrategy())
from chathouse.utilities.security.controller_strategy.controller import Controller from chathouse.views.authorized.controller.logout.strategy import LogoutStrategy ''' Initilizes a proper controller, by creating an instance of a Controller and providing an according Strategy. Thus the Controller must only call the handle method to basically handle the request based on the choosen Strategy. Pattern/Chain of calls: Controller.handle(request_headers,request_data) -> any decorators ( Strategy.accept(request_headers,request_data,kwargs) ). In this case the View Controller is the - [Logout]Controller. [Logout] - View route - /logout. ''' LogoutController=Controller(LogoutStrategy())
from chathouse.utilities.security.controller_strategy.controller import Controller from chathouse.views.public.controller.start.strategy import StartStrategy ''' Initilizes a proper controller, by creating an instance of a Controller and providing an according Strategy. Thus the Controller must only call the handle method to basically handle the request based on the choosen Strategy. Pattern/Chain of calls: Controller.handle(request_headers,request_data - empty) -> any decorators ( Strategy.accept(request_headers,request_data - empty,kwargs) ). In this case the View Controller has to be GET - [Start]Controller. [Start] - view route - /,/start. ''' StartController=Controller(StartStrategy())
from chathouse.rest.tokens.access.controller.get.strategy import GetAccessStrategy from chathouse.utilities.security.controller_strategy.controller import Controller ''' Initilizes a proper controller, by creating an instance of a Controller and providing an according Strategy. Thus the Controller must only call the handle method to basically handle the request based on the choosen Strategy. Pattern/Chain of calls: Controller.handle(request_headers,request_data) -> any decorators ( Strategy.accept(request_headers,request_data,kwargs) ). In this case the Controller is the - [Get][Access]Controller. [Get] - method GET. [Access] - REST endpoint - /tokens/access. ''' GetAccessController = Controller(GetAccessStrategy())
from chathouse.utilities.security.controller_strategy.controller import Controller from chathouse.views.public.controller.signup.strategy import SignUpStrategy ''' Initilizes a proper controller, by creating an instance of a Controller and providing an according Strategy. Thus the Controller must only call the handle method to basically handle the request based on the choosen Strategy. Pattern/Chain of calls: Controller.handle(request_headers,request_data - empty) -> any decorators ( Strategy.accept(request_headers,request_data - empty,kwargs) ). In this case the View Controller has to be GET - [SignUp]Controller. [SignUp] - view route - /signup. ''' SignUpController = Controller(SignUpStrategy())
from chathouse.utilities.security.controller_strategy.controller import Controller from chathouse.views.public.controller.login.strategy import LogInStrategy ''' Initilizes a proper controller, by creating an instance of a Controller and providing an according Strategy. Thus the Controller must only call the handle method to basically handle the request based on the choosen Strategy. Pattern/Chain of calls: Controller.handle(request_headers,request_data - empty) -> any decorators ( Strategy.accept(request_headers,request_data - empty,kwargs) ). In this case the View Controller has to be GET - [LogIn]Controller. [LogIn] - view route - /login. ''' LogInController = Controller(LogInStrategy())