示例#1
0
def create_relation(user_1_id, user_2_id, relation_type):
    remove_relation(user_1_id, user_2_id)
    remove_relation(user_2_id, user_1_id)
    timestamp = int(time.time() * 1000)
    cursor.execute("insert into social values (?, ?, ?, ?)",
                   [user_1_id, user_2_id, relation_type, timestamp])
    connection.commit()
示例#2
0
def modify_tokens(user_id, formatted_token, remove):
    temp_tokens = valid_tokens(user_id)
    temp_tokens.remove(formatted_token) if remove else temp_tokens.append(
        formatted_token)
    cursor.execute("update users set valid_tokens = ? where user_id = ?",
                   [json.dumps(temp_tokens), user_id])
    connection.commit()
示例#3
0
def getTracks():
    cursor.execute(
        """SELECT Faixas.id,Faixas.id_faixa_album,Faixas.nome,Faixas.descricao,Faixas.tipo_gravacao,Faixas.album,Faixas.tipo_composicao,Faixas.duracao,Compositor.nome,Interprete.nome,Composicao.nome
    From Faixas, FaixasCompositorAux,Compositor, FaixasInterpreteAux,
    Interprete,Composicao
    WHERE Faixas.id = FaixasCompositorAux.id_faixa 
    AND FaixasCompositorAux.id_compositor = Compositor.id
    AND  FaixasInterpreteAux.id_faixa = Faixas.id 
    AND FaixasInterpreteAux.id_interprete = Interprete.id 
    AND Faixas.tipo_composicao = Composicao.id
    GROUP BY Faixas.id,Faixas.id_faixa_album,Faixas.nome,Faixas.descricao,Faixas.tipo_gravacao,Faixas.album,Faixas.tipo_composicao,Faixas.duracao,Compositor.nome,Interprete.nome,Composicao.nome
    ORDER BY Faixas.id""")
    faixas = []
    for row in cursor.fetchall():
        faixas.append({
            'id': row[0],
            'id_faixa_album': row[1],
            'nome': row[2],
            'descricao': row[3],
            'tipo_gravacao': row[4],
            'album': row[5],
            'tipo_composicao': row[6],
            'duracao': (str(row[7])),
            'nome_compositor': row[8],
            'nome_interprete': row[9],
            'nome_composicao': row[10]
        })
    return jsonify(faixas)
示例#4
0
def store_commit(repos_id, commit, filename, author_name, author_email,
                 author_date, committer_name, committer_email, committer_date,
                 added, removed, whitespace):

    # Fix some common issues in git commit logs and store data

    # Sometimes git is misconfigured and name/email get swapped
    author_name, author_email = check_swapped_emails(author_name, author_email)
    committer_name, committer_email = check_swapped_emails(
        committer_name, committer_email)

    # Some systems append extra info after a second @
    author_email = strip_extra_amp(author_email)
    committer_email = strip_extra_amp(committer_email)
    store = (
        "INSERT INTO analysis_data (repos_id,commit,filename,"
        "author_name,author_raw_email,author_email,author_date,"
        "committer_name,committer_raw_email,committer_email,committer_date,"
        "added,removed,whitespace) "
        "VALUES (%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s)")

    cursor.execute(store,
                   (repos_id, commit, filename, author_name, author_email,
                    discover_alias(author_email), author_date, committer_name,
                    committer_email, discover_alias(committer_email),
                    committer_date, added, removed, whitespace))
    db.commit()

    log_activity('Debug', 'Stored commit: %s' % commit)
示例#5
0
def update_status(status):

    # Update the status displayed in the UI

    query = ("UPDATE settings SET value=%s WHERE setting='utility_status'")
    cursor.execute(query, (status, ))
    db.commit()
示例#6
0
def shop_menu(callback):
    message = callback.message
    if not USER_BASKET_DATA.get(callback.from_user.id):
        USER_BASKET_DATA[callback.from_user.id] = {}
    if [int(callback.data)
        ] in cursor.execute('select shop_id from menu').fetchall():
        shop_name_description = \
            cursor.execute(f"select name, description from shops where id={callback.data}").fetchall()[0]
        bot.send_message(
            message.chat.id,
            f'Ресторан "{shop_name_description[0]}"\n{shop_name_description[1]}'
        )
        dishes = cursor.execute(f"select description, name, photo, cost from menu where shop_id = '{callback.data}'")\
            .fetchall()
        names = [i[1] for i in dishes]
        SHOP_MENU_DATA[callback.from_user.id] = {
            dish[1]: dish
            for dish in dishes
        }
        bot.send_message(message.chat.id,
                         'Доступные блюда:',
                         reply_markup=create_menu_keyboard(
                             names, callback.data))
    else:
        bot.send_message(message.chat.id,
                         'Кажется этот ресторан еще не настроил свое меню')
