def friend_request():
db_manager = DatabaseManager()
username = request.json.get('username')
friendname = request.json.get('friendname')
if username == None or friendname == None:
abort(400)
if db_manager.username_exists(username) and db_manager.username_exists(
friendname):
if not db_manager.users_are_friends(username, friendname):
email = db_manager.get_user(friendname).get("email")
# Email request
token = generate_confirmation_token([username, friendname])
confirm_url = url_for('accept_friend', token=token, _external=True)
html = render_template('friend.html',
confirm_url=confirm_url,
name=username)
subject = "New friend request"
send_email(email, subject, html)
return "Email sent"
else:
return "ERROR, already friends"
def backuper():
"""
Backs up each item in backup list.
"""
# start logging
logging.info('Starting backups')
# bring in the backups
db = DatabaseManager(BACKUP_FILE_PATH)
logging.debug('Database loaded')
sql = 'SELECT * FROM backups'
backup_list = db.select(sql, None)
# backup schema:
# [0]coordinate, [1]name, [2]owner, [3]active, [4]backup_times
for entry in backup_list:
# Is this planet being actively backed up?
if not entry[3]:
# nope, skip it
continue
# perform the backup action
perform_backup(db, entry)
# update log to reflect new backup
prune_backups(db, entry)
logging.info('Backups completed.')
logging.info('=====================================================.')
def callback():
code = request.args.get('code')
url = 'https://accounts.spotify.com/api/token'
resp = requests.post(url=url,
data={
'grant_type': 'authorization_code',
'code': code,
'redirect_uri': SPOTIFY_REDIRECT_URI,
'client_id': SPOTIFY_CLIENT_ID,
'client_secret': SPOTIFY_CLIENT_SECRET
})
if resp.status_code != 200:
print resp.json()
else:
token = resp.json()
access_token = '%s %s' % (token['token_type'], token['access_token'])
refresh_token = token['refresh_token']
resp = requests.get(url='https://api.spotify.com/v1/me',
headers={'Authorization': access_token})
if resp.status_code == 200:
user_data = resp.json()
manager = DatabaseManager(DATABASE)
manager.create_user(session['telegram_user'],
session['telegram_first_name'],
user_data['id'], access_token, refresh_token)
return redirect('/')
def get_friends():
db_manager = DatabaseManager()
username = request.json.get('username').lower()
token = request.json.get('token')
if username == None or token == None:
abort(400)
# Verifiy token
token_credentials = db_manager.verify_auth_token(token=token)
if token_credentials is None:
abort(401)
elif not db_manager.check_password(token_credentials[0],
token_credentials[1]):
abort(401)
elif token_credentials[0] != username:
abort(401)
friends = db_manager.get_friends_for_user(username)
# It is unsafe to send your friends password hash to the browser... email_verified and id aren't needed
for friend in friends:
if friend == None:
friends.remove(friend)
continue
del friend['password_hash']
del friend['email_verified']
del friend['id']
return response_cache_header(json.dumps({"friends": friends}))
def change_password():
db_manager = DatabaseManager()
username = request.json.get('username')
old_password = sha512_crypt.encrypt(
request.json.get('old_password'),
salt=app.config['SECURITY_PASSWORD_SALT'],
rounds=5000)
new_password = sha512_crypt.encrypt(
request.json.get('new_password'),
salt=app.config['SECURITY_PASSWORD_SALT'],
rounds=5000)
token = request.json.get('token')
# Not everything filled in
if username == None or old_password == None or new_password == None or token == None:
abort(400)
# Verifiy token
token_credentials = db_manager.verify_auth_token(token=token)
if token_credentials is None:
abort(401)
elif not db_manager.check_password(token_credentials[0],
token_credentials[1]):
abort(401)
elif token_credentials[0] != username:
abort(401)
if db_manager.check_password(username, old_password):
db_manager.change_password(username, old_password, new_password)
return response_cache_header("Changed password",
cache_control="no-cache")
else:
return response_cache_header("ERROR, Wrong password",
cache_control="no-cache")
def initEnv():
""" Code to be executed when called by test function """
fileConfigApp = 'CalcAl.ini'
configApp = configparser.RawConfigParser()
configApp.read(fileConfigApp, encoding="utf-8")
CalcAl.setLocaleCalcal(configApp, '.')
# Create and open test database
baseDirPath = os.path.join(configApp.get('Resources', 'ResourcesDir'),
configApp.get('Resources', 'DatabaseDir'))
baseTestDirPath = os.path.join(baseDirPath, "test")
if not os.path.exists(baseTestDirPath):
os.mkdir(baseTestDirPath)
demoDatabaseName = configApp.get('Resources', 'DemoDatabaseName')
shutil.copyfile(os.path.join(baseDirPath, demoDatabaseName),
os.path.join(baseTestDirPath, demoDatabaseName))
databaseManager = DatabaseManager.DatabaseManager(configApp, '.',
baseTestDirPath)
databaseManager.openDatabase(demoDatabaseName)
# Init user table in test database
database = databaseManager.getDatabase()
database.createUserTables()
# Values returned to each test calling function
return configApp, databaseManager
def __init__(self) -> None:
self.root = Tk()
self.root.geometry("300x370+0+0")
# self.root.resizable(True, True)
self.root.eval("tk::PlaceWindow . center")
self.root.title("Чеботарёв Степан ПКС-405")
self.root.iconphoto(False, PhotoImage(file=config_get("icon_path")))
self.Frame = None
self.database_manager = DatabaseManager()
# ? Fonts
self.font_color = "#37474F"
self.font_color_complementary = "#78909C"
self.font_color_accent = "#FF9C1A"
self.font_captcha = ("Curlz MT", 24)
self.font_20 = (
"Arial",
20,
)
self.font_24 = (
"Arial",
24,
)
self.font_28 = (
"Arial",
28,
)
def main():
parser = ArgumentParser()
parser.add_argument("--db-uri", required=True)
parser.add_argument("--serializer", default="CsvRawSerializer")
args = parser.parse_args()
logger.info("init")
db = DatabaseManager(args.db_uri)
store = YaDiskStore(token=db.get_tokens().yandex_disk)
for controller in db.get_controllers():
c = Controller(name=controller.name, mac=controller.mac)
store.prepare_for_sync_controller(c)
for sensor in db.get_sensors(controller):
first_date = db.get_first_sensor_data_date(sensor.id)
s = Sensor(name=sensor.name, id=sensor.id, controller=c)
store.prepare_for_sync_sensor(s)
store.sync(
sensor=s,
serializer=getattr(serializers, args.serializer)(),
stream_wrapper=AesStreamWrapper(key=db.get_encryption_key()),
first_date=first_date,
get_data=lambda time_range: db.get_sensor_data(
sensor.id, time_range),
)
logger.info("done")
def authenticate():
db_manager = DatabaseManager()
username = request.json.get('username')
password = sha512_crypt.encrypt(request.json.get('password'),
salt=app.config['SECURITY_PASSWORD_SALT'],
rounds=5000)
if username and password:
if db_manager.get_user(username):
if db_manager.get_user(username).get('email_verified'):
# Check password
if db_manager.check_password(username, password):
return json.dumps({
"token":
db_manager.generate_auth_token(
username, password).decode("utf-8")
})
else:
return "ERROR, Email not verified"
else:
return "ERROR, User not found"
else:
return Response('Login!', 401,
{'WWW-Authenticate': 'Basic realm="Login!"'})
def database_manager() -> DatabaseManager:
filename = "helpdesk.db"
dbm = DatabaseManager(filename)
yield dbm
dbm.__del__() # explicitly release the database manager
os.remove(filename)
def get_friends():
db_manager = DatabaseManager()
username = request.json.get('username')
token = request.json.get('token')
if username == None or token == None:
abort(400)
# Verifiy token
token_credentials = db_manager.verify_auth_token(token=token)
if token_credentials is None:
return json.dumps({'username': '******'})
elif not db_manager.check_password(token_credentials[0],
token_credentials[1]):
return json.dumps({'username': '******'})
elif token_credentials[0] != username:
abort(401)
friends = db_manager.get_friends_for_user(username)
# It is unsafe to send your friends password hash to the browser... email_verified and id aren't needed
for friend in friends:
del friend['password_hash']
del friend['email_verified']
del friend['id']
return json.dumps(friends)
def register():
db_manager = DatabaseManager()
username = request.json.get('username')
password = sha512_crypt.encrypt(request.json.get('password'),
salt=app.config['SECURITY_PASSWORD_SALT'],
rounds=5000)
email = request.json.get('email')
# Check if everything filled in
if username is None or password is None or email is None:
return "ERROR, not everything filled in" # missing arguments
# Check if already exists
elif db_manager.username_exists(username) or db_manager.email_exists(
email):
return "ERROR, username and/or email do already exist" # username and/or email do already exist
else:
db_manager.create_user(username=username,
password_hash=password,
email=email,
email_verified=False)
# Email verification
token = generate_confirmation_token(email)
confirm_url = url_for('verify_email', token=token, _external=True)
html = render_template('email.html', confirm_url=confirm_url)
subject = "Please confirm your email"
send_email(email, subject, html)
return "Successfully created user, please verify email.\n"
def __init__(self):
self.databaseManager = DatabaseManager()
self.communicationManager = CommunicationManager()
self.file_type = self.databaseManager.get_file_type()
self.seed_path = self.databaseManager.get_seed_path()
self.seed_file = self.databaseManager.get_seed_file()
self.mutate_path = self.databaseManager.get_mutate_path()
self.crash_path = self.databaseManager.get_crash_path()
self.target_path = self.databaseManager.get_target_path()
self.work_summary = None
self.loop = self.databaseManager.get_loop()
self.test_number = self.databaseManager.get_test_number()
self.mutate_mode = self.databaseManager.get_mutate_mode() # windows binary or docker container
self.stop = False
self.pid = None
self.debug = None
self.event = None
self.debug_time = 0
self.system_bit = self.databaseManager.get_system_bit()
require_directorys = [self.seed_path, self.mutate_path, self.crash_path]
for directory in require_directorys:
if not os.path.exists(directory):
os.makedirs(directory)
def __init__(self):
super().__init__(command_prefix=custom_prefix,
owner_id=int(environ['OWNER_ID']),
case_insensitive=True,
help_command=None,
max_messages=None,
fetch_offline_members=platform.machine() != 'armv7l',
activity=Game(f'Loading...'))
self.db = DatabaseManager(name=environ['DATABASE_NAME'],
uri=environ['DATABASE_URI'],
bot=self)
self.i18n = i18n.I18N(source='pt_BR')
self.log = log
self.emoji = emojis
self.color = DEFAULT_EMBED_COLORS
self.loaded = False
self.launched_shards = []
self.started_at = datetime.utcnow()
self.wavelink = wavelink.Client(self)
self.guild_blacklist = set()
self.user_blacklist = set()
self.invoked_commands = 0
self.read_messages = 0
self.played_tracks = 0
self.prefixes = environ['PREFIXES'].split(', ')
self._prefixes = {}
self._message_logs = set()
def remember():
db_manager = DatabaseManager()
selector = request.json.get('selector')
if selector:
data = db_manager.get_auth_id(selector)
if data:
token = json.loads(data)['token']
return response_cache_header(json.dumps({
"token": token,
"success": True
}),
cache_control="no-cache")
else:
return response_cache_header(json.dumps({
"error": "no session",
"success": False
}),
cache_control="no-cache")
else:
return response_cache_header(json.dumps({
"error": "no session",
"success": False
}),
cache_control="no-cache")
def delete_list():
db_manager = DatabaseManager()
username = request.json.get('username')
listname = request.json.get('listname')
token = request.json.get('token')
if username == None or listname == None or token == None:
abort(400)
# Verifiy token
token_credentials = db_manager.verify_auth_token(token=token)
if token_credentials is None:
return json.dumps({'username': '******'})
elif not db_manager.check_password(token_credentials[0],
token_credentials[1]):
return json.dumps({'username': '******'})
elif token_credentials[0] != username:
abort(401)
if not db_manager.listname_exists_for_user(username, listname):
return "No list found"
if db_manager.listname_exists_for_user(username, listname):
db_manager.delete_list(username, listname)
return "Successfully deleted list"
return abort(401)
def delete_list():
db_manager = DatabaseManager()
username = request.json.get('username').lower()
listname = request.json.get('listname')
token = request.json.get('token')
if username == None or listname == None or token == None:
abort(400)
# Verifiy token
token_credentials = db_manager.verify_auth_token(token=token)
if token_credentials is None:
abort(401)
elif not db_manager.check_password(token_credentials[0],
token_credentials[1]):
abort(401)
elif token_credentials[0] != username:
abort(401)
if not db_manager.listname_exists_for_user(username, listname):
return response_cache_header("No list found", cache_control="no-cache")
if db_manager.listname_exists_for_user(username, listname):
db_manager.delete_list(username, listname)
return response_cache_header(json.dumps(
{'response': 'Successfully deleted list'}),
cache_control="no-cache")
return abort(401)
def friend_request():
db_manager = DatabaseManager()
username = request.json.get('username')
friendname = request.json.get('friendname')
if username == None or friendname == None:
abort(400)
if db_manager.username_exists(username) and db_manager.username_exists(
friendname):
if not db_manager.users_are_friends(username, friendname):
email = db_manager.get_user(friendname).get("email")
# Email request
token = generate_confirmation_token([username, friendname])
confirm_url = 'https://api.woording.com/acceptFriend/' + token
html = render_template('friend.html',
confirm_url=confirm_url,
name=username)
subject = "New friend request"
send_email(email, subject, html)
return response_cache_header("Email sent",
cache_control="no-cache")
else:
return response_cache_header("ERROR, already friends",
cache_control="no-cache")
def __init__(self, app):
QDialog.__init__(self)
self.app = app
self.app_path = os.getenv("APPDATA") + "\\" + qApp.applicationName()
self.registrySettings = QSettings("HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Run", QSettings.NativeFormat)
self.table_path = self.app_path + "\\tables"
self.engine = Engine()
self.minimize_action = QAction("Minimize", self)
self.maximize_action = QAction("Maximize", self)
self.settings_action = QAction("Settings", self)
self.about_action = QAction("About", self)
self.quit_action = QAction("Quit", self)
self.tray_icon_menu = QMenu(self)
self.tray_icon = QSystemTrayIcon(self)
self.setupUi(self)
self.icon = QIcon(QPixmap(":icon/off_logo"))
self.construct_tray_icon()
self.signal_connectors()
self.database = DatabaseManager()
self.shortcut_key = self.database.get_shortcut_key()
self.populate_modifier_cbox()
if self.database.get_current_state() == "True":
self.engine.conv_state = False
else:
self.engine.conv_state = True
self.icon_activated(QSystemTrayIcon.Trigger)
self.file_path_tview.setEnabled(False)
self.check_app_path()
self.update_table(True)
self.init_combobox()
if self.registrySettings.contains(qApp.applicationName()):
self.start_windows_check.setChecked(True)
else:
self.start_windows_check.setChecked(False)
def classify(song_id, activity):
manager = DatabaseManager(DATABASE)
return jsonify({
'code': 1,
'updated': manager.classify_song(song_id, activity)
})
def random_course(request):
if not request.is_ajax():
print 'not ajax'
return
db = DatabaseManager()
course = db.generate_random_course()
jsonified = json.dumps(course, default=decimal_default)
return HttpResponse(jsonified)
def test_dbm_fx() -> DatabaseManager:
"""
Test fixture for Database Manager.
A DATABASE CONFIGURATION AND CONNECTION IS REQUIRED FOR THESE TESTS.
"""
database = DatabaseManager()
return database
def database_manager() -> DatabaseManager:
filename = "test_additional.db"
dbm = DatabaseManager(filename)
yield dbm
dbm.__del__() # this is to release the database manager afterwards
os.remove(filename
) # this does what it sounds like it does, removes the test file
def __init__(self, game_ids, players, season=None, force_retrieval=False):
self.force_retrieval = force_retrieval
self.season = season
self.game_ids = game_ids
self.players = players
self.database_manager = DatabaseManager()
self.parser = PlayByPlayParser()
self.game_root_url = "http://www.espn.com/nba/playbyplay?gameId={0}"
def save_song(telegram_user):
manager = DatabaseManager(DATABASE)
user_data = manager.get_user_by_telegram_id(telegram_user,
access_token=True)
track_id = request.form['track_id']
track_features = get_track_features(track_id, user_data['access_token'])
if not track_features:
return ({
'code': -1,
'message': u'Error de autenticación. Prueba con "/conectar"'
})
track = {
'track_id':
track_id,
'track_name':
request.form['track_name'],
'track_album_id':
request.form['track_album_id'],
'track_album_name':
request.form['track_album_name'],
'track_popularity':
request.form['track_popularity'],
'track_artists':
request.form['artists'].split(','),
'duration':
track_features['duration_ms'] if track_features else 'NA',
'danceability':
track_features['danceability'] if track_features else 'NA',
'energy':
track_features['energy'] if track_features else 'NA',
'key':
track_features['key'] if track_features else 'NA',
'loudness':
track_features['loudness'] if track_features else 'NA',
'mode':
track_features['mode'] if track_features else 'NA',
'speechiness':
track_features['speechiness'] if track_features else 'NA',
'acousticness':
track_features['acousticness'] if track_features else 'NA',
'instrumentalness':
track_features['instrumentalness'] if track_features else 'NA',
'liveness':
track_features['liveness'] if track_features else 'NA',
'valence':
track_features['valence'] if track_features else 'NA',
'tempo':
track_features['tempo'] if track_features else 'NA'
}
inserted_track_id = manager.add_songs(user_data['id'], [track])
manager.classify_song(inserted_track_id,
ACTIVITIES.index(request.form['activity']))
return jsonify({'code': 1, 'message': 'Saved song succesfully!!!!'})
def test_cursor_type(self):
dbm = DatabaseManager(config.DB_HOST, config.DB_USER,
config.DB_PASSWORD, config.DB_NAME)
get_cursor_type = dbm._DatabaseManager__get_cursor_type
self.assertEqual(get_cursor_type(use_dict=True),
MySQLdb.cursors.DictCursor)
self.assertEqual(get_cursor_type(use_dict=False),
MySQLdb.cursors.Cursor)
dbm.close()
def train(telegram_user):
manager = DatabaseManager(DATABASE)
unclassified_song = manager.get_unclassified_songs(telegram_user)
if not unclassified_song:
return jsonify({'code': 0, 'message': 'All your song are trained.'})
else:
return jsonify({'code': 1, 'song': unclassified_song})
def course_search(request):
if not request.is_ajax():
print 'not ajax'
return
coursecode = request.POST['coursecode']
db = DatabaseManager()
courses = db.recommend_courses(coursecode)
jsonified = json.dumps(courses, default=decimal_default)
return HttpResponse(jsonified)
def accept_friend(token):
db_manager = DatabaseManager()
names = confirm_token(token)
if db_manager.users_are_friends(names[0], names[1]):
return "Already friends"
else:
db_manager.create_friendship(names[0], names[1])
return "Now friends"
def database_manager() -> DatabaseManager:
"""
What is a fixture? https://docs.pytest.org/en/stable/fixture.html#what-fixtures-are
"""
filename = "test_bookmarks.db"
dbm = DatabaseManager(filename)
yield dbm
dbm.__del__() # explicitly release the database manager
os.remove(filename)
