Beispiel #1
0
def create_message(sender_id, content, channel_id):
    new_message = Message(sender=sender_id,
                          content=content,
                          channel=channel_id)
    db.session.add(new_message)
    db.session.commit()
    return new_message.serialize()
Beispiel #2
0
def create_message_to_channel(user_id, channel_id, content):
    new_message = Message(user_id=user_id,
                          channel_id=channel_id,
                          content=content)
    db.session.add(new_message)
    db.session.commit()
    return new_message.serialize()
Beispiel #3
0
 async def create_message(self, ctx):
     user = ctx.user
     ws = ctx.extensions.get('ws')
     snowflake = ctx.services.get('snowflake')
     websocket = ctx.services.get('websocket')
     try:
         channel = Channel.nodes.first_or_none(uid=kwargs['url_data']['channel.id'])
     except KeyError:
         raise web.HTTPBadRequest()
     if not channel:
         raise web.HTTPBadRequest()
     board = channel.board_parent.single()
     role_uid = board.subscribers.relationship(user).role
     role = Role.nodes.first_or_none(uid=role_uid)
     if not role:
         raise web.HTTPBadRequest()
     if (role.permissions & 8 == 8) or (role.permissions & 2048 == 2048):
         message_data = ctx.sent_data
         content = message_data['content']
     if content == '':
         raise web.HTTPBadRequest()
     new_message = Message(uid=await snowflake(), content=content)
     new_message.save()
     new_message.author.connect(user)
     new_message.channel.connect(channel)
     await ws.event(EventType.MESSAGE_CREATE, board.subscribers, message=new_message)
     return ctx.respond(jsonify(new_message))
Beispiel #4
0
def get_chat_messages_data(game_id: int, oldest_id: int, newest_id: int,
                           newer_messages: bool):
    older_message = Message.get_or_none((Message.game == game_id)
                                        & (Message.id < oldest_id))
    has_older_message = older_message is not None

    MESSAGE_LIMIT = 20
    if newer_messages:
        messages = Message.select().where((Message.game == game_id) & (Message.id > newest_id)).order_by(-Message.id)\
            .limit(MESSAGE_LIMIT).execute()
    else:
        messages = Message.select().where((Message.game == game_id) & (Message.id < oldest_id)).order_by(-Message.id)\
            .limit(MESSAGE_LIMIT).execute()

    # Note: oldest_id and newest_id could be -1 when frontend has no messages at all

    if len(messages):  # Needed for when newer_messages is False
        oldest_id_in_query = messages[0].id
        has_older_message = Message.get_or_none(
            (Message.game == game_id)
            & (Message.id < oldest_id_in_query))
        has_older_message = has_older_message is not None

    reversed_messages = [
        messages[len(messages) - i - 1] for i in range(len(messages))
    ]
    return reversed_messages, has_older_message
Beispiel #5
0
def group_chat(id_=None):
    form = MessageForm()
    if request.method == 'POST':
        content = form.data.content
        send2 = form.data.send2
        send2user = User.get_or_404(id=send2)
        message = Message(create_by=current_user.id,
                          content=content,
                          send2=send2)
        message.save()
    msgs = Message.objects(send2=id_)
    return render_template('/group_chat.html', msgs=msgs, form=form)
def create_message(chat_id, body):
    message = Message(timestamp=datetime.datetime.now(),
                      content=body.get("content"),
                      sender_id=body.get("sender_id"),
                      chat_id=chat_id)
    chat = Chat.query.filter_by(id=chat_id).first()
    sender = User.query.filter_by(id=body.get("sender_id")).first()
    if sender not in chat.users:
        return None
    for user in chat.users:
        if user is not sender:
            user.messages_received.append(message)
    db.session.add(message)
    db.session.commit()
    return message.serialize()
Beispiel #7
0
def send_message_to_group(sender_id, group_id, message):
    sender = User.query.filter_by(id=sender_id).first()
    group = Group.query.filter_by(id=group_id).first()
    if sender is None or group is None or sender not in group.members:
        return None

    new_message = Message(
        sender_id=sender_id,
        group_id=group_id,
        message=message
    )

    db.session.add(new_message)
    db.session.commit()
    return new_message.serialize()