示例#7
0
def get_chats_list():
    if not request.json or 'user' not in request.json or not request.json[
            'user'].isdigit():
        abort(400)
    chats_id = cursor.execute(
        f"select chat_id from user_chat where user_id={request.json['user']}"
    ).fetchall()
    last_messages = []
    for chat_id in chats_id:
        if cursor.execute(
                f"select created_at from message where chat={chat_id[0]}"
        ).fetchall():
            last_messages.append([
                chat_id[0],
                sorted([
                    i[0] for i in cursor.execute(
                        f"select created_at from message where chat={chat_id[0]}"
                    ).fetchall()
                ])[-1]
            ])
    result = sorted([
        cursor.execute(f"select * from chat where id={i[0]}").fetchall()[0]
        for i in last_messages
    ],
                    key=lambda x: x[1],
                    reverse=True)
    return jsonify({'chats': result})
示例#8
0
def getFaixaCompositores():
    cursor.execute("SELECT * from FaixasCompositorAux")
    faixacompositores = []
    for row in cursor.fetchall():
        faixacompositores.append({'id_compositor':row[0],
                                'id_faixa': row[1]})
    return jsonify(faixacompositores)
示例#9
0
    def post(self):
        data = UserRegistration.parser.parse_args()
        data['pwd'] = User.generate_hash(data['pwd'])
        create_users_table()
        insert_query = """INSERT INTO users (username, pwd, firstname, 
                                    lastname, othernames, email, registered, isAdmin) 
                                    VALUES (%s, %s, %s, %s, %s, %s, %s, %s);"""
        record_to_insert = list(data.values())

        try:
            cursor.execute(insert_query, record_to_insert)
            connection.commit()
            access_token = create_access_token(identity=data['username'])
            return {
                       'status': 201,
                       'data': [{
                           'token': access_token,
                           'user': data['username']
                       }]
                   }, 201
        # TODO: HANDLE ERROR BETTER -- 409 IF CONFLICT, 500 IF OTHER
        except (Exception, psycopg2.Error) as error:
            connection.rollback()
            return {
                       'status': 500,
                       'message': json.dumps(error, default=str)
                   }, 500
示例#10
0
def git_repo_updates():

    # Update existing repos

    update_status('Updating repos')
    log_activity('Info', 'Updating existing repos')

    repo_base_directory = get_setting('repo_directory')

    query = ("SELECT id,projects_id,git,name,path FROM repos WHERE "
             "status='Active'")
    cursor.execute(query)

    existing_repos = list(cursor)

    for row in existing_repos:

        log_activity('Verbose', 'Attempting to update %s' % row['git'])
        update_repo_log(row['id'], 'Updating')

        cmd = ("git -C %s%s/%s%s pull" %
               (repo_base_directory, row['projects_id'], row['path'],
                row['name']))

        return_code = subprocess.Popen([cmd], shell=True).wait()

        if return_code == 0:
            update_repo_log(row['id'], 'Up-to-date')
            log_activity('Verbose', 'Updated %s' % row["git"])
        else:
            update_repo_log(row['id'], 'Failed (%s)' % return_code)
            log_activity('Error', 'Could not update %s' % row["git"])

    log_activity('Info', 'Updating existing repos (complete)')
