def test_middleware_processing(self):
route_handler.register(TestRouter)
data = {'verb': 'say_hello', 'route': TestRouter.get_name()}
with self.assertRaises(AttributeError):
self.connection.dummy
self.connection.on_message(data)
self.assertTrue(self.connection.dummy)
def setUp(self):
route_handler.register(NotificationRouter)
backends.backends = [('realtime', RealtimeNotification)]
user_manager.clear()
self.user_a = User.objects.create(first_name='Veronica', username='******')
self.user_b = User.objects.create(first_name='Jonas', username='******')
self.user_c = User.objects.create(first_name='Benedicte', username='******')
user_manager.add_user(self.user_a.pk)
user_manager.add_user(self.user_b.pk)
user_manager.add_user(self.user_c.pk)
def test_validate_field_from_router(self):
"""
Ensure that both the text and number error message
is raised upon validation
"""
data = {'text': 'foo', 'number': 8}
route_handler.register(Router)
self.connection.call_verb(Router.route_name, 'create', **data)
self.assertEqual(self.connection.last_message['context']['state'], ERROR)
self.assertIn('text', self.connection.last_message['data'])
self.assertIn('number', self.connection.last_message['data'])
def setUp(self):
route_handler.register(NotificationRouter)
backends.backends = [('realtime', RealtimeNotification)]
user_manager.clear()
self.user_a = User.objects.create(first_name='Veronica',
username='******')
self.user_b = User.objects.create(first_name='Jonas', username='******')
self.user_c = User.objects.create(first_name='Benedicte',
username='******')
user_manager.add_user(self.user_a.pk)
user_manager.add_user(self.user_b.pk)
user_manager.add_user(self.user_c.pk)
def test_register_model_router_with_missing_get_object(self):
with self.assertRaises(Exception):
route_handler.register(ModelRouterGetObject)
from dataset_manager.enums import ComputingStateType
from testing import tasks
class TestServerRouter(BaseRouter):
route_name = 'test_server'
valid_verbs = BaseRouter.valid_verbs + ['test', 'test_celery']
def test(self):
try:
time.sleep(2)
self.send({"state": ComputingStateType.SUCCESS})
except:
self.send({"state": ComputingStateType.FAILED})
def test_celery(self):
try:
task = tasks.test.delay()
time.sleep(2)
state = task.state
if state == "SUCCESS":
self.send({"state": ComputingStateType.SUCCESS})
else:
self.send({"state": ComputingStateType.FAILED})
except:
self.send({"state": ComputingStateType.FAILED})
route_handler.register(TestServerRouter)
def test_register_router(self):
route_handler.register(Router)
self.assertIsNotNone(route_handler.get_route_handler(
Router.get_name()))
def test_on_message_invalid_verb(self):
route_handler.register(TestRouter)
data = {'verb': 'invalid_verb', 'route': TestRouter.get_name()}
with self.assertRaises(UnexpectedVerbException):
self.connection.on_message(data)
self.assertTrue(self.connection.is_closed)
class ChatRouter(ModelRouter):
route_name = 'chat'
serializer_class = ChatSerializer
include_related = [ChatMessageSerializer, ChatMessageSerializer]
model = Chat
def get_object(self, **kwargs):
return self.model.objects.get(pk=kwargs['id'])
def get_query_set(self, **kwargs):
return self.model.objects.all()
class ChatMessageRouter(ModelRouter):
route_name = 'chat-message'
serializer_class = ChatMessageSerializer
model = ChatMessage
def get_object(self, **kwargs):
return self.model.objects.get(pk=kwargs['id'])
def get_query_set(self, **kwargs):
return self.model.objects.all()
route_handler.register(MailRouter)
route_handler.register(MailReplyRouter)
route_handler.register(NotificationRouter)
route_handler.register(ChatRouter)
route_handler.register(ChatMessageRouter)
return self.model.objects.get(pk = kwargs['id'])
def get_query_set(self, **kwargs):
return self.model.objects.all()
class TicTacToeMoveRouter(ModelPubRouter):
route_name = 'tic-tac-toe-move'
model = TicTacToeMove
serializer_class = model.serializer_class
def get_initial(self, verb, **kwargs):
if verb == 'create':
try:
tic_tac_toe = TicTacToe.objects.get(id = kwargs.get('tic_tac_toe_id'))
return {'tic_tac_toe': tic_tac_toe}
except TicTacToe.DoesNotExist:
pass
return dict()
def get_object(self, **kwargs):
return self.model.objects.get(pk = kwargs['id'])
def get_query_set(self, **kwargs):
return self.model.objects.filter(tic_tac_toe = kwargs['tic_tac_toe_id'])
route_handler.register(TicTacToeRouter)
route_handler.register(TicTacToeMoveRouter)
pass
else:
auth.is_read = True
auth.save()
comment = Comment()
comment.room = get_object_or_404(Room, pk=kwargs["room"])
comment.authid = self.connection.user.id
comment.text = kwargs['text']
comment.save()
class RoomRegistRouter(ModelRouter):
route_name = 'regist-route'
serializer_class = RoomResistSerializer
model = RoomResist
def get_object(self, **kwargs):
obj, created = self.model.objects.get_or_create(user=self.connection.user.id, room=kwargs['room_id'])
return obj
def get_query_set(self, **kwargs):
# print(self.model.objects.filter(room=kwargs['room_id'])[1].text)
return self.model.objects.filter(user=kwargs['user_id'])
# return self.model.objects.all()
route_handler.register(UserRouter)
route_handler.register(RoomRouter)
route_handler.register(CommentRouter)
route_handler.register(RoomRegistRouter)
from swampdragon import route_handler
from swampdragon.pubsub_providers.data_publisher import publish_data
from swampdragon.route_handler import BaseRouter
from tornado.ioloop import PeriodicCallback
pcb = None
class CallStatusRouter(BaseRouter):
route_name = 'calls'
def get_subscription_channels(self, **kwargs):
broadcast_call_status()
return ['call_status']
def broadcast_call_status():
print "IN HEREtoo"
global pcb
if pcb is None:
pcb = PeriodicCallback(broadcast_call_status, 500)
pcb.start()
print "HELLO"
publish_data('call_status', {
'status': random.randint(0, 1000)
})
route_handler.register(CallStatusRouter)
event = Event.objects.filter(identifier = kwargs['identifier'])
return self.model.objects.filter(event = event)
def created(self, obj, **kwargs):
data = self.serializer_class(instance=obj).serialize()
chatData = dict({'data': data})
base_channel = self.serializer_class.get_base_channel()
identifier = kwargs['identifier']
channel = base_channel + "identifier:" + identifier
self.publish([channel], chatData)
super().created(obj, **kwargs)
class MarkerListRouter(BaseRouter):
route_name = 'marker-list'
valid_verbs = ['subscribe', 'get_markers']
def get_markers(self, **kwargs):
identifier = kwargs['identifier']
local_channel = kwargs['local_channel']
lat = kwargs['lat']
lng = kwargs['lng']
channel = "marker|identifier:" + identifier
self.publish([channel], kwargs)
def get_subscription_channels(self, **kwargs):
identifier = kwargs['identifier']
return ["marker|identifier:" + identifier]
route_handler.register(ChatListRouter)
route_handler.register(MarkerListRouter)
import logging
from swampdragon import route_handler
from swampdragon.route_handler import BaseRouter
logger = logging.getLogger(__name__)
class ActivityFeedRouter(BaseRouter):
route_name = 'activityfeed'
def get_subscription_channels(self, **kwargs):
channels = ('feed', )
pk = kwargs.pop('pk')
if pk:
channels = ['post-{pk}'.format(pk=pk)]
channels.append('feed')
return channels
def subscribe(self, **kwargs):
logger.info(kwargs)
super(ActivityFeedRouter, self).subscribe(**kwargs)
route_handler.register(ActivityFeedRouter)
from swampdragon import route_handler
from swampdragon.route_handler import ModelRouter
from turnover.models import Events
from turnover.serializers import EventsSerializer
class EventsRouter(ModelRouter):
route_name = "events-list"
serializer_class = EventsSerializer
model = Events
def get_object(self, **kwargs):
return self.model.objects.get(pk=kwargs["id"])
def get_query_set(self, **kwargs):
return self.model.objects.all()
route_handler.register(EventsRouter)
from swampdragon import route_handler
from swampdragon.route_handler import BaseRouter
from swampdragon.pubsub_providers.data_publisher import publish_data
from django.conf import settings
from google.models import Search
cache = settings.CACHE
class GeoRouter(BaseRouter):
route_name = 'geo_task'
valid_verbs = ['subscribe']
def get_subscription_channels(self, **kwargs):
channel = 'project_%s_geo' % kwargs.get('project')
return [channel]
class SearchRouter(BaseRouter):
route_name = 'search_task'
valid_verbs = ['subscribe']
def get_subscription_channels(self, **kwargs):
channel = 'project_%s_search' % kwargs.get('project')
print channel
return [channel]
route_handler.register(GeoRouter)
route_handler.register(SearchRouter)
from swampdragon.route_handler import register
from swampdragon.route_handler import ModelRouter
from models import Message
from serializers import NotificationSerializer
class NotificationRouter(ModelRouter):
model = Message
serializer_class = NotificationSerializer
route_name = 'notifications'
valid_verbs = ['subscribe']
register(NotificationRouter)
class MessageRouter(ModelRouter):
route_name = 'message'
serializer_class = MessageSerializer
model = Message
valid_verbs = ['chat', 'subscribe', 'get_list']
def get_object(self, **kwargs):
return self.model.objects.get(pk=kwargs['id'])
def get_query_set(self, **kwargs):
return self.model.objects.filter(
Q(sender=kwargs['user_id']) | Q(recipient=kwargs['user_id']))
route_handler.register(MyUserRouter)
route_handler.register(MessageRouter)
class NotificationRouter(ModelRouter):
valid_verbs = ['subscribe']
route_name = 'notification'
model = Message
serializer_class = MessageSerializer
def get_object(self, **kwargs):
return self.model.objects.get(pk=kwargs['pk'])
def get_query_set(self, **kwargs):
return self.model.objects.all()
route_name = '_sdfileupload'
class WithFileRouter(BaseModelRouter):
model = WithFile
serializer_class = WithFileSerializer
route_name = 'withfile-route'
def get_object(self, **kwargs):
return self.model.objects.get(pk=kwargs['id'])
def get_query_set(self, **kwargs):
return self.model.objects.all()
class MultiFileRouter(BaseModelRouter):
model = MultiFileModel
serializer_class = MultiFileSerializer
route_name = 'multifile-route'
def get_object(self, **kwargs):
return self.model.objects.get(pk=kwargs['id'])
def get_query_set(self, **kwargs):
return self.model.objects.all()
route_handler.register(WithFileRouter)
route_handler.register(MultiFileRouter)
route_handler.register(FileUpload)
'message': m.text
})
class MessageRouter(ModelRouter):
route_name = 'message'
serializer_class = MessageSerializer
model = Message
def get_object(self, **kwargs):
return self.model.objects.get(pk=kwargs['id'])
def get_query_set(self, **kwargs):
return self.model.objects.filter(chat__id=kwargs['chat_id'])
class NotifyRouter(BaseRouter):
valid_verbs = ['subscribe', 'notify_everyone_but_me']
route_name = 'notifier'
def notify_everyone_but_me(self, name):
users = CustomUser.objects.all()
# users = CustomUser.objects.exclude(pk=self.connection.user.pk)
foo = Notification.objects.create(name=name)
notify_users(users, subject=foo, notification_type='foo')
route_handler.register(NotifyRouter)
route_handler.register(ChatRouter)
route_handler.register(MessageRouter)
return self.model.objects.get(initiator = kwargs['initiator'],problem = kwargs['problem']) def get_query_set(self, **kwargs): return self.model.objects.all() class MultiMoveRouter(ModelRouter): route_name = 'MultiMove' serializer_class = MultiMoveSerializer model = MultiMove def get_object(self, **kwargs): return self.model.objects.get(solution= kwargs['solution'], piece_key = kwargs['piece_key']) def get_query_set(self, **kwargs): return self.model.objects.filter(solution= kwargs['solution']) class ChatRouter(ModelRouter): route_name = 'Chat' serializer_class = ChatSerializer model = Chat def get_object(self, **kwargs): return self.model.objects.get(solution= kwargs['solution'], username = kwargs['username'], initiator = kwargs['initiator']) def get_query_set(self, **kwargs): return self.model.objects.filter(solution__problem__name = kwargs['problem_name']) route_handler.register(MultiSolRouter) route_handler.register(MultiMoveRouter) route_handler.register(ChatRouter)
return self.model.objects.get(pk=kwargs['id'])
def get_query_set(self, **kwargs):
return self.model.objects.all()
class TicTacToeMoveRouter(ModelPubRouter):
route_name = 'tic-tac-toe-move'
model = TicTacToeMove
serializer_class = model.serializer_class
def get_initial(self, verb, **kwargs):
if verb == 'create':
try:
tic_tac_toe = TicTacToe.objects.get(
id=kwargs.get('tic_tac_toe_id'))
return {'tic_tac_toe': tic_tac_toe}
except TicTacToe.DoesNotExist:
pass
return dict()
def get_object(self, **kwargs):
return self.model.objects.get(pk=kwargs['id'])
def get_query_set(self, **kwargs):
return self.model.objects.filter(tic_tac_toe=kwargs['tic_tac_toe_id'])
route_handler.register(TicTacToeRouter)
route_handler.register(TicTacToeMoveRouter)
from swampdragon import route_handler
from swampdragon.route_handler import ModelPubRouter
from .models import Notification
from .serializers import NotificationSerializer
class NotificationRouter(ModelPubRouter):
valid_verbs = ['subscribe']
route_name = 'notifications'
model = Notification
serializer_class = NotificationSerializer
route_handler.register(NotificationRouter)
from swampdragon import route_handler
from swampdragon.route_handler import ModelRouter
from .models import Player
from .serializers import PlayerSerializer
class PlayerRouter(ModelRouter):
route_name = 'player'
serializer_class = PlayerSerializer
model = Player
def get_object(self, **kwargs):
return self.model.objects.get(pk=kwargs['id'])
def get_query_set(self, **kwargs):
return self.model.objects.all()
route_handler.register(PlayerRouter)
model = UserMessage
route_name = 'admin-message'
permission_classes = [LoginRequired()]
def get_object(self, **kwargs):
return self.model.objects.get(pk=kwargs['pk'])
def get_query_set(self, **kwargs):
return self.model.all()
def create(self, **kwargs):
initial = self.get_initial('create', **kwargs)
self.serializer = self.serializer_class(data=kwargs, initial=initial)
pk = self.serializer.data['user']
user = get_user_model().objects.get(pk=pk)
msg = UserMessage.objects.create(
text=self.serializer.data['text'],
user=user,
direction='to'
)
publish_data('user-message-%s' % user.pk, {
'text': msg.text,
'created_at': str(msg.created_at),
'direction': 'from'
})
self.send('done')
route_handler.register(UserMessageRouter)
route_handler.register(AdminMessageRouter)
def setUp(self):
route_handler.register(PersonRouter)
from swampdragon import route_handler
from swampdragon.route_handler import ModelRouter
from localground.apps.site.api.realtime_serializers import PhotoRTSerializer
from localground.apps.site.models import Photo
class PhotoRouter(ModelRouter):
route_name = 'photo'
serializer_class = PhotoRTSerializer
model = Photo
def get_object(self, **kwargs):
return self.model.objects.get(pk=kwargs['id'])
def get_query_set(self, **kwargs):
return self.model.objects.all()
route_handler.register(PhotoRouter)
def test_on_message(self):
route_handler.register(TestRouter)
data = {'verb': 'say_hello', 'route': TestRouter.get_name()}
self.connection.on_message(data)
self.assertTrue(self.connection.hello_said)
from datetime import datetime
from swampdragon import route_handler
from swampdragon.route_handler import BaseRouter
class FooRouter(BaseRouter):
route_name = 'foo'
valid_verbs = ['get_date', 'get_error']
def get_date(self, **kwargs):
self.send({'current_date': str(datetime.now()), "kwargs": kwargs})
def get_error(self, **kwargs):
self.send_error({'name': 'the name is required'})
route_handler.register(FooRouter)
route_name = 'mensaje-router'
serializer_class = MensajeSerializer
model = Mensaje
def get_object(self, **kwargs):
a = self.model.objects.filter(
fk_receptor__username=kwargs['username'],
leido=False).order_by('fecha_de_envio').last()
print a
return a
def get_query_set(self, **kwargs):
return self.model.objects.all()
route_handler.register(MensajeRouter)
# Class para notificacion
class NotificacionRouter(ModelRouter):
route_name = 'notificacion-router'
serializer_class = NotificacionSerializer
model = Notificacion
def get_object(self, **kwargs):
a = self.model.objects.filter(
destinatario_notificacion__username=kwargs['username'],
estado_notificacion=False).order_by('fecha_creacion').last()
print a
return a
def get_subscription_contexts(self, **kwargs):
return {'room__users__pk': self.connection.user.pk}
class ProfileRouter(ModelRouter):
route_name = 'profiles'
serializer_class = ProfileSerializer
model = Profile
def get_object(self, **kwargs):
return self.model.objects.get(pk=kwargs['id'])
def get_query_set(self, **kwargs):
return self.model.objects.all()
route_handler.register(MessageRouter)
route_handler.register(ProfileRouter)
# Modified OnlineUsersRouter
class ChatOnlineUsersRouter(OnlineUsersRouter):
def subscribe(self, **kwargs):
if not self.connection.user:
return
#super().subscribe(**kwargs)
if self.connection.user:
user_manager.add_user(self.connection.user.pk)
route_handler.registered_handlers['swampdragon-online'] = ChatOnlineUsersRouter
from swampdragon import route_handler
from swampdragon.route_handler import BaseRouter
class ChatRouter(BaseRouter):
route_name = 'chat-route'
valid_verbs = ['chat', 'subscribe']
def get_subscription_channels(self, **kwargs):
return ['chatroom']
def chat(self, *args, **kwargs):
errors = {}
if 'name' not in kwargs or len(kwargs['name']) is 0:
errors['name'] = 'Specify a name'
if 'message' not in kwargs or len(kwargs['message']) is 0:
errors['message'] = 'Enter a chat message'
if errors:
self.send_error(errors)
else:
self.send({'status': 'ok'})
self.publish(self.get_subscription_channels(), kwargs)
route_handler.register(ChatRouter)
def test_register_router_twice(self):
route_handler.register(Router)
route_handler.register(Router)
self.assertEqual(len(route_handler.registered_handlers), 1)
'''
'''
from django.contrib.auth.models import User
from swampdragon import route_handler
from swampdragon.route_handler import BaseRouter
from swampdragon_notifications.notifier import notify_users
from .models import *
class NotifyRouter(BaseRouter):
valid_verbs = ['subscribe', 'notify_everyone', 'notify_everyone_but_me']
route_name = 'notifier'
def notify_everyone(self, name):
users = User.objects.all()
# foo = Foo.objects.create(name=name)
notify_users(users, subject="Hello", notification_type='foo')
def notify_everyone_but_me(self, name):
users = User.objects.exclude(pk=self.connection.user.pk)
# foo = Foo.objects.create(name=name)
notify_users(users, subject="hello everyone", notification_type='foo')
route_handler.register(NotifyRouter)
def test_register_model_router_with_missing_get_query_set(self):
with self.assertRaises(Exception):
route_handler.register(ModelRouterGetQuerySet)
message = client.compose(kwargs['uuid'], message)
self.send(message)
except Exception, e:
self.send_error({'message': 'Error composing message'})
@login_required
def get_conversation(self, **kwargs):
user = self.connection.user
token = UserProfile.objects.get(user=user).token
if 'uuid' not in kwargs:
self.send_error({'message': 'Missing room uuid'})
return
try:
client = ChatClient(token)
conv = client.get_conversation(kwargs['uuid'])
conv['messages'].reverse()
self.send(conv)
except Exception, e:
self.send_error({'message': 'Error retrieving conversation'})
route_handler.register(SessionRouter)
route_handler.register(ChatRouter)
from swampdragon import route_handler
from swampdragon.route_handler import ModelRouter
from .serializers import CompanySerializer, StaffSerializer, DocumentSerializer, CompanyOwnerSerializer
from .models import Company
class CompanyRouter(ModelRouter):
serializer_class = CompanySerializer
model = Company
route_name = 'company-route'
include_related = [
StaffSerializer, DocumentSerializer, CompanyOwnerSerializer
]
def get_query_set(self, **kwargs):
return self.model.objects.all()
def get_object(self, **kwargs):
return self.model.objects.get(pk=kwargs['pk'])
route_handler.register(CompanyRouter)
class ChatRouter(ModelRouter):
route_name = 'chat'
serializer_class = ChatSerializer
include_related = [ChatMessageSerializer, ChatMessageSerializer]
model = Chat
def get_object(self, **kwargs):
return self.model.objects.get(pk=kwargs['id'])
def get_query_set(self, **kwargs):
return self.model.objects.all()
class ChatMessageRouter(ModelRouter):
route_name = 'chat-message'
serializer_class = ChatMessageSerializer
model = ChatMessage
def get_object(self, **kwargs):
return self.model.objects.get(pk=kwargs['id'])
def get_query_set(self, **kwargs):
return self.model.objects.all()
route_handler.register(MailRouter)
route_handler.register(MailReplyRouter)
route_handler.register(NotificationRouter)
route_handler.register(ChatRouter)
route_handler.register(ChatMessageRouter)
for user in game.players:
user.give_message(kwargs['msg'], sender, kwargs['target'],
kwargs['time'])
elif kwargs['target'] == "world":
data_dict = {}
data_dict['message'] = kwargs['msg']
data_dict['sender'] = sender
data_dict['target'] = kwargs['target']
data_dict['time'] = kwargs['time']
data_dict['type'] = "message"
data_dict['channel'] = "sysmsg"
channel = "sysmsg"
publish_data(channel, data_dict)
#else: # search through game given this grouping (witch, werewolf, humans etc.)
def vote(self, **kwargs):
myGame = Game(session_data['g_id'])
myGame.event_queue[0].add_vote(kwargs['p_id'])
raise NotImplementedError
def broadcast_games(self, *kwargs):
return self.send(broadcast_games())
# register router
route_handler.register(LobbyRouter)
route_handler.register(GameRouter)
from swampdragon.route_handler import ModelRouter
from servers.models import ServerList, ServerItem
from servers.serializers import ServerListSerializer, ServerItemSerializer
class ServerListRouter(ModelRouter):
route_name = 'server-list'
serializer_class = ServerListSerializer
model = ServerList
def get_object(self, **kwargs):
return self.model.objects.get(pk=kwargs['id'])
def get_query_set(self, **kwargs):
return self.model.objects.all()
class ServerItemRouter(ModelRouter):
route_name = 'server-item'
serializer_class = ServerItemSerializer
model = ServerItem
def get_object(self, **kwargs):
return self.model.objects.get(pk=kwargs['id'])
def get_query_set(self, **kwargs):
return self.model.objects.filter(server_list__id=kwargs['list_id'])
route_handler.register(ServerListRouter)
route_handler.register(ServerItemRouter)
from chat.models import ChatList, ChatItem
from chat.serializers import ChatListSerializer, ChatItemSerializer
class ChatListRouter(ModelRouter):
route_name = 'chat-list'
serializer_class = ChatListSerializer
model = ChatList
def get_object(self, **kwargs):
return self.model.objects.get(pk=kwargs['id'])
def get_query_set(self, **kwargs):
return self.model.objects.all()
class ChatItemRouter(ModelRouter):
route_name = 'chat-item'
serializer_class = ChatItemSerializer
model = ChatItem
def get_object(self, **kwargs):
return self.model.objects.get(pk=kwargs['id'])
def get_query_set(self, **kwargs):
return self.model.objects.filter(chat_list__id=kwargs['list_id'])
route_handler.register(ChatListRouter)
route_handler.register(ChatItemRouter)
from swampdragon.route_handler import BaseRouter
class AppointmentCreate(BaseRouter):
route_name = 'AppointmentCreate'
def get_subscription_channels(self, **kwargs):
return ['createAppt']
class AppointmentUpdate(BaseRouter):
route_name = 'AppointmentUpdate'
def get_subscription_channels(self, **kwargs):
return ['updateAppt']
class AppointmentDelete(BaseRouter):
route_name = 'AppointmentDelete'
def get_subscription_channels(self, **kwargs):
return ['deleteAppt']
class PatientQueue(BaseRouter):
route_name = 'PatientQueue'
def get_subscription_channels(self, **kwargs):
return ['queue']
route_handler.register(AppointmentCreate)
route_handler.register(AppointmentUpdate)
route_handler.register(AppointmentDelete)
route_handler.register(PatientQueue)
from swampdragon import route_handler
from swampdragon.permissions import login_required, LoginRequired
from swampdragon.route_handler import BaseRouter
class Chat(BaseRouter):
route_name = 'chat'
valid_verbs = BaseRouter.valid_verbs + ['say_hello', 'chat']
#permission_classes = [LoginRequired()]
def get_subscription_channels(self, **kwargs):
return ['chatroom']
@login_required
def say_hello(self, **kwargs):
data = {'name': kwargs['name'], 'message': 'hello'}
self.publish(self.get_subscription_channels(), {'data': data})
@login_required
def chat(self, **kwargs):
print(self.connection.get_user().is_authenticated())
self.publish(self.get_subscription_channels(), {'data': kwargs})
route_handler.register(Chat)
print("kwargs__GSC")
print(kwargs)
#print(kwargs[])
print("vars(self.connection)__")
print(vars(self.connection))
contexto = dict()
contexto['user__id'] = self.connection.user.pk
print("contexto = ",contexto)
return contexto
def get_client_context(self, verb, **kwargs):
print("get_client_context________________________")
return {'id__': self.connection.user.pk}
def send(self, data, channel_setup=None, **kwargs):
print("metodo send______________________-")
self.context['state'] = 'success'
if 'verb' in self.context:
client_context = self.get_client_context(self.context['verb'], **kwargs)
self._update_client_context(client_context)
print("Client_context : "+str(client_context))
message = format_message(data=data, context=self.context, channel_setup=channel_setup)
#print("se enviara el mensaje "+str(message))
self.connection.send(message)
print("se ENVIO mensaje "+str(message))
route_handler.register(NotificacionesRouter)
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU Affero General Public License for more details.
#
# You should have received a copy of the GNU Affero General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
#
"""
SwampDragon routers - Register channels available to the client-side (browser)
"""
# Imports #####################################################################
from swampdragon import route_handler
from swampdragon.route_handler import BaseRouter
# Routers #####################################################################
class NotificationRouter(BaseRouter): #pylint: disable=abstract-method,missing-docstring
route_name = 'notifier'
def get_subscription_channels(self, **kwargs):
return ['notification', 'log']
# Routers registration ########################################################
route_handler.register(NotificationRouter)
def test_on_message(self):
route_handler.register(TestRouter)
data = {"verb": "say_hello", "route": TestRouter.get_name()}
self.connection.on_message(data)
self.assertTrue(self.connection.hello_said)
from swampdragon.route_handler import ModelRouter
from todo.models import TodoList, TodoItem
from todo.serializers import TodoListSerializer, TodoItemSerializer
class TodoListRouter(ModelRouter):
route_name = 'todo-list'
serializer_class = TodoListSerializer
model = TodoList
def get_object(self, **kwargs):
return self.model.objects.get(pk=kwargs['id'])
def get_query_set(self, **kwargs):
return self.model.objects.all()
class TodoItemRouter(ModelRouter):
route_name = 'todo-item'
serializer_class = TodoItemSerializer
model = TodoItem
def get_object(self, **kwargs):
return self.model.objects.get(pk=kwargs['id'])
def get_query_set(self, **kwargs):
return self.model.objects.filter(todo_list__id=kwargs['list_id'])
route_handler.register(TodoListRouter)
route_handler.register(TodoItemRouter)
def test_on_message_invalid_verb(self):
route_handler.register(TestRouter)
data = {"verb": "invalid_verb", "route": TestRouter.get_name()}
with self.assertRaises(UnexpectedVerbException):
self.connection.on_message(data)
self.assertTrue(self.connection.is_closed)
def get_subscription_channels(self, **kwargs):
return ['sd_online_users']
def get_online_count(self, **kwargs):
self.send({'online': user_manager.user_count()})
class NotificationRouter(BaseRouter):
route_name = 'swampdragon-notifications'
valid_verbs = ['subscribe', 'unsubscribe', 'get_user_count', 'mark_read']
def subscribe(self, **kwargs):
"""
Only subscribe online users
"""
if not self.connection.user:
return
super(NotificationRouter, self).subscribe(**kwargs)
def get_subscription_channels(self, **kwargs):
return ['sd_notification_user_{}'.format(self.connection.user.pk)]
def mark_read(self, notification_id):
Notification.objects.filter(user=self.connection.user,
pk=notification_id).update(read=True)
route_handler.register(OnlineUsersRouter)
route_handler.register(NotificationRouter)
user_manager.clear()
from swampdragon import route_handler
from swampdragon.route_handler import ModelRouter
from localground.apps.site.api.realtime_serializers import PhotoRTSerializer
from localground.apps.site.models import Photo
class PhotoRouter(ModelRouter):
route_name = 'photo'
serializer_class = PhotoRTSerializer
model = Photo
def get_object(self, **kwargs):
return self.model.objects.get(pk=kwargs['id'])
def get_query_set(self, **kwargs):
return self.model.objects.all()
route_handler.register(PhotoRouter)
#theme.save()
def update(self, **kwargs):
comment = get_object_or_404(Comment, pk=kwargs['comment'])
comment.good = comment.good + 1
comment.save()
class ThemeRegisterRouter(ModelRouter):
route_name = 'route-register'
serializer_class = ThemeRegisterSerializer
model = ThemeRegister
def get_object(self, **kwargs):
obj, created = self.model.objects.get_or_create(user=self.connection.user, theme=get_object_or_404(Theme, pk=kwargs['theme']))
# print(obj.is_read, created)
return obj
def get_query_set(self, **kwargs):
if kwargs['theme'] == "":
obj = self.model.objects.filter(user=self.connection.user)
else:
obj = self.model.objects.filter(theme=get_object_or_404(Theme, pk=kwargs['theme']))
return obj
route_handler.register(UserRouter)
route_handler.register(ThemeRouter)
route_handler.register(CommentRouter)
route_handler.register(ThemeRegisterRouter)
def get_subscription_channels(self, **kwargs):
return ['sd_online_users']
def get_online_count(self, **kwargs):
self.send({'online': user_manager.user_count()})
class NotificationRouter(BaseRouter):
route_name = 'swampdragon-notifications'
valid_verbs = ['subscribe', 'unsubscribe', 'get_user_count', 'mark_read']
def subscribe(self, **kwargs):
"""
Only subscribe online users
"""
if not self.connection.user:
return
super(NotificationRouter, self).subscribe(**kwargs)
def get_subscription_channels(self, **kwargs):
return ['sd_notification_user_{}'.format(self.connection.user.pk)]
def mark_read(self, notification_id):
Notification.objects.filter(user=self.connection.user, pk=notification_id).update(read=True)
route_handler.register(OnlineUsersRouter)
route_handler.register(NotificationRouter)
user_manager.clear()