Beispiel #8
0
def send_message(roomname):
    ''' Send a message '''
    message = request.json["message"]
    if "username" not in message and \
       "roomname" not in message and \
       "content" not in message and \
       "timestamp" not in message:
        abort(UNPROCESSABLE_ENTITY_ERROR)
    elif message["roomname"] not in cached_rooms or \
         message["username"] not in cached_users:
        abort(NOT_FOUND_ERROR)
    elif message["username"] not in cached_rooms[message["roomname"]]:
        abort(UNAUTHORIZED_ERROR)
    else:
        # Well formed message, send it!
        timestamp = datetime.fromtimestamp(message["timestamp"])
        this_offset = room_offsets[message["roomname"]] + 1
        sent_message = Message(offset=this_offset,
                               roomname=message["roomname"],
                               username=message["username"],
                               content=message["content"],
                               timestamp=timestamp)
        print(
            f'Trying to send message {message} and the offset is {room_offsets[message["roomname"]]}'
        )
        if not db.send_message(sent_message):
            abort(INTERNAL_SERVER_ERROR)
        else:
            # Successfully saved the message to the db
            room_offsets[message["roomname"]] = this_offset
            cached_messages[message["roomname"]].append(sent_message)

    return jsonify({'status': 200})  # What to send back here?
Beispiel #9
0
def my_timeline():
    	user = get_session_user()
	assert user is not None
    	messages = Message.select().where(
        	Message.user == user
    	)
    	return object_list('my_messages.html', messages, 'message_list')
Beispiel #10
0
def act_sendMessage(data):
    userId = dbi.getXbyY('User', 'sid', data['sid']).id
    msgTime = misc.generateTimeForTest() if misc.TEST_MODE else math.trunc(
        time.time())
    text = data['text']
    dbi.add(Message(userId, text, msgTime))
    return {'result': 'ok'}
Beispiel #11
0
def post_message_to_group(user_id, group_id):
    group = Group.query.filter_by(id=group_id).first()
    if group is None:
        return json.dumps({
            "success": False,
            "error": "Group not found..."
        }), 404
    post_body = json.loads(request.data)
    message = Message(user_id=user_id,
                      group_id=group_id,
                      description=post_body.get("description"))
    db.session.add(message)
    db.session.commit()
    return json.dumps({
        'success': True,
        'data': message.serialize_group()
    }), 201
Beispiel #12
0
def _log_msg(text, source, update, state=None, chat_id=None):
    chat_id = chat_id or update.effective_chat.id
    msg = Message(msg=text,
                  source=source,
                  chat_id=chat_id,
                  state=state,
                  server_time=datetime.utcnow())
    Database().insert(msg)
Beispiel #13
0
def create_message_with_file(file):
    a = AlfaCV(file)
    messages = a.get_messages()

    bulk_list = []
    for message in messages:
        parser = ParserMessage(message)

        bulk_list.append(
            Message(card=parser.get_card(),
                    balance=parser.get_balance(),
                    amount=parser.get_amount(),
                    currency=parser.get_currency(),
                    date=parser.get_date(),
                    body=parser.text))

    Message.bulk_create(bulk_list)
Beispiel #14
0
def private_timeline():
    	# the private timeline exemplifies the use of a subquery -- we are asking for
    	# messages where the person who created the message is someone the current
    	# user is following.  these messages are then ordered newest-first.
    	user = get_session_user()
	assert user is not None
    	messages = Message.select().where(
        	Message.user << user.following()
    	)
    	return object_list('private_messages.html', messages, 'message_list')
Beispiel #15
0
def score_message(hug_token, message_id: hug.types.number,
                  score: hug.types.number):
    try:
        msg = Message.get(Message.token == Token.get(Token.token == hug_token),
                          Message.id == message_id, Message.reply_to != None)
        Score.create(message=msg, value=score)
        return {"status": "ok"}
    except Message.DoesNotExist:
        raise HTTPError(HTTP_404)
    except peewee.IntegrityError:
        raise HTTPError(HTTP_409)
