def search_messages(self, data, room, offset): offset = int(offset) if not RoomUsers.objects.filter(room_id=room, user_id=self.user_id).exists(): raise ValidationError("You can't access this room") messages = Message.objects.filter(content__icontains=data, room_id=room).order_by('-id')[ offset:offset + settings.MESSAGES_PER_SEARCH] imv = get_message_images_videos(messages) result = [] for message in messages: files = MessagesCreator.prepare_img_video(imv, message.id) prep_m = MessagesCreator.create_message(message, files) result.append(prep_m) return result
def send_message(message, giphy=None): if message[VarNames.TIME_DIFF] < 0: raise ValidationError("Back to the future?") files = UploadedFile.objects.filter(id__in=message.get( VarNames.FILES), user_id=self.user_id) symbol = get_max_key(files) channel = message[VarNames.ROOM_ID] js_id = message[VarNames.JS_MESSAGE_ID] message_db = Message(sender_id=self.user_id, content=message[VarNames.CONTENT], symbol=symbol, giphy=giphy, room_id=channel) message_db.time -= message[VarNames.TIME_DIFF] res_files = [] message_db.save() if files: images = up_files_to_img(files, message_db.id) res_files = MessagesCreator.prepare_img_video( images, message_db.id) prepared_message = self.create_send_message( message_db, Actions.PRINT_MESSAGE, res_files, ) prepared_message[VarNames.JS_MESSAGE_ID] = js_id self.publish(prepared_message, channel) self.notify_offline(channel, message_db.id)
def edit_message_edit(self, data, message): action = Actions.EDIT_MESSAGE message.giphy = None tags = data[VarNames.MESSAGE_TAGS] files = UploadedFile.objects.filter(id__in=data.get(VarNames.FILES), user_id=self.user_id) if files or tags: update_symbols(files, tags, message) if tags: db_tags = MessageMention.objects.filter(message_id=message.id) update_or_create = [] update_or_create_dict = {} for db_tag in db_tags: if tags.get(db_tag.symbol) and tags.get(db_tag.symbol) != db_tag.user_id: update_or_create.append(MessageMention(message_id=message.id, symbol=db_tag.symbol, user_id=tags[db_tag.symbol])) update_or_create_dict[db_tag.symbol] = True if update_or_create: MessageMention.objects.bulk_update(update_or_create) create_tags = [] for (k, v) in tags.items(): if not update_or_create_dict.get(k): create_tags.append(MessageMention(message_id=message.id, symbol=k, user_id=v)) if create_tags: MessageMention.objects.bulk_create(create_tags) if files: up_files_to_img(files, message.id) if message.symbol: # fetch all, including that we just store db_images = Image.objects.filter(message_id=message.id) prep_files = MessagesCreator.prepare_img_video(db_images, message.id) else: prep_files = None Message.objects.filter(id=message.id).update(content=message.content, symbol=message.symbol, giphy=None, edited_times=get_milliseconds()) self.publish(self.message_creator.create_send_message(message, action, prep_files, tags), message.room_id)
def profile(self, id): try: user_profile = UserProfile.objects.get(pk=id) profile = MessagesCreator.get_user_profile(user_profile) profile['image'] = user_profile.photo.url if user_profile.photo.url else None return profile except ObjectDoesNotExist: raise tornado.web.HTTPError(404)
def get_users_in_current_user_rooms(user_id): user_rooms = Room.objects.filter(users__id=user_id, disabled=False).values('id', 'name', 'roomusers__notifications', 'roomusers__volume') res = MessagesCreator.create_user_rooms(user_rooms) room_ids = (room_id for room_id in res) rooms_users = User.objects.filter(rooms__in=room_ids).values('id', 'username', 'sex', 'rooms__id') for user in rooms_users: dict = res[user['rooms__id']][VarNames.ROOM_USERS] dict[user['id']] = RedisPrefix.set_js_user_structure(user['username'], user['sex']) return res
def search_messages(request): data = request.POST['data'] room_id = request.POST['room'] offset = int(request.POST['offset']) if not RoomUsers.objects.filter(room_id=room_id, user_id=request.user.id).exists(): raise ValidationError("You can't access this room") messages = Message.objects.filter( content__icontains=data, room_id=room_id).order_by('-id')[offset:offset + settings.MESSAGES_PER_SEARCH] imv = get_message_images_videos(messages) result = [] for message in messages: files = MessagesCreator.prepare_img_video(imv, message.id) prep_m = MessagesCreator.create_message(message, files) result.append(prep_m) response = json.dumps(result) return HttpResponse(response, content_type='application/json')
def show_profile(request, profile_id): try: user_profile = UserProfile.objects.get(pk=profile_id) profile = MessagesCreator.get_user_profile(user_profile) profile[ 'image'] = user_profile.photo.url if user_profile.photo.url else None return HttpResponse(json.dumps(profile), content_type='application/json') except ObjectDoesNotExist: raise Http404
def upload_profile_image(self, files): """ POST only, validates email during registration """ up = UserProfile(photo=files['file'], id=self.user_id) up.save(update_fields=('photo',)) url = up.photo.url message = json.dumps(MessagesCreator.set_profile_image(url)) channel = RedisPrefix.generate_user(self.user_id) global_redis.sync_redis.publish(channel, message) return settings.VALIDATION_IS_OK
def upload_profile_image(request): """ POST only, validates email during registration """ up = UserProfile(photo=request.FILES['file'], id=request.user.id) up.save(update_fields=('photo', )) url = up.photo.url message = json.dumps(MessagesCreator.set_profile_image(url)) channel = RedisPrefix.generate_user(request.user.id) global_redis.sync_redis.publish(channel, message) return HttpResponse(settings.VALIDATION_IS_OK, content_type='text/plain')
def search_messages(self, data): offset = data[VarNames.SEARCH_OFFSET] #// room, offset messages = Message.objects.filter( content__icontains=data[VarNames.SEARCH_STRING], room_id=data[VarNames.ROOM_ID] # access permissions is already checked on top level by ROOM_ID ).order_by('-id')[offset:offset + settings.MESSAGES_PER_SEARCH] content = MessagesCreator.message_models_to_dtos(messages) self.ws_write({ VarNames.CONTENT: content, VarNames.JS_MESSAGE_ID: data[VarNames.JS_MESSAGE_ID], VarNames.HANDLER_NAME: HandlerNames.NULL })
def register(self, username, password, email, sex): check_user(username) self.__check_password(password) self.__check_email__(email) user_profile = UserProfile(username=username, email=email, sex_str=sex) user_profile.set_password(password) user_profile.save() RoomUsers(user_id=user_profile.id, room_id=settings.ALL_ROOM_ID, notifications=False).save() if email: yield from self.__send_sign_up_email(user_profile) return MessagesCreator.get_session( self.__generate_session__(user_profile.id))
def auth(self, username, password): """ Logs in into system. """ try: if '@' in username: user = UserProfile.objects.get(email=username) else: user = UserProfile.objects.get(username=username) if not user.check_password(password): raise ValidationError("Invalid password") except User.DoesNotExist: raise ValidationError("User {} doesn't exist".format(username)) return MessagesCreator.get_session(self.__generate_session__(user.id))
def sync_history(self, in_message): room_ids = in_message[VarNames.ROOM_IDS] message_ids = in_message[VarNames.MESSAGE_IDS] if not set(room_ids).issubset(self.channels): raise ValidationError("This is not a messages in the room you are in") messages = Message.objects.filter( Q(room_id__in=room_ids) & ~Q(id__in=message_ids) & Q(edited_times__gt=get_milliseconds() - in_message[VarNames.LAST_SYNCED]) ) content = MessagesCreator.message_models_to_dtos(messages) self.ws_write({ VarNames.CONTENT: content, VarNames.JS_MESSAGE_ID: in_message[VarNames.JS_MESSAGE_ID], VarNames.HANDLER_NAME: HandlerNames.NULL })
def send_message(message, giphy=None): if message[VarNames.TIME_DIFF] < 0: raise ValidationError("Back to the future?") tags_users = message[VarNames.MESSAGE_TAGS] files = UploadedFile.objects.filter(id__in=message.get(VarNames.FILES), user_id=self.user_id) symbol = max_from_2(get_max_symbol(files), get_max_symbol_dict(tags_users)) channel = message[VarNames.ROOM_ID] js_id = message[VarNames.JS_MESSAGE_ID] parent_message_id = message[VarNames.PARENT_MESSAGE] if parent_message_id: parent_room_id = Message.objects.get(id=parent_message_id).room_id if parent_room_id not in self.channels: raise ValidationError("You don't have access to this room message") message_db = Message( sender_id=self.user_id, content=message[VarNames.CONTENT], symbol=symbol, parent_message_id=parent_message_id, giphy=giphy, room_id=channel ) message_db.time -= message[VarNames.TIME_DIFF] res_files = [] message_db.save() if tags_users: mes_ment = [MessageMention( user_id=userId, message_id=message_db.id, symbol=symb, ) for symb, userId in tags_users.items()] MessageMention.objects.bulk_create(mes_ment) if files: images = up_files_to_img(files, message_db.id) res_files = MessagesCreator.prepare_img_video(images, message_db.id) prepared_message = self.message_creator.create_send_message( message_db, Actions.PRINT_MESSAGE, res_files, tags_users ) prepared_message[VarNames.JS_MESSAGE_ID] = js_id self.publish(prepared_message, channel) self.notify_offline(channel, message_db.id)
def edit_message_edit(self, data, message): action = Actions.EDIT_MESSAGE message.giphy = None files = UploadedFile.objects.filter(id__in=data.get(VarNames.FILES), user_id=self.user_id) if files: update_symbols(files, message) up_files_to_img(files, message.id) if message.symbol: # fetch all, including that we just store db_images = Image.objects.filter(message_id=message.id) prep_files = MessagesCreator.prepare_img_video( db_images, message.id) else: prep_files = None Message.objects.filter(id=message.id).update( content=message.content, symbol=message.symbol, giphy=None, edited_times=message.edited_times) self.publish(self.create_send_message(message, action, prep_files), message.room_id)
def send_message(message, giphy=None): files = UploadedFile.objects.filter(id__in=message.get( VarNames.FILES), user_id=self.user_id) symbol = get_max_key(files) channel = message[VarNames.CHANNEL] js_id = message[VarNames.JS_MESSAGE_ID] message_db = Message(sender_id=self.user_id, content=message[VarNames.CONTENT], symbol=symbol, giphy=giphy, room_id=channel) res_files = [] do_db(message_db.save) if files: images = up_files_to_img(files, message_db.id) res_files = MessagesCreator.prepare_img_video( images, message_db.id) prepared_message = self.create_send_message( message_db, Actions.PRINT_MESSAGE, res_files, js_id) self.publish(prepared_message, channel) self.notify_offline(channel, message_db.id)
def register(self, username, password, email, sex): check_user(username) self.__check_password(password) self.__check_email__(email) user_profile = UserProfile(username=username, email=email, sex_str=sex) user_profile.set_password(password) user_profile.save() RoomUsers(user_id=user_profile.id, room_id=settings.ALL_ROOM_ID, notifications=False).save() user_data = { VarNames.ROOMS: [{ VarNames.ROOM_ID: settings.ALL_ROOM_ID, VarNames.ROOM_USERS: list( RoomUsers.objects.filter(room_id=ALL_ROOM_ID).values_list( 'user_id', flat=True)) }], VarNames.EVENT: Actions.CREATE_NEW_USER, VarNames.HANDLER_NAME: HandlerNames.ROOM, } user_data.update( RedisPrefix.set_js_user_structure(user_profile.id, user_profile.username, user_profile.sex, None)) global_redis.async_redis_publisher.publish( settings.ALL_ROOM_ID, json.dumps(user_data), ) if email: yield from self.__send_sign_up_email(user_profile) return MessagesCreator.get_session( self.__generate_session__(user_profile.id))
def ping_online(): message = encode_message(MessagesCreator.ping_client(get_milliseconds()), True) logger.info("Pinging clients: %s", message) async_redis_publisher.publish(ALL_ROOM_ID, message)
def __oauth(self, token, handler): user_profile, is_new = handler.generate_user_profile(token) return MessagesCreator.get_oauth_session( self.__generate_session__(user_profile.id), user_profile.username, is_new)
def set_video_images_messages(self, imv, inm, outm): for message in inm: files = MessagesCreator.prepare_img_video(imv, message.id) prep_m = self.create_message(message, files) outm.setdefault(message.room_id, []).append(prep_m)