Exemplo n.º 1
0
def handle_postback(raw_event):
    bot = Bot(utils.config["page_access_token"])
    cuser = messages.user(bot.get_user_info(raw_event["sender"]["id"]),
                          raw_event["sender"]["id"])

    payload = raw_event["postback"]["payload"]

    red_user = utils.get_redis(cuser.id)

    # welcome message, user has not signed up yet
    if red_user == None:
        messages.intro_message(bot, cuser)
        return

    # if something is different between the user and the database user
    if red_user.is_different(cuser):
        utils.set_redis(cuser.id, red_user)

    if payload == "starting_gate":
        # and not red_user.looking_for_chat:
        if not red_user.in_chat and not red_user.looking_for_chat:

            red_user.set_looking_for_chat()
            found_chat = red_user.search_for_chat()

            bot.send_text_message(red_user.id, "Searching...")
            if found_chat:
                messages.found_chat_reply(bot, red_user, found_chat)

        elif red_user.looking_for_chat:
            messages.send_in_limbo(bot, red_user)

    elif payload == "decision_time_yes" or payload == "decision_time_no":
        if not red_user.on_edge:
            return

        other_user = utils.get_redis(red_user.in_chat_with)

        if payload == "decision_time_no":
            messages.decision_time_no(bot, red_user, other_user)
        else:
            if red_user.showed_id:
                messages.waiting_for_decision(bot, red_user)
                return
            messages.decision_time_yes(bot, red_user, other_user)

    elif payload == "start_message":
        handle_message(raw_event)
Exemplo n.º 2
0
def work(cmd):
    s = get_redis()

    last_log = s.lindex(LOG_KEY, 0)
    if (not last_log) or last_log.split()[1] != cmd:
        s.lpush(LOG_KEY, '%.3f %s' % (time.time(), cmd))
        s.ltrim(LOG_KEY, 0, MAX_LOG_LINES - 1)

    single(MQTT_CHANNEL, cmd, retain=True, **MQTT_KWARGS)
Exemplo n.º 3
0
def read_log(parse_time=False):
    s = get_redis()

    ret = []

    try:
        for line in s.lrange(LOG_KEY, 0, -1):
            line = line.split()

            ret.append({
                'time': datetime.fromtimestamp(float(line[0])),
                'cmd': line[1]
            })
    except Exception:
        raise

    return ret
Exemplo n.º 4
0
def handle_auth_message(user_id, code):
    # get the info used for all messages
    bot = Bot(utils.config["page_access_token"])
    cuser = utils.get_redis(user_id)
    new_user = False

    if cuser == None:
        cuser = messages.user(bot.get_user_info(user_id), user_id)
        new_user = True

    needs_update = cuser.needs_api_update
    cuser.needs_api_update = False
    cuser.set_api_key(code)
    utils.set_redis(user_id, cuser)

    if new_user:
        messages.after_registering(cuser)
    elif needs_update:
        messages.refresh_api_key()
Exemplo n.º 5
0
def handle_message(raw_event):
    # use pymessenger to make an API call to FB to get the
    # info about the user who send the message
    bot = Bot(utils.config["page_access_token"])
    user_id = raw_event["sender"]["id"]
    user_info = bot.get_user_info(user_id)

    cuser = messages.user(user_info, user_id)

    red_user = utils.get_redis(cuser.id)

    # welcome message, user has not signed up yet
    if red_user == None:
        messages.intro_message(bot, cuser)
        return

    # if something is different between the user and the database user
    if red_user.is_different(cuser):
        utils.set_redis(cuser.id, red_user)

    elif red_user.looking_for_chat:
        messages.send_in_limbo(bot, red_user)

    elif red_user.in_chat:
        if "message" in raw_event.keys():
            raw_message = raw_event["message"]
            messages.handle_chat(bot, red_user, raw_message)
        else:
            bot.send_text_message(user_id, "You are in a chat currently")

    elif red_user.on_edge and not red_user.showed_id:
        messages.send_decision_message(bot, red_user)

    elif red_user.on_edge and red_user.showed_id:
        messages.waiting_for_decision(bot, red_user)

    elif not red_user.in_chat and not red_user.looking_for_chat and not red_user.on_edge:
        messages.send_starting_gate(bot, red_user)
Exemplo n.º 6
0
def handle_chat(bot, cuser, raw_message):
    other_user = utils.get_redis(cuser.in_chat_with)

    messages_display = cuser.messages_left
    cuser.messages_left -= 1
    other_user.messages_left -= 1

    messages_left = cuser.messages_left

    if messages_left == 0:
        cuser.in_chat = False
        cuser.on_edge = True
        other_user.in_chat = False
        other_user.on_edge = True
        cuser.messages_left = 20
        other_user.messages_left = 20

    utils.set_redis(cuser.id, cuser)
    utils.set_redis(other_user.id, other_user)

    if "text" in raw_message.keys():
        text_message = raw_message["text"]
        text = "{0}: '{1}'".format(messages_display, text_message)
        bot.send_text_message(other_user.id, text)

    elif "url" in raw_message["attachments"][0]["payload"].keys():
        img_url = raw_message["attachments"][0]["payload"]["url"]
        text = "{0}:".format(messages_display)

        bot.send_text_message(other_user.id, text)
        bot.send_image_url(other_user.id, img_url)

    if messages_left == 0:
        send_decision_message(bot, cuser)
        send_decision_message(bot, other_user)
    elif messages_left == 1:
        bot.send_text_message(cuser.id, "You have one message left!")
        bot.send_text_message(other_user.id, "You have one message left!")
Exemplo n.º 7
0
from settings import TOKEN
from utils import get_redis

db = get_redis()

PUB_TOKEN = TOKEN.split(':')[0]


def add_member(uid):
    return db.sadd('BOT:' + PUB_TOKEN, uid)


def members_count():
    return db.scard('BOT:' + PUB_TOKEN)


def get_adv_key():
    return 'BOT:%s:ADS' % PUB_TOKEN


Exemplo n.º 8
0
from rq import Queue
from redis import Redis
from worker_jobs import *
import utils
import time
from flask import Flask, jsonify, request
import neo4j_queries

app = Flask(__name__)

# Tell RQ what Redis connection to use
redis_conn = utils.get_redis()

# define three different priority queues for jobs to be added to
q_high = Queue('highdepends', connection=redis_conn)
q_medium = Queue('mediumdepends', connection=redis_conn)
q_low = Queue('lowdepends', connection=redis_conn)


@app.route('/dependents/project', methods=['POST'])
def create_parse_project_task():
    if not request.json or not 'github_short_url' in request.json:
        return 400

    task = {
        'github_short_url': request.json['github_short_url'],
    }

    job = q_high.enqueue(fetch_project,
                         task.get('github_short_url'),
                         timeout=180)
Exemplo n.º 9
0
from rq import Connection, Queue, Worker
import requests
import utils
import os

# Start a worker and begin listening on the redis job queue
if __name__ == '__main__':
    # Tell rq what Redis connection to use
    with Connection(utils.get_redis()):
        queue = os.environ.get('RQ_QUEUE')
        q = Queue(queue)
        Worker(q).work()
Exemplo n.º 10
0
def get_user_from_profile_id(profile_id):
    string = "-" + str(profile_id)
    chat_id = utils.get_redis(string)
    cuser = utils.get_redis(chat_id)
    return cuser
Exemplo n.º 11
0
from __future__ import print_function
from utils import get_descriptor_from_event, kp_loads, prt, get_redis
import os
import json
import requests

from worker import calc_diff, generate_descriptor


REDIS_CONN = get_redis()
MATCH = 'cattle_image_id_*'


def register_handler(event, context):
    get_descriptor_from_event(event, context, REDIS_CONN, prefix='cattle_image_id_')
    return {'status': 'success'}


def register_delete_handler(event, context):
    s3_info = event['Records'][0]['s3']
    s3_bucket = s3_info['bucket']['name']
    s3_key = s3_info['object']['key']

    id_ = s3_key.split('/')[-1].split('-')[0]

    REDIS_CONN.delete('cattle_image_id_%s' % (id_))


def match_handler(event, context):
    match_image_id, match_image_descriptor, s3_client = get_descriptor_from_event(event, context, REDIS_CONN, prefix='match_image_id_')