Beispiel #16
0
 def setUp(self):
     super().setUp()
     with db.atomic() as txn:
         self.game = Game.create(
             name='Game',
             starting_cash=10000.00,
             shareable_link='aaaabbbbccccdddd',
             shareable_code='aaaa',
             ends_at=(datetime.utcnow().replace(tzinfo=pytz.utc) +
                      timedelta(days=7)).isoformat())
         profile = Profile.create(username='******',
                                  hashed_password='******')
         GameProfile.create(game=self.game, profile=profile, cash=-1.0)
         Message.create(
             game=self.game.id,
             profile=profile.id,
             content="first message",
             # use default value for created_on
         )
         self.token = AuthToken.create(profile=profile,
                                       token='thevalidtoken').token
Beispiel #17
0
def show_db_message_table():
    # creating HTML table from dict
    messages = {}
    query = Message.select().dicts()
    msg_id = 0
    for row in query:
        messages[msg_id] = row
        msg_id += 1
    df = pd.DataFrame(data=messages)
    df = df.fillna(' ').T
    resp = df.to_html()
    return resp
Beispiel #18
0
def add_message(from_user, to_user, content):
    f_user = session.query(User.name).filter_by(name=from_user).first()[0]
    t_user = session.query(User.name).filter_by(name=to_user).first()[0]

    if f_user and t_user:
        new_message = Message(from_user=f_user,
                              to_user=t_user,
                              content=content)

        session.add(new_message)
        session.commit()
        print('************ insert successful ************')
        return True
Beispiel #19
0
 def __init__(self, resources):
     self._mutex = threading.RLock()
     logging.info('Starting logging thread')
     self._object = resources.object
     self._resources = resources
     db = self._resources.getDbManager()
     self._log = Log(db)
     self._message = Message(db)
     self._plc = self._resources.plcManager
     self._position = self._resources.plcManager.getPositionHelper()
     self._period = resources.config.getLoggingTime()
     self._altitude = None
     self._start()
Beispiel #20
0
def message():
    if request.method == 'POST':
        if request.form.get('name') and request.form.get('message_content'):
            message = Message(
                ip_address=request.remote_addr,
                date_time=datetime.utcnow().isoformat(),
                name=request.form['name'],
                content=request.form['message_content']
            )
            db.session.add(message)

            db.session.commit()
        
        return jsonMessages()
Beispiel #21
0
def add_message_to_assignment(class_id, assign_id):
    post_body = json.loads(request.data)
    single_class = Class.query.filter_by(id=class_id).first()
    assignment = Assignment.query.filter_by(id=assign_id).first()
    user = User.query.filter_by(username=post_body.get('username')).first()
    if single_class is None:
        return json.dumps({'success': False, 'error': 'Class not found'}), 404
    elif assignment is None:
        return json.dumps({
            'success': False,
            'error': 'Assignment not found'
        }), 404
    message = Message(message=post_body.get('message', ''),
                      username=post_body.get('username', 'anonymous'),
                      name=post_body.get('name', 'anonymous'),
                      time=post_body.get('time', '2000-01-01T00:00:00'),
                      assignment_id=assign_id)
    if user is not None:
        user.classes.append(single_class)
        user.assignments.append(assignment)
    assignment.messages.append(message)
    db.session.add(message)
    db.session.commit()
    return json.dumps({'success': True, 'data': message.serialize()}), 200
Beispiel #22
0
def create():
    	if request.method == 'GET':
		return render_template('create.html')
	content = request.form.get('content')
	if not content:
        	flash('Please input message')
		return redirect(url_for('create'))
    	user = get_session_user()
	assert user is not None
        message = Message.create(
           user=user,
           content=content,
           pub_date=datetime.datetime.now()
        )
        flash('Your message has been created')
        return redirect(url_for('user_detail', username=user.username))
