def create(imgfile, permitted_user_ids, private):
errors = FileWrapper.is_valid_file(imgfile)
if len(errors):
return None
f_ext = path.splitext(imgfile.filename)[1]
file_id = insert_db(
'INSERT into Files (extension, private) VALUES (?, ?)', [
f_ext, bool(private)])
if not file_id:
return None
for user_id in permitted_user_ids:
status = insert_db(
'INSERT into FilePermissions (file_id, user_id) VALUES (?, ?)', [
file_id, user_id])
if not status:
return None
f_wrapper = FileWrapper(file_id, f_ext, private)
storage_path = os.path.join(app.root_path, app.config[
'UPLOAD_FOLDER'], f_wrapper.get_filename())
app.logger.debug("Saving attachment to {:s}".format(storage_path))
imgfile.save(storage_path)
return f_wrapper
async def info_state(message: types.Message, state: FSMContext):
answer = message.text
db.insert_db(message.chat.id,info=answer)
await bot.unpin_all_chat_messages(message.chat.id)
await bot.pin_chat_message(message.chat.id, message.message_id)
await state.finish()
await message.answer("Информация успешно установлена")
def download_files(msg):
file_path = os.path.join('media', msg.fileName)
with open(file_path, 'wb') as f:
f.write(msg.download())
insert_db(msg.type, msg.fileName, msg.CreateTime, msg.User.NickName)
logger.info('{}, {}, {}, {}'.format(msg.type, msg.filename, msg.CreateTime,
msg.User.NickName))
def win():
global move_count
print '\n\nYou caught the cat in ' + str(move_count) + ' moves!'
print win_text
insert_db(p.name, move_count, datetime.now())
raw_input('\nPress Enter to see a list of leaders!')
cls()
results_db()
def add_entry(lon, lat):
if not session.get('logged_in'):
about()
db.insert_db('insert into nodes (lon, lat) values (?, ?)',
[lon, lat],
True)
flash('New node added')
return redirect(url_for('build'))
def delete_buchung(Reservierungsnummer):
# Löschen
insert_db("DELETE FROM reservieren WHERE Reservierungsnummer = ?",
(Reservierungsnummer, ))
flash('Reservierung gelöscht', 'success')
return redirect(url_for('buchungen'))
def save_user(name, email, face_encoding):
user_exists_query = "SELECT * FROM Usuarios WHERE email='{}';".format(
email)
user_exists = db.query_db(user_exists_query)
# Check if face exists - could be implemented by checking the face values
if (user_exists == []):
face_encoding_str = face_encoding.dumps() #insert string to DB
insert_query = "INSERT INTO Usuarios (nombre, email, rostro) VALUES(%s, %s, _binary %s);"
data_array = (name, email, face_encoding_str)
db.insert_db(insert_query, data_array)
return ''
def process_song_file(conn, path):
# Extract
artist_data, song_data = extract_song_file(path)
# Transform
transformed_artist_data = transform_artist_data(artist_data)
transformed_song_data = transform_song_data(song_data)
# Load
insert_db(conn, 'artist', transformed_artist_data)
insert_db(conn, 'song', transformed_song_data)
def process_file(mainlog, conn, curr):
letter = []
for line in mainlog:
if line.startswith('From MAILER-DAEMON') or line.startswith('From [email protected]'):
# after tihs we get letter error
errorKey = process_letter(''.join(letter))
if not errorKey:
errorKey = 666
idGroup = find_id(''.join(letter))
if idGroup:
queueId, sendId = idGroup.groups()
# inserting to db
db.insert_db(conn, curr, queueId, sendId, errorKey)
letter = []
letter.append(line)
def extract(instr_list, output_table):
for instrument in instr_list:
xml_file = download_file(instrument, TMP_DIR)
if instrument["instrument_type"] == "Non-Equity Instruments":
df = parse_non_equity(instrument, xml_file)
else:
df = parse_equity(instrument, xml_file)
print("Writing CSV...")
csv_file = f"{HOST_STAGING_DIR}{instrument['file_name'][:-4]}.csv"
write_csv(df, csv_file)
print("COPYing to db...")
insert_db(csv_file, "raw", output_table)
clean_file(xml_file)
clean_file(csv_file)
print(f"Done {xml_file}")
def process_file(mainlog, conn, curr):
letter = []
for line in mainlog:
if line.startswith('From MAILER-DAEMON') or line.startswith(
'From [email protected]'):
# after tihs we get letter error
errorKey = process_letter(''.join(letter))
if not errorKey:
errorKey = 666
idGroup = find_id(''.join(letter))
if idGroup:
queueId, sendId = idGroup.groups()
# inserting to db
db.insert_db(conn, curr, queueId, sendId, errorKey)
letter = []
letter.append(line)
def verify_twofa(self, token):
totp = pyotp.TOTP(self.otp_secret)
totp_verify = totp.verify(token, valid_window=15)
# Already succesful
if totp_verify:
return True, False
# Try if the token is a backup codes
# Make a timing safe comparison over all elements in the list
match = False
for e in self.otp_backup_codes:
match |= safe_str_cmp(e, token)
if not match:
return False, False
# Clear the token and reserialize
self.otp_backup_codes.remove(token)
json_recovery_tokens = json.dumps(self.otp_backup_codes)
result = insert_db('UPDATE Users SET otp_backup_codes = ? WHERE id = ?', [json_recovery_tokens, self.id])
if not result:
return False, False
# We used one of the backup codes
return True, True
def insert_id_to_db(level, uid):
res = []
for i in range(50):
s = generate_id()
sql = "insert into id(id,status,level,uid) values('%s',1,%d,'%s')" % (
s, level, uid)
if insert_db(sql):
res.append(s)
return res
def register():
form = RegisterForm()
if form.validate_on_submit():
pw_hash = bcrypt.generate_password_hash(form.password.data) #Hash the inputted pw
db.insert_db('insert into users (username, password, email, name, city, role) values (?,?,?,?,?,?)',
[form.username.data,
pw_hash, #drop in the hashed password
form.email.data,
form.name.data,
form.city.data,
1],True)
flash("User: "******" has been successfully registered!")
user = db.pullUserObj(form.username.data, form.password.data)
if login_user(user,0): #Everything looks good attempt login.
return redirect('/')
else:
flash("Could Not Login After Registering. Try manually logging in.")
return redirect('/login') #Dump them back to login, maybe this'll work?
return render_template('register.html', title='Register', form=form)
def create(author_id, recipient_id, content, attachment_name=None):
if len(content) > MAX_CONTENT_LENGTH:
return None
result = insert_db(
'INSERT into Messages (author_id, recipient_id, content, filename, timestamp) VALUES (?, ?, ?, ?, ?)', [
author_id, recipient_id, content, attachment_name, int(
time.time())])
if not result:
return None
return True
def change_role(self, is_admin):
if self.is_admin == is_admin:
# Value does not change, nothing to do
return
result = insert_db('UPDATE Users SET is_admin = ? WHERE id = ?', [
int(is_admin), self.id])
if not result:
return None
self.is_admin = is_admin
return True
def update_password(self, new_password):
errors = User.verify_password_policy(new_password)
if len(errors):
return errors
salt, hashed_pw = User.create_salt_and_hashed_password(new_password)
result = insert_db('UPDATE Users SET password_salt = ?, password_token = ? WHERE id = ?', [
salt, hashed_pw, self.id])
if result is None:
return ['Could not reset password']
return []
def create(user):
token = os.urandom(32)
token = b64encode(token, '-_')
signer = URLSafeTimedSerializer(app.config['SECRET_KEY'])
signed_token = signer.dumps(token)
hashed_token = PasswordRecoveryTokens.hash_token(signed_token)
status = insert_db('INSERT into PasswordRecoveryTokens (user_id, token) VALUES (?, ?)', [user.id, hashed_token])
if status:
return signed_token
else:
return None
async def process_callback_check_pay(callback_query: types.CallbackQuery): cb_m_id = callback_query.message.chat.id if callback_query.data.endswith(str(callback_query.from_user.id)): last_tr = banking.mono_check(cb_m_id) if int(db.get_from_db(cb_m_id, "price")) <= last_tr['amount'] / 100: str_to_db = db.get_from_db(str(cb_m_id),"list_user") try: user = last_tr['comment'] + "✅" not_done = last_tr['comment'] if str_to_db == "none": db.insert_db(cb_m_id,list_user= user + "\n") elif str_to_db.find(not_done) > -1: db.insert_db(cb_m_id,list_user=str_to_db.replace(not_done,user)) await bot.send_message(cb_m_id,"Oплата прошла успешно") elif str_to_db.find(user) == -1: db.insert_db(cb_m_id,list_user=str_to_db + user + "\n") await bot.send_message(cb_m_id,"Oплата прошла успешно") else: await bot.send_message(cb_m_id,"Oплата не прошла, обратитесь к админу") except: await bot.send_message(cb_m_id,"Oплата не прошла, обратитесь к админу") else: await bot.send_message(cb_m_id,"Oплата не прошла, обратитесь к админу") data = callback_query.data.split() await bot.edit_message_reply_markup(cb_m_id, int(data[1]) + 1)
def edit_buchung(Reservierungsnummer):
# Buchung per Resnr. bekommen
buchung = query_db(
"SELECT * FROM reservieren r JOIN Aufführung_von a ON r.Datum = a.Datum AND r.Uhrzeit = a.Uhrzeit WHERE Reservierungsnummer = ?",
(Reservierungsnummer, ),
one=True)
form = ReservierungsFormular(request.form)
# Felder vorbelegen mit alten Daten
form.name.data = buchung['Name']
form.datum.data = datetime.strptime(buchung['Datum'], '%Y-%m-%d')
form.uhrzeit.data = datetime.strptime(buchung['Uhrzeit'], '%H:%M')
form.sitzplatz.data = buchung['Sitzplatz']
if request.method == 'POST' and form.validate():
name = request.form['name']
datum = request.form['datum']
uhrzeit = request.form['uhrzeit']
sitzplatz = request.form['sitzplatz']
result = query_db(
"SELECT * FROM Aufführung_von WHERE (Datum, Uhrzeit, Name) = (?,?,?) AND Datum > DATE('now') ",
(datum, uhrzeit, name))
if result:
insert_db(
"UPDATE reservieren SET Datum = ?, Uhrzeit = ?, Sitzplatz = ? WHERE Reservierungsnummer = ?",
(datum, uhrzeit, sitzplatz, Reservierungsnummer))
flash('Buchung geändert', 'success')
return redirect(url_for('buchungen'))
else:
flash('Aufführung existiert nicht! Bitte Eingaben überprüfen.')
return redirect(
url_for('edit_buchung',
Reservierungsnummer=Reservierungsnummer))
return render_template('edit_buchung.html', form=form)
def new_session(user):
app.logger.debug(
"Create new session for user {:s}".format(user.username))
session_token = os.urandom(Session.TOKEN_LENGTH)
session_token = b64encode(session_token).decode('utf-8')
signer = URLSafeTimedSerializer(app.config['SECRET_KEY'])
session_token = signer.dumps(session_token)
csrf_token = Session.create_csrf_token()
result = insert_db(
'INSERT INTO Sessions (session_token, user_id, csrf_token) Values (?, ?, ?)', [
session_token, user.id, csrf_token])
return result, session_token, csrf_token
def register():
form = RegisterForm(request.form)
if request.method == 'POST' and form.validate():
username = request.form['username']
vorname = request.form['vorname']
nachname = request.form['nachname']
soznr = request.form['soznr']
ort = request.form['ort']
adresse = request.form['adresse']
password = pbkdf2_sha256.hash(request.form['password'])
query = 'INSERT INTO users (username, password, SozNr) VALUES(?,?,?);'
query_person = 'INSERT INTO Person (SozNr, Vorname, Nachname, Ort, Adresse) VALUES(?,?,?,?,?);'
try:
insert_db(query, (username, password, soznr))
insert_db(query_person, (soznr, vorname, nachname, ort, adresse))
flash(
'Vielen Dank für die Registrierung! Sie sind nun angelegt und können sich mit Username & Passwort einloggen.',
'success')
return redirect(url_for('login'))
except:
flash('Error bei SQL Query', 'error')
return redirect(url_for('register'))
return render_template('register.html', form=form)
async def send_command(message: types.Message):
if message.text.lower().startswith('/start'):
db.insert_db(message.chat.id)
await message.answer( f'{message.from_user.first_name} , добро \
пожаловать к PartyBot!\nЕсть вопросы? Обратись к помощи /help\n')
elif message.text.lower() == "/help":
await message.answer("Этот бот поможет организовать тусовочку\n\
/setinfo - установить информацию тусовочки\n/setlocale - установить место\n\
/setdate - установить дату\n/setprice - установить цену\n/setcardinfo \
- установить автопроверку платежей (Monobank, PrivatBank)")
elif message.text.lower() == "/setinfo":
await message.answer("А теперь отправь информацию о тусовочке!")
await Test.info.set()
elif message.text.lower() == "/setlocale":
kb.inline_btn_1.callback_data = "btn1 " + str(message.message_id) + " " + str(message.from_user.id)
kb.inline_btn_2.callback_data = "btn2 " + str(message.message_id) + " " + str(message.from_user.id)
await message.answer("А теперь выбери формат адреса",reply_markup=kb.inline_kb_variant_addres)
elif message.text.lower() == "/setdate":
await message.answer("А теперь отправь дату тусовочки!\nНапример 17.03")
await Test.date.set()
elif message.text.lower() == "/setprice":
await message.answer("А теперь отправь стоимость проходки на тусовочку!")
await Test.price.set()
elif message.text.lower() == "/setcardinfo":
kb.mono.callback_data = "monokey " + str(message.message_id) + " " + str(message.from_user.id)
kb.private.callback_data = "privatekey " + str(message.message_id) + " " + str(message.from_user.id)
await message.answer("А теперь выбери свой банк!",reply_markup=kb.bank_kb)
elif message.text.lower().startswith("/delete"):
str_to_db = db.get_from_db(str(message.chat.id),"list_user")
user = message.text.split()[1]
if str_to_db.find(user) == -1:
await message.answer(user + " - нет в списке")
else:
str_to_db = str_to_db.replace(user + "\n","")
db.insert_db(message.chat.id,list_user=str_to_db)
await message.answer(user + " - удалил из списка")
def process_log_file(conn, path):
# Extract
time_data, user_data, playsong_data = extract_log_file(path)
# Transform
transformed_time_data = transform_time_data(time_data)
transformed_playsong_data = transform_playsong_data(playsong_data, conn)
# Load
insert_db(conn, 'time', transformed_time_data)
insert_db(conn, 'user', user_data)
insert_db(conn, 'songplay', transformed_playsong_data)
def create(username, email, salt, hashed_password, is_admin=False, otp_secret=None):
# usernames are case insensitive so we need to check first regardless
# of unique constraint
if User.get_user_by_name(username):
app.logger.debug("Username already exists")
return None
if User.get_user_by_email(email):
app.logger.debug("Email already exists")
return None
if not otp_secret:
otp_secret = pyotp.random_base32()
otp_recovery_tokens = []
for i in range(User.NR_RECOVERY_TOKENS):
otp_recovery_tokens.append(pyotp.random_base32())
json_recovery_tokens = json.dumps(otp_recovery_tokens)
result = insert_db(
'INSERT into Users (username, email, password_salt, password_token, is_admin, otp_secret, otp_backup_codes) VALUES (?, ?, ?, ?, ?, ?, ?)', [
username, email, salt, hashed_password, int(is_admin), otp_secret, json_recovery_tokens])
if not result:
return None
return User.get_user_by_name(username)
async def cardprivate_state(message: types.Message, state: FSMContext):
answer = message.text
db.insert_db(message.chat.id,private=answer)
await state.finish()
await message.answer("Информация успешно установлена")
async def price_state(message: types.Message, state: FSMContext):
answer = message.text
db.insert_db(message.chat.id,price=answer.lower())
await state.finish()
await message.answer("Цена успешно установлена")
async def locale_state(message: types.Message, state: FSMContext):
answer = message.text
db.insert_db(message.chat.id,locale=answer)
await state.finish()
await message.answer("Геолокация успешно установлена")
async def send_text(message: types.Message):
m_id = message.chat.id
proxyDict = {
"http" : os.environ.get('FIXIE_URL', ''),
"https" : os.environ.get('FIXIE_URL', '')}
if message.text.lower() == 'погодка':
try:
await message.answer(other.pogodka(m_id),reply_markup=delkey)
except:
await message.answer("Погодка будет доступна за 5 дней до туссовки.",reply_markup=delkey)
elif message.text.startswith('/key'):
await message.answer("Вот мои комманды: ",reply_markup=kb.markup_key)
elif message.text.lower() == 'дата':
await message.answer(db.get_from_db(str(m_id),"date"),reply_markup=delkey)
elif message.text.lower() == 'цена':
await message.answer(db.get_from_db(str(m_id),"price") + " ₴",reply_markup=delkey)
elif message.text.lower() == 'инфо':
await message.answer(db.get_from_db(str(m_id),"info"),reply_markup=delkey)
elif message.text.lower() == 'кто будет?':
await message.answer(db.get_from_db(str(m_id),"list_user"),reply_markup=delkey)
elif message.text.lower() == 'я буду':
str_to_db = db.get_from_db(str(m_id),"list_user")
user = message.from_user.username
if user is None:
user = message.from_user.full_name
if str_to_db.find(user) == -1:
if str_to_db == "none":
db.insert_db(m_id,list_user= "******" + user + "\n")
else:
db.insert_db(m_id,list_user=str_to_db + "@" + user + "\n")
await message.answer("@" + user + " - добавил тебя в список",reply_markup=delkey)
else:
await message.answer("@" + user + " - извини но ты уже в списке",reply_markup=delkey)
elif message.text.lower() == 'не буду':
str_to_db = db.get_from_db(str(m_id),"list_user")
user = message.from_user.username
if user is None:
user = message.from_user.full_name
if str_to_db.find(user) == -1:
await message.answer("@" + user + " - тебя нет в списке",reply_markup=delkey)
else:
str_to_db = str_to_db.replace("@" + user + "\n","")
db.insert_db(m_id,list_user=str_to_db)
await message.answer("@" + user + " - удалил тебя из списка",reply_markup=delkey)
elif message.text.lower() == 'геолока':
locale = db.get_from_db(str(m_id),"locale").strip()
if locale[0].isdigit():
await message.answer_location(locale.split()[0],locale.split()[1])
else:
location = geolocator.geocode(locale, language='ru')
await message.answer(location,reply_markup=delkey)
await message.answer_location(location.latitude, location.longitude)
elif message.text.lower() == 'бюджет':
try:
# p_price = privat_bank(os.getenv('API_PRIVAT2'),proxyDict, "155325","5168745302334229")
m_price = int(banking.mono_bank(m_id))
await message.answer("Бюджет тусовочки 💴 💴 💴 : " + str(m_price) + " ₴",reply_markup=delkey)
except:
await message.answer('Cервер выебываеться попробуйте позже 😔 😔 😔',reply_markup=delkey)
elif message.text.lower() == 'оплатить':
kb.mono_pay.callback_data = "mono_pay " + str(message.message_id) + " " + str(message.from_user.id)
kb.private_pay.callback_data = "private_pay " + str(message.message_id) + " " + str(message.from_user.id)
kb.nal_pay.callback_data = "nal_pay " + str(message.message_id) + " " + str(message.from_user.id)
await message.answer("Выберите способ оплаты :",reply_markup=kb.payment_kb)
def insert(self, cardid, studentname, studentid, studentaccount):
params = [cardid, studentname, studentid, studentaccount]
ret = db.insert_db(params)
return ret
def clear():
return insert_db('DELETE FROM PasswordRecoveryTokens')
def delete_token(token):
return insert_db('DELETE FROM PasswordRecoveryTokens where token = ?', [token])
if latest_datetime[0]:
latest_date_formatted = latest_datetime[0].strftime('%Y-%m-%dT%H:%M:%SZ')
url = base_stream_url + '?since={date}'.format(
date=latest_date_formatted)
else:
url = base_stream_url
if len(sys.argv) > 1 and sys.argv[1] == 'nohistorical':
url = base_stream_url
for event in EventSource(url):
if event.event == 'message':
try:
change = json.loads(event.data)
except ValueError:
continue
hashtag_matches = hashtag_match(change['comment'])
if hashtag_matches and valid_edit(change):
for hashtag in hashtag_matches:
if db.is_duplicate(hashtag, change['id']):
print("Skipped duplicate {hashtag} ({id})".format(
hashtag=hashtag, id=change['id']))
elif valid_hashtag(hashtag):
# Check edit_summary length, truncate if necessary
if len(change['comment']) > 800:
change['comment'] = change['comment'][:799]
db.insert_db(hashtag, change)