示例#11
0
    def move(self, user_id, column):
        if len(self.board.win_positions) > 0: return
        if self.board.board_full: return

        move = self.player_1_id if self.board.player_1 else self.player_2_id
        if user_id != move: return

        self.board.drop_fisje(column)

        io.emit("fieldUpdate", {"field": self.board.board}, room=self.room)

        now = int(time.time() * 1000)
        cursor.execute(
            "update games set last_activity = ?, moves = moves || ? || ',' where game_id = ?",
            [now, column, self.game_id])
        connection.commit()

        if len(self.board.win_positions) > 0 or self.board.board_full:
            outcome = "d"
            if not self.board.board_full:
                winner = self.board.board[int(self.board.win_positions[0][0])]
                outcome = "w" if winner == "2" else "l"
            io.emit("finish", {
                "winPositions": self.board.win_positions,
                "boardFull": self.board.board_full
            },
                    room=self.room)
            self.close("finished", outcome)
            return

        io.emit("turnUpdate", {"player1": self.board.player_1}, room=self.room)
示例#12
0
def get_recommendation():
    if request.method == "POST":
        RATINGS_PATH = '/srv/movielens/ratings_matrix.npz'
        RATINGS_MATRIX = ratings_matrix.ratings_matrix(RATINGS_PATH)
        user_id = request.json["user_id"]
        sql_query = "SELECT DISTINCT movie_id FROM user_favorite WHERE user_id = %s"
        cursor.execute(sql_query, tuple([user_id]))
        movie_ids = cursor.fetchall()
        movie_list = []
        if len(movie_ids) == 0:
            result = {"recommended_movies": movie_list}
            return jsonify(result)

        liked = {}
        for movie_id in movie_ids:
            movie_id = movie_id[0]
            liked[movie_id] = 50
        print(liked)
        recommendations = get_matches(RATINGS_MATRIX, liked,
                                      NUM_RECOMMENDATIONS)
        print(recommendations)
        sql_query = "SELECT * FROM movie WHERE id = %s"
        for index in range(NUM_RECOMMENDATIONS):
            movie_id = recommendations[index][1]
            movie_id = RATINGS_MATRIX.imdb_id(movie_id)
            cursor.execute(sql_query, tuple([int(movie_id)]))
            movie_row = cursor.fetchone()
            movie = get_movie_details(movie_row)
            movie_list.append(movie)
        result = {"recommended_movies": movie_list}
        print(movie_list)
        return jsonify(result)
示例#13
0
def index():
    data = request.get_json()

    # get form data
    email = data.get("email") or ""
    password = data.get("password") or ""

    # return malformed request if email or password is missing
    if not email or not password:
        return "", 400

    # resolve user_id from username or email
    user_id = None
    user_id = user_id or cursor.execute(
        "select user_id from users where email = ?", [email]).fetchone()
    user_id = user_id or cursor.execute(
        "select user_id from users where lower(username) = lower(?)",
        [email]).fetchone()
    if user_id == None: return "", 401

    # check the password
    valid_password = login_password(user_id[0], password)
    if not valid_password: return "", 401

    # generate a new authentication token and add it to the users valid token list
    new_token = token.generate_token()
    token.add_token(user_id[0], token.hash_token(new_token))

    # make response with the set_cookie header
    res = make_response("", 200)
    res.set_cookie("token",
                   new_token["token"],
                   expires=int(new_token["expirationDate"] / 1000))

    return res
示例#14
0
def get_movie_details(row):
    id = row[0]
    sql_query = "SELECT person.name FROM person, person_junction " +\
                "WHERE person.id = person_junction.person_id" +\
                " AND person_junction.role = 'cast'" +\
                " AND person_junction.movie_id = %s"
    cursor.execute(sql_query, tuple([id]))
    casts = cursor.fetchmany(size=4)
    actors = []
    for cast in casts:
        actors.append(cast[0])
    sql_query = "SELECT rating FROM ratings WHERE movie_id = %s"
    cursor.execute(sql_query, tuple([id]))
    rating = cursor.fetchone()[0]
    movie = {
        "id": row[0],
        "title": row[1],
        "year": row[2],
        "url": row[3],
        "plot": row[5][:200] + " ...",
        "genre": row[6],
        "language": row[7],
        "casts": actors,
        "rating": rating
    }
    return movie
示例#15
0
def index():
    cursor.execute('select name from Sequences;')

    response = Response()
    response.set_data(f'Welcome to the Integer Sequence Database.\r\n</br>Sequences: {str([*cursor])[1:-1]}')

    return response
示例#16
0
def collection():
    sql = "select * from tbl_sp where id_sp = 33"
    cursor.execute(sql)
    record1 = cursor.fetchall()
    sql = "select * from tbl_sp where id_sp = 34"
    cursor.execute(sql)
    record2 = cursor.fetchall()
    return render_template("collection.html", r1=record1, r2=record2)
示例#17
0
def get_setting(setting):

    # Get a setting from the database

    query = ("SELECT value FROM settings WHERE setting=%s ORDER BY "
             "last_modified DESC LIMIT 1")
    cursor.execute(query, (setting, ))
    return cursor.fetchone()["value"]
示例#18
0
def get_setting(setting):

# Get a setting from the database

	query = ("SELECT value FROM settings WHERE setting='%s' ORDER BY "
		"last_modified DESC LIMIT 1" % setting)
	cursor.execute(query)
	return cursor.fetchone()["value"]
示例#19
0
def cleanup():
    now = int(time.time() * 1000)
    old_games = cursor.execute(
        "select game_id from games where (status = \"wait_for_opponent\" or status = \"in_progress\") and last_activity < ?",
        [now - 5 * 60 * 1e3]).fetchall()
    for game_id in old_games:
        cursor.execute("delete from games where game_id = ?", [game_id[0]])
    connection.commit()
示例#20
0
def getInterpretes():
    cursor.execute("SELECT * from Interprete")
    interpretes = []
    for row in cursor.fetchall():
        interpretes.append({'id':row[0],
                            'nome': row[1], 
                            'tipo':row[2]})
    return jsonify(interpretes)
示例#21
0
def viewSeq():

    name = request.args.get("name") # get query string
    response = Response()
    cursor.execute(f'select seq from Sequences where name=\'{name}\';')
    response.set_data(str([str(i) for i in cursor])) # write to response

    return response
示例#22
0
def add_favorite():
    if request.method == "POST":
        user_id = request.json["user_id"]
        movie_id = request.json["movie_id"]
        sql_query = "INSERT INTO user_favorite(user_id, movie_id) VALUES(%s, %s)"
        cursor.execute(sql_query, tuple([user_id, movie_id]))
        database.commit()
        return "SUCCESS"
    return "FAILED"
def added_user():
    us = request.form.get("us")
    pa = request.form.get("pa")
    pq = request.form.get("pq")

    sql = f"insert into tbl_user(user_name, pass_word, phan_quyen) values(N'{us}', N'{pa}', {pq})"
    cursor.execute(sql)
    connection.commit()
    return redirect("/user")
示例#24
0
def update_repo_log(repos_id, status):

    # Log a repo's fetch status

    log_message = ("INSERT INTO repos_fetch_log (repos_id,status) "
                   "VALUES (%s,%s)")

    cursor.execute(log_message, (repos_id, status))
    db.commit()
示例#25
0
def update_analysis_log(repos_id, status):

    # Log a repo's analysis status

    log_message = ("INSERT INTO analysis_log (repos_id,status) "
                   "VALUES (%s,%s)")

    cursor.execute(log_message, (repos_id, status))
    db.commit()
示例#26
0
def rename_shop_final(message):
    new_name = message.text
    old_name = cursor.execute(
        f"select name from shops where user_id = '{message.from_user.id}'"
    ).fetchall()[0][0]
    cursor.execute(
        f"update shops set name = '{new_name}' where name = '{old_name}'")
    update_state(RENAME_STATE, message, RENAME_CLOSE)
    connection.commit()
    bot.send_message(message.chat.id, 'Имя успешно изменено')
示例#27
0
def start_command(message):
    clear_all_state(message)
    bot.send_message(
        message.chat.id,
        'Привет, ты на универсальной платформе по доставке еды.\n'
        'Достпуный список команд - /help')
    user_id = str(message.from_user.id)
    if [user_id] not in cursor.execute('select user_id from users').fetchall():
        cursor.execute(f"insert into users (user_id) values ('{user_id}')")
        connection.commit()
示例#28
0
def product():
    if "username" in session:
        id_sp = request.args.get("id_sp", type=int)
        sql = "select * from tbl_sp"
        cursor.execute(sql)
        record = cursor.fetchall()
        print(record)
        return render_template("ad_product.html", r=record, id_sp=id_sp)
    else:
        return redirect("/login")
示例#29
0
def createPlaylist():
    data = request.form.to_dict()
    if not (data and data['nome'] and data['descricao']):
        return "Json vazio", 400

    playlist = {'nome': data['nome'], 'descricao': data['descricao']}
    query = "INSERT INTO Playlist (nome, descricao, data_criacao) VALUES (?, ?, SYSDATETIME())"
    cursor.execute(query, playlist['nome'], playlist['descricao'])
    cnxn.commit()
    return playlist, 201
示例#30
0
def route(user_1_id, user_2_id):
    cursor.execute(
        "update social set type = \"friendship\" where user_1_id = ? and user_2_id = ?",
        [user_2_id, user_1_id])
    connection.commit()

    io.emit("changedRelation", {"id": user_2_id}, room="user-" + user_1_id)
    io.emit("changedRelation", {"id": user_1_id}, room="user-" + user_2_id)

    return "", 200
示例#31
0
def store_working_commit(repo_id, commit):

    # Store the working commit.

    store_commit = ("UPDATE repos " "SET working_commit = %s " "WHERE id = %s")

    cursor.execute(store_commit, (commit, repo_id))
    db.commit()

    log_activity('Debug', 'Stored working commit: %s' % commit)
示例#32
0
import config
from db import cursor
from markovify import markovify

userlist = {}
for row in cursor.execute('SELECT usercode, username FROM user'):
    userlist[row[0]] = row[1]
markov_chains = {}
print(userlist)


class Markov(object):
    def __init__(self, usercode):
        messages = [row[0] for row in cursor.execute('SELECT body FROM message WHERE usercode=?', (usercode,))]
        self.text_model = markovify.Text('. '.join(messages))

    def generate_markov_text(self):
        output = ''
        for r in range(config.markov_sentences):
            attempts = 0
            sentence = ' '.join(self.text_model.chain.walk(None))
            while attempts < 100 and len(sentence.split()) < config.markov_sentence_length:
                sentence = ' '.join(self.text_model.chain.walk(None))
                attempts += 1

            sentence = sentence.replace('.', '').strip()
            output += sentence + '. '

        return output[:-1]

示例#33
0
filename = 'facade_summary-projects_by_LoC_and_number_contributors_by_year.xlsx'

#--> Set the description of the data

detail = 'LoC added (Unique emails)'

#--> Change this to modify the names of each worksheet

sheets = reversed(list(range(int(get_setting('start_date')[:4]),
	datetime.datetime.now().year + 1)))

#--> Change this to modify the x axis

get_x_axis = "SELECT name,id FROM projects"

cursor.execute(get_x_axis)
x_axis = list(cursor)

facade_dir = dirname(dirname(dirname(filepath)))
outfile = os.path.join(facade_dir,'files',filename)

workbook = xlsxwriter.Workbook(outfile)

bold = workbook.add_format({'bold': True})
italic = workbook.add_format({'italic': True})
bold_italic = workbook.add_format({'bold': True, 'italic': True})
numformat = workbook.add_format({'num_format': '#,##0'})

for sheet in sheets:

	worksheet = workbook.add_worksheet(str(sheet))
示例#34
0
 def __init__(self, usercode):
     messages = [row[0] for row in cursor.execute('SELECT body FROM message WHERE usercode=?', (usercode,))]
     self.text_model = markovify.Text('. '.join(messages))
示例#35
0
checker = enchant.Dict('en_US')
DEBUG = False
base_directory = raw_input('Dir name: ')
# Import users first
for root, subdirs, filenames in os.walk(base_directory):
    for filename in filenames:
        if filename in ('channels.json', 'integration_logs.json', '.DS_Store'):
            continue
        with open(os.path.join(root, filename)) as f:
            data = json.loads(f.read())
            if filename == 'users.json':
                for user in data:
                    try:
                        print('Loading ' + user['name'])
                        if not DEBUG: cursor.execute('INSERT INTO user VALUES(?, ?, ?, ?)', (user['id'], user['name'], permissions.USER, config.starting_beers))
                        conn.commit()
                    except Exception as e:
                        print(e)
            else:
                for message in data:
                    try:
                        if not message.get('subtype'): # assume anything without a subtype is a regular message
                            text = message['text']
                            # Ignore messages that are ! commands
                            if text.startswith('!'):
                                continue

                            for emoji in re.findall(r'(:[a-z0-9_]+:)', text):
                                if not DEBUG: cursor.execute('INSERT INTO emoji VALUES (?)', (emoji,))