Beispiel #23
0
def contact():
    error, success = False, False
    if request.method == 'POST':
        name = request.form['name']
        email = request.form['email']
        message = request.form['message']
        date = datetime.now().__str__()
        try:
            new_message = Message(name=name,
                                  email=email,
                                  message=message,
                                  date=date)
            session.add(new_message)
            session.commit()
            success = True
        except:
            error = True
    return render_template('contact.html', error=error, success=success)
Beispiel #24
0
def main():
    Session = sessionmaker(bind=engine)
    session = Session()

    r = re.compile(
        '^(?P<sender>[\w-]+)>([^:]+)::(?P<recipient>[^:]+):(?P<body>[^{]*){?(.*)$'
    )

    while True:
        try:
            s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
            s.connect((settings.APRS_IS_HOST, settings.APRS_IS_PORT))
            s.sendall('user %s pass %s\n' %
                      (settings.CALLSIGN, doHash(settings.CALLSIGN)))

            try:
                f = s.makefile()
                for l in f:
                    print l,
                    m = r.match(l)
                    if not m:
                        continue

                    sender = m.group('sender').strip()
                    recipient = m.group('recipient').strip()
                    body = m.group('body').strip()

                    session.add(
                        Message(sender=sender, recipient=recipient, body=body))
                    try:
                        session.commit()
                    except DataError as e:
                        print 'ERROR:', e
            except KeyboardInterrupt:
                raise
            finally:
                f.close()
        except KeyboardInterrupt:
            break
        finally:
            s.shutdown(socket.SHUT_RDWR)
            s.close()
Beispiel #25
0
def create_chat_message(profile_id, game_id, message):
    try:
        int(profile_id)
        int(game_id)
        assert len(message) > 0
    except:
        raise BadRequest("Invalid parameters to create chat message")

    message = Message.create(
        game=game_id,
        profile=profile_id,
        content=message,
        # use default value for created_on
    )

    game = Game.get_or_none(Game.id == game_id)
    if game is not None:
        print("Broadcaseting to game")
        broadcast_in_a_game(game, 'chat', '', False)

    return message
Beispiel #26
0
    async def on_message(self, message):
        if message.author == self.user:
            return

        if config.get(
                'channels-whitelist') and message.channel.name not in strip(
                    config.get('channels-whitelist').split(',')):
            return

        if config.get('channels-blacklist') and message.channel.name in strip(
                config.get('channels-blacklist').split(',')):
            return

        content = message.content
        mentions = message.mentions
        bot_mention = lambda user: not user.bot
        if all(mentions, bot_mention):
            return

        if message.author.bot:
            return

        if len(message.attachments) > 0:
            return

        r = s.query(Message).filter(
            Message.message.ilike(content)).one_or_none()
        if r:
            channel = message.channel
            await message.delete()
            await channel.say(
                '{0} Your message has been deleted as an identical message has been sent already.'
                .format(author.mention))
        else:
            db_entry = Message(username=message.author.name, message=content)
            s.add(db_entry)
            s.commit()
Beispiel #27
0
def process_question(message):
    return Message.create(token=message.token,
                          content='Reply to: ' + message.content,
                          reply_to=message)
Beispiel #28
0
 def save_massage(self, user_id, message):
     mes = Message(user_id, message)
     session.add(mes)
     session.commit()
Beispiel #29
0
def send_message(hug_token, message: hug.types.text):
    msg = Message.create(content=message,
                         token=Token.get(Token.token == hug_token))
    return model_to_dict(chatbot.process_question(msg))
Beispiel #30
0
from alfa_cv import AlfaCV
from parser_message import ParserMessage
from db import Message

a = AlfaCV('history.jpg')
messages = a.get_messages()

bulk_list = []
for message in messages:
    parser = ParserMessage(message)

    bulk_list.append(
        Message(card=parser.get_card(),
                balance=parser.get_balance(),
                amount=parser.get_amount(),
                currency=parser.get_currency(),
                date=parser.get_date(),
                body=parser.text))

Message.bulk_create(bulk_list)
Beispiel #31
0
 def create(self, content):
     m = Message(content=content)
     super().create(m)
Beispiel #32
0
class LogThread(object):
    """ Separate thread for logging stuff.
    It starts to log in separate thread as new instance will be done  or _start() method will be called
    Timer could be stopped be calling stop() method.  """

    def __init__(self, resources):
        self._mutex = threading.RLock()
        logging.info('Starting logging thread')
        self._object = resources.object
        self._resources = resources
        db = self._resources.getDbManager()
        self._log = Log(db)
        self._message = Message(db)
        self._plc = self._resources.plcManager
        self._position = self._resources.plcManager.getPositionHelper()
        self._period = resources.config.getLoggingTime()
        self._altitude = None
        self._start()

    def _start(self):
        """ Starts timer to run, function is looped by itself.
        Should be interrupted by calling timer.cancel() in other case it will become a daemon  """
        if self._plc.isSwitchedOn():
            self._doWork()
        self._timer = threading.Timer(self._period, self._start)
        self._timer.start()

    def stop(self):
        """ Thread safe method for stopping timer. It will finish as soon as timer
        thread stops working and thread will be closed"""
        with self._mutex:
            self._timer.cancel()
            self._timer.join()

    def _doWork(self):
        """ All logging stuff performs here. This method is calling by logging thread """
        with self._mutex:
            if self._resources.plcManager.isConnected():
                self._log.setStarId(self._getStarId())
                self._log.setMsgId(self._getMsgId())
                self._log.setCurrentRaDec(*self._getCurrentRaDec())
                self._log.setCurrentFocus(self._getCurrentFocus())
                self._log.setTemperature(*self._getTemperature())
                self._log.setAlarmStatus(self._getAlarmStatus())
                self._log.setCurrentAltitude(self._getAltitude())
                self._log.writeToLog()

    def force(self):
        with self._mutex:
            self._timer.cancel()
            self._timer.join()
            self._start()

    def updatePeriod(self, time):
        """ Update logging period, period in seconds """
        self._period = time

    def _getStarId(self):
        """ return selected object id from controller, if object is not selected return None """
        object = self._resources.object
        return object.getId()

    def _getMsgId(self):
        """ for getting current message last stored message is used """
        id = self._message.getLastId()
        return id

    def _getCurrentRaDec(self):
        """ current telescope positions are taken directly from plc """
        return self._position.getCurrentPosition()

    def _getAltitude(self):
        if self._object.selected():
            alt, az = self._object.getHorizontalPosition()
            return alt.real

    def _getCurrentFocus(self):
        """ current telescope positions are taken directly from plc """
        focus = self._position.getFocus()
        return focus

    def _getTemperature(self):
        """ current dome and telescope temperatures """
        return self._plc.getModeHelper().readTemperatures()

    def _getAlarmStatus(self):
        """ alarm status as a alarm codes separated by ',' """
        return self._plc.readAlarmStatus()
Beispiel #33
0
def add_message_record(source, text, sent, body):
    logger.info('adding new record to Message table [from:{}, text:{}]'.format(source, text))
    message = Message.create(source=source, text=text, sent=sent, body=body)
    message.save()
Beispiel #34
0
def receive_message(hug_token, after_msg_id: hug.types.number):
    token = Token.get(Token.token == hug_token)
    return Message.select().where(Message.token == token,
                                  Message.reply_to != None,
                                  Message.id > after_msg_id).dicts()
Beispiel #35
0
def public_timeline():
    	# simply display all messages, newest first
    	messages = Message.select()
    	return object_list('public_messages.html', messages, 'message_list')
Beispiel #36
0
    def read_messages(driver, queue, **params):
        page_number = 1
        messages_on_page = 10
        messages = {}
        while True:
            driver.get('%s?t=0&order=DESC&page=%d' %
                       (Player.PAGES['MESSAGES'], page_number))
            time.sleep(2)
            unread_messages = Player._parse_message_table(driver)
            for i in unread_messages:
                messages.update({
                    i[1]: {
                        'header': i[2],
                        'from_id': i[3],
                        'from_name': i[4],
                        'date_time': i[5]
                    }
                })
            if len(unread_messages) < messages_on_page:
                break
            page_number += 1

        for travian_id, message_params in messages.items():
            driver.get('%s?id=%d' % (Player.PAGES['MESSAGES'], travian_id))
            time.sleep(2)

            try:
                body = driver.find_element_by_xpath("//div[@id='message']")
            except NoSuchElementException:
                logging.error('Cant read message mody id=%d' % travian_id)
                return queue
            body = body.text
            message_params['body'] = body

        if messages:
            logging.info('%d New messages!' % len(messages))

        for travian_id, message_params in messages.items():
            Message.create_new(
                travian_id,
                message_params['from_id'],
                message_params['from_name'],
                message_params['header'],
                message_params['body'],
                message_params['date_time'],
            )

        need_def_messages = Message.get_need_def_messages()
        if need_def_messages:
            try:
                server_time = driver.find_element_by_xpath(
                    "//div[@id='servertime']/span")
            except NoSuchElementException:
                logging.error('Cant define servertime')
                return queue

            h, m, s = server_time.text.split(':')
            h = Player._to_int(h)
            m = Player._to_int(m)
            s = Player._to_int(s)
            now = datetime.now()
            year, month, day = now.year, now.month, now.day
            now = datetime(year, month, day, h, m, s)

            for need_def_message in need_def_messages:
                if need_def_message.valid_def_message() is False:
                    logging.warning(
                        'Someone in message travian_id = %s whant def.' %
                        need_def_message.travian_id)
                    continue

                params = need_def_message.get_def_params()
                if params is None:
                    continue
                    return queue
                x, y, atack_time = params
                atack_timedelta = atack_time - now
                if atack_timedelta.total_seconds() < 0:
                    logging.warning('Passed atack. Message travian_id = %s' %
                                    need_def_message.travian_id)
                    need_def_message.readed()
                    continue
                helpers = get_help(x, y, atack_timedelta)
                if 'Dictator' in helpers:
                    helpers.remove('Dictator')

                attention_message = '''
##########################################
            Внимание!
Наша деревня [x|y]({x}|{y})[/x|y] атакована.
Атака будет совершена в {atack_time}.

Всем кто успевает.
Необходимо выслать деф на данные координаты.

p.s. Всем удачи!

И не забывайте выслать кроп для своих войск.
##########################################
'''.format(x=x, y=y, atack_time=str(atack_time))

                head = 'Нужен ДЕФ'
                if helpers:
                    # We can write only for 25 peoples.
                    counter = 0
                    to_helpers = []
                    for helper in helpers:
                        counter += 1
                        to_helpers.append(helper)
                        if counter == 24:
                            Player.write_message(driver, to_helpers, head,
                                                 attention_message)
                            counter = 0
                            to_helpers = []

                    if to_helpers:
                        Player.write_message(driver, to_helpers, head,
                                             attention_message)

                head = 'RE: %s' % need_def_message.header
                if helpers:
                    attention_message = '''
##########################################
Игроки, которые могут оперативно
прислать помощь оповещены.
##########################################
'''
                    dictator_message = '''
##########################################
Наша деревня [x|y]({x}|{y})[/x|y] атакована.
Атака будет совершена в {atack_time}.

Игроки, которые могут помочь проинформированы:
{helpers}
##########################################
'''.format(x=x, y=y, atack_time=str(atack_time), helpers='\n'.join(helpers))

                else:
                    attention_message = '''
##########################################
Нет игроков, готовых оперативно помочь.
##########################################
'''

                    dictator_message = '''
##########################################
Наша деревня [x|y]({x}|{y})[/x|y] атакована.
Атака будет совершена в {atack_time}.

Нет игроков, готовых оперативно помочь.
##########################################
'''.format(x=x, y=y, atack_time=str(atack_time))

                Player.write_message(driver, need_def_message.from_name, head,
                                     attention_message)
                Player.write_message(
                    driver, 'Dictator',
                    'На деревню (%s, %s) будет совершено нападение' % (x, y),
                    dictator_message)
                need_def_message.readed()
        return queue