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 post(self, blogId, blogStatus): try: whereClause = {'_id': ObjectId(blogId)} data = DatabaseManager.find(Post, whereClause) if len(data) == 0 or len(data) > 1: formattedResponse = ResponseHandler.formatResponse( 'POST_NOT_FOUND') return formattedResponse, formattedResponse['statusCode'] postInstance = data[0] postInstance.status = blogStatus result = DatabaseManager.update(postInstance) formattedResponse = ResponseHandler.formatResponse( 'POST_UPDATE_SUCCESS') return formattedResponse, formattedResponse['statusCode'] except Exception as e: logging.error(traceback.format_exc()) formattedResponse = ResponseHandler.formatResponse( 'POST_UPDATE_FAILED', exception=e) return formattedResponse, formattedResponse['statusCode']
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 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 abort(400) # missing arguments # Check if already exists elif db_manager.username_exists(username) or db_manager.email_exists(email): # username and/or email do already exist return response_cache_header("ERROR, username and/or email do already exist", cache_control="no-cache") 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 response_cache_header("Successfully created user, please verify email.\n", cache_control="no-cache")
def classify(song_id, activity): manager = DatabaseManager(DATABASE) return jsonify({ 'code': 1, 'updated': manager.classify_song(song_id, activity) })
def createCharacter(account, name, model): if hasPlayer(name): raise CharacterAlreadyExists() try: ID = idFactory.createID() # these values are only for test puporse, must be tested and fixed # all players stats must be saved on DB if model == 1: spd = 2 df = 2 fc = 2 hp = 300 elif model == 2: spd = 1 df = 2 fc = 3 hp = 350 elif model == 3: spd = 3 df = 1 fc = 2 hp = 250 DB.getInstance().query("INSERT INTO Players (ID, account, name, speed, defense, `force`, maxHp, hp, model)" \ "Values (%s,%s,%s,%s,%s,%s,%s,%s,%s)",(ID,account,name,spd,df,fc,hp,hp,model)) except Exception, e: print e return False
def user_scripts(): token = request.query['token'] if not DatabaseManager.check_session(token): return HTTPResponse(status=401) user_id = DatabaseManager.get_user_id(request.query['user']) _response = {'scripts': [dict(x) for x in DatabaseManager.get_user_scripts(user_id)]} return HTTPResponse(status=200, body=json.dumps(_response))
def execute_on_torrent_downloaded_actions(self): """ Execute onTorrentDownloaded action """ curs = DatabaseManager.Instance().cursor # "SELECT id, data FROM AutomatedActions WHERE `trigger`='onTorrentDownloaded' AND notifier='TvShowManager';" actions = self.actions["onTorrentDownloaded"] # for a in curs: # actions.append(a) for id_, data in actions.items(): id_ = int(id_) try: self.logger.info("try to execute action id=%d", id_) success = self.execute_action(data) self.logger.info("action (id=%d) result=%d", id_, success) delete = success except KeyError: self.logger.info( "error while processing action (id=%d) torrent does not exist", id_) delete = True finally: pass if delete: self.logger.info("remove action with id=%d", id_) delete_query = "DELETE FROM AutomatedActions WHERE id=%s;" curs.execute(delete_query, (id_, )) DatabaseManager.Instance().connector.commit()
def authorize_user(login, password): if len(DatabaseManager.get_user(login, password)) != 0: token = secrets.token_hex(20) DatabaseManager.add_session(login, token) return token else: return "0"
def emulation_info_state(uuid): state_info = {} state_ref = dbm.retrieve_save_state(uuid=uuid)[0] other_save_states = dbm.retrieve_save_state(game_uuid=state_ref['game_uuid']) state_extra_files = dbm.retrieve_file_path(save_state_uuid=uuid) state_info['record'] = state_ref state_info['availableStates'] = filter(lambda s: True if s.get('save_state_source_data') or s.get('rl_starts_data') else False, other_save_states) state_info['fileMapping'] = {k: os.path.join('/game_data', v, k.split('/')[-1]) for k, v in map(lambda x: (x['file_path'], x['source_data']), state_extra_files)} if state_extra_files else None state_info['fileInformation'] = {f['file_path']: f for f in state_extra_files} # Save data is singular, and probably LZMA compressed if state_ref['save_state_source_data']: state_info['stateFileURL'] = os.path.join('/cite_data', state_ref['save_state_source_data'], '{}'.format(state_ref['uuid'])) # Save data is multiple and probably run length encoded if state_ref['rl_starts_data'] and state_ref['rl_lengths_data']: state_info['rlStartsURL'] = os.path.join('/cite_data', state_ref['rl_starts_data'], '{}'.format(state_ref['uuid'])) state_info['rlLengthsURL'] = os.path.join('/cite_data', state_ref['rl_lengths_data'], '{}'.format(state_ref['uuid'])) if state_extra_files: main_exec = dbm.retrieve_file_path(save_state_uuid=uuid, main_executable=True)[0] state_info['gameFileURL'] = os.path.join('/game_data', main_exec['source_data'], main_exec['file_path'].split('/')[-1]) else: game_ref = dbm.retrieve_game_ref(state_ref['game_uuid']) state_info['gameFileURL'] = os.path.join('/game_data', game_ref['source_data'], game_ref['data_image_source']) return jsonify(state_info)
class PlayerScraper: def __init__(self, season, force_retrieval=False): self.force_retrieval = force_retrieval self.parser = PlayerParser() self.season = season self.database_manager = DatabaseManager() self.numeric_cols = [] def request_players_from_web(self): player_stat_page = "http://www.basketball-reference.com/leagues/NBA_{0}_totals.html".format( str(self.season + 1)) r = urllib2.urlopen(player_stat_page) return r def fetch_players(self): if len(self.database_manager.get_players( self.season)) == 0 or self.force_retrieval: # We want to get the remote copy, regardless if we have it already. print "fetching players remotely" page = self.request_players_from_web() df = self.parser.parse_player_page(page) df.reset_index(inplace=True) df["season"] = self.season df = df.apply(pd.to_numeric, errors='ignore') print df.loc[:, 'efg_pct'] [ self.database_manager.add_player(v) for k, v in df.to_dict(orient='index').iteritems() ] return self.database_manager.get_players(self.season)
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 cli(ctx, verbose, no_prompts): ctx.obj = dict() # Context object that stores application state in dict, could make class at some point ctx.obj['VERBOSE'] = verbose ctx.obj['NO_PROMPTS'] = no_prompts # Check for ucon64 try: devnull = open(os.devnull) subprocess.Popen(['ucon64'], stdout=devnull, stderr=devnull).communicate() except OSError as e: if e.errno == os.errno.ENOENT: click.echo("WARNING: ucon64 not installed. Required for NES, SNES and N64 rom info.") # Check for data root if not os.path.exists(LOCAL_DATA_ROOT): click.echo("Local data root not found, creating {}".format(LOCAL_DATA_ROOT)) os.makedirs(LOCAL_DATA_ROOT) # Check for tables, extracted, game citation and performance citation dbm.create_tables() # Check for data directory for data_path, path_name in ((LOCAL_GAME_DATA_STORE, "game data"), (LOCAL_CITATION_DATA_STORE, "citation data")): if not os.path.exists(data_path): click.echo("Local {} store: '{}' not found, creating...".format(path_name, data_path)) os.makedirs(data_path)
def _add_message(self, data): database = DatabaseManager() security = Security() user = security.user password = security.password database.connect(dialect=self.dialect, user=user, passwd=password, database=self.db) database.add_messages(data)
def getUserRights(): token = request.query['token'] if not DatabaseManager.checkSession(token): return HTTPResponse(status=401) rights = DatabaseManager.getUserRights( DatabaseManager.getLoginByToken(token)[0])[0] return HTTPResponse(status=200, body=json.dumps({'rights': rights}))
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 getRoomRents(): token = request.query['token'] if not DatabaseManager.checkSession(token): return HTTPResponse(status=401) return HTTPResponse( status=200, body=json.dumps(DatabaseManager.getRoomRents(request.query['room'])))
def getUserRents(): token = request.query['token'] if not DatabaseManager.checkSession(token): return HTTPResponse(status=401) userId = DatabaseManager.getUserId(request.query['user']) _body = json.dumps(DatabaseManager.getUserRents(userId[0])) return HTTPResponse(status=200, body=_body)
def performance_info(uuid): perf_info = {} perf_ref = dbm.retrieve_perf_ref(uuid) perf_info['record'] = perf_ref.elements perf_info['linkedStates'] = dbm.retrieve_all_state_perf_links(uuid) perf_info['availablePerformances'] = [dict(p.get_element_items()) for p in dbm.retrieve_derived_performances(perf_ref['game_uuid'])] return jsonify(perf_info)
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('=====================================================.')
class get_dbm(object): def __enter__(self): self.dbm = DatabaseManager(config.DB_HOST, config.DB_USER, config.DB_PASSWORD, config.DB_NAME) return self.dbm def __exit__(self, type, value, traceback): self.dbm.close()
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 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 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 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 __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 insert_or_update_in_db(self): # if not self.isInDB: sql = "INSERT INTO `TrackedTorrentFiles` (`hash`, `name`, `timeout`, `torrentHash`, `torrentFileName`) VALUES (%s, %s, UNIX_TIMESTAMP()+%s, %s, %s) ON DUPLICATE KEY UPDATE timeout=VALUES(timeout);" DatabaseManager.Instance().cursor.execute( sql, (self.hash, self.name, self.timeout, self.torrent_hash, self.torrent_file_name)) DatabaseManager.Instance().connector.commit()
def add_rl_save_state_data(uuid): rl_starts_b64 = request.form.get('rl_starts') rl_lengths_b64 = request.form.get('rl_lengths') rl_total_length = int(request.form.get('rl_total_length')) rl_lengths_length = int(request.form.get('rl_lengths_length')) rl_starts_length = int(request.form.get('rl_starts_length')) rl_starts_b_array = bytearray(base64.b64decode(rl_starts_b64)) rl_lengths_b_array = bytearray(base64.b64decode(rl_lengths_b64)) if len(rl_starts_b_array) != rl_starts_length: rl_starts_b_array.extend([0 for _ in range(len(rl_starts_b_array), rl_starts_length)]) if len(rl_lengths_b_array) != rl_lengths_length: rl_lengths_b_array.extend([0 for _ in range(len(rl_lengths_b_array), rl_lengths_length)]) rl_start_hash, file_name = save_byte_array_to_store(rl_starts_b_array, file_name=uuid) rl_lengths_hash, file_name = save_byte_array_to_store(rl_lengths_b_array, file_name=uuid) dbm.update_table(dbm.GAME_SAVE_TABLE, ['rl_starts_data','rl_lengths_data','rl_total_length','compressed'], [rl_start_hash, rl_lengths_hash, rl_total_length, True], ['uuid'], [uuid]) return jsonify({'record': dbm.retrieve_save_state(uuid=uuid)[0]})
class GameScraper: """ Pulls down play-by-play and schedule data from ESPN """ 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_pbp_to_disk(self, page, game_id): import os pbp_path = os.path.join('data', str(self.season)) with open(os.path.join(pbp_path, "pbp_" + str(game_id) + ".txt"), "wb") as f: f.write(str(page)) def scrape_pbp(self): print self.season stored_game_ids = np.unique([ dunk["game_id"] for dunk in self.database_manager.get_dunks(self.season) ]) missing_game_ids = set(self.game_ids) - set(stored_game_ids) print len( missing_game_ids ), " missing game ids in dunk database, will attempt to retrieve." pbp_path = os.path.join('data', str(self.season), 'pbp_reg') for game_id in missing_game_ids: try: with open( os.path.join(pbp_path, "pbp_" + str(game_id) + ".txt"), "r") as f: g = f.read() print "We've got this on disk" except IOError: print "Don't have this play-by-play yet" time.sleep(np.random.randint(2, 7)) try: g = urllib2.urlopen( self.game_root_url.format(game_id)).read() self._save_pbp_to_disk(bs4.BeautifulSoup(g, "lxml"), game_id) except urllib2.URLError: print "could not get page" continue dunks = self.parser.parse_pbp(g, self.players, game_id, self.season) if dunks is not None: for dunk in dunks: if dunk is not None: self.database_manager.add_dunk(dunk) else: continue
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 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 change_status(self): self.engine.conv_state = not self.engine.conv_state DatabaseManager.set_current_state(self.engine.conv_state) if self.engine.conv_state: self.show_on_status() self.load_keyboard() else: self.show_off_status()
def make_performance_package(performance): pack = {} game = dbm.retrieve_game_ref(performance['game_uuid']) pack['game'] = game.elements if game else None pack['performance'] = performance.elements # Last performance is current performance pack['previous_performances'] = [i.elements for i in dbm.retrieve_performance_chain(performance['uuid'])[:-1]] return pack
def delete_script(): body = request.json token = body['token'] if not DatabaseManager.check_session(token): return HTTPResponse(status=401) user_id = DatabaseManager.get_user_id(body['user']) DatabaseManager.delete_script(user_id, body['name']) return HTTPResponse(status=200)
def controllers(): token = request.query['token'] if not DatabaseManager.check_session(token): return HTTPResponse(status=401) user_id = DatabaseManager.get_user_id(request.query['user']) result = DatabaseManager.get_user_controllers(user_id) _response = {"controllers": [dict(x) for x in result]} return HTTPResponse(status=200, body=json.dumps(_response))
def getHotelAvailableRooms(): token = request.query['token'] if not DatabaseManager.checkSession(token): return HTTPResponse(status=401) return HTTPResponse(status=200, body=json.dumps( DatabaseManager.getHotelAvailableRooms( request.query['hotel'])))
def get_received_code(): token = request.query['token'] if not DatabaseManager.check_session(token): return HTTPResponse(status=401) key = request.query['key'] code = DatabaseManager.get_received_code(key) _response = {'code': code} return HTTPResponse(status=200, body=_response)
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 citations_all_page(): all_game_cites = [dbm.create_cite_ref_from_db(GAME_CITE_REF, x) for x in dbm.retrieve_all_from_table(dbm.GAME_CITATION_TABLE)] all_perf_cites = [dbm.create_cite_ref_from_db(PERF_CITE_REF, x) for x in dbm.retrieve_all_from_table(dbm.PERFORMANCE_CITATION_TABLE)] return render_template('citations_main.html', all_game_cites=all_game_cites, all_perf_cites=all_perf_cites, perf_headers=all_perf_cites[0].get_element_names() if all_perf_cites else [], game_headers=all_game_cites[0].get_element_names() if all_game_cites else [])
def citation_add(cite_type): clean_params = dict([(k, v) for k, v in request.form.items() if not v or v != 'None']) if cite_type == GAME_CITE_REF: cite = generate_cite_ref(GAME_CITE_REF, GAME_SCHEMA_VERSION, **clean_params) elif cite_type == PERF_CITE_REF: cite = generate_cite_ref(PERF_CITE_REF, PERF_SCHEMA_VERSION, **clean_params) dbm.add_to_citation_table(cite, fts=True) return redirect(url_for('citation_page', uuid=cite['uuid']))
def set_timeout(self, timeout=2538000): # default timeout set to 30 days sql = "UPDATE `TrackedTorrentFiles` SET `timeout`=UNIX_TIMESTAMP()+ %d WHERE `name`=%s;" DatabaseManager.Instance().cursor.execute(sql, ( timeout, self.name, )) DatabaseManager.Instance().connector.commit()
def accept_friend(token): db_manager = DatabaseManager() names = confirm_token(token) if db_manager.users_are_friends(names[0], names[1]): return response_cache_header("Already friends", cache_control="no-cache") else: db_manager.create_friendship(names[0], names[1]) return response_cache_header("Now friends", cache_control="no-cache")
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 verify_email(token): db_manager = DatabaseManager() email = confirm_token(token) if db_manager.email_is_verified(email): return "Email already verified.\n" else: # Verify db_manager.verify_email(email) return "Email Successfully verified.\n"
def verify_email(token): db_manager = DatabaseManager() email = confirm_token(token) if db_manager.email_is_verified(email): return response_cache_header("Email already verified.\n", cache_control="no-cache") else: # Verify db_manager.verify_email(email) return response_cache_header("Email Successfully verified.\n", cache_control="no-cache")
def ok_file(self, button, filesel): path = filesel.get_filename() mdpath = join(dirname(path), 'machine_database.xml') action = filesel.get_data('action') filesel.destroy() dir = dirname(path) dbm = DatabaseManager(self.conn) if action == 'backup': dbm.backup(dir) elif action == 'restore': dbm.restore(dir)
def init_combobox(self): self.keyboard_cbox.blockSignals(True) self.keyboard_cbox.clear() current_keyboard = DatabaseManager.get_current_keyboard() index = 0 for keyboard in DatabaseManager.get_all_keyboards()[1]: self.keyboard_cbox.addItem(keyboard.language_name, keyboard.id) if int(current_keyboard) == keyboard.id: self.keyboard_cbox.setCurrentText(keyboard.language_name) self.keyboard_cbox.setCurrentIndex(index) index += 1 self.keyboard_cbox.blockSignals(False)
def add_screen_data(uuid): screen_data = bytes(base64.b64decode(request.form.get('buffer'))) width = int(request.form.get('width')) height = int(request.form.get('height')) image = Image.frombytes("RGBA", (width, height), screen_data) # Doing the saving here for now, might move later? base_path = os.path.join(LOCAL_CITATION_DATA_STORE, uuid) if not os.path.exists(base_path): os.makedirs(base_path) image.save(os.path.join(base_path, 'screen_{}.png'.format(uuid)), "PNG") dbm.add_screen_to_state(uuid) # one screen per state, so only change 'has_screen' parameter state = dbm.retrieve_save_state(uuid=uuid)[0] return jsonify({'record': state})
def store(): db_manager = DatabaseManager() token = request.json.get("token") # password = sha512_crypt.encrypt(request.json.get('password'), salt=app.config['SECURITY_PASSWORD_SALT'], rounds=5000) selector = request.json.get("selector") if selector: db_manager.add_auth_token(selector, token) return response_cache_header( json.dumps({"response": "Stored session", "success": True}), cache_control="no-cache" ) else: return response_cache_header(json.dumps({"error": "Not satisfied", "success": False}), cache_control="no-cache")
def remove(): db_manager = DatabaseManager() selector = request.json.get("selector") if selector: db_manager.remove_auth_token(selector) return response_cache_header( json.dumps({"response": "Removed Session", "success": True}), cache_control="no-cache" ) else: return response_cache_header( json.dumps({"response": "Did not remove session", "success": False}), cache_control="no-cache" )
def search_globally_with_game_partial(citation_partial): citations = [] NEW = 'new' OLD = 'old' @coroutine def process_citation_url(): while True: url = (yield) if not dbm.is_attr_in_db('source_url', url, dbm.GAME_CITATION_TABLE): click.echo('Extracting url {} through coroutine.'.format(url)) extractor = get_extractor_for_uri(url, get_url_source(url)) extractor.extract() citation, extracted_options = extractor.create_citation() citations.append((citation, NEW)) else: click.echo('Found {} in local db.'.format(url)) citation = dbm.create_cite_ref_from_db(GAME_CITE_REF, dbm.retrieve_attr_from_db( 'source_url', url, dbm.GAME_CITATION_TABLE)[0]) citations.append((citation, OLD)) # Currently this search is only through MobyGames, may work on federated search # in the future. Also only searches on title for now # Just need the extractor, don't need its state search_string = citation_partial['description']['title'] limit = citation_partial['limit'] if 'limit' in citation_partial else None search_uris = get_extractor_for_uri('http://www.mobygames.com', None).get_search_uris(search_string) if limit and limit <= len(search_uris) - 1: search_uris = search_uris[:limit] # Process coroutine # Send uris to coroutine generator for uri in search_uris: process_citation_url().send(uri) # Block until all the search citations return while len(citations) != len(search_uris): pass for c in citations: if c[1] == NEW: dbm.add_to_citation_table(c[0], fts=True) return [c for c, _ in citations]
def show_user_list(username, listname): db_manager = DatabaseManager() token = request.json.get("token") if token is None or token is "": return json.dumps({ 'username':'******' }) # 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':'******'}) if db_manager.username_exists(username): if db_manager.listname_exists_for_user(username, listname): list_data = db_manager.get_list(username, listname) shared_with = list_data.get("shared_with") translations = db_manager.get_translations_for_list(username, listname) for translation in translations: del translation['id']; del translation['list_id'] # Check if is owner if username == token_credentials[0]: return json.dumps({ 'listname' : listname, 'language_1_tag' : list_data.get("language_1_tag"), 'language_2_tag' : list_data.get("language_2_tag"), 'words' : translations, 'shared_with' : shared_with }) # Check if is friend elif shared_with == '1' and db_manager.users_are_friends(username, token_credentials[0]): return json.dumps({ 'listname' : listname, 'language_1_tag' : list_data.get("language_1_tag"), 'language_2_tag' : list_data.get("language_2_tag"), 'words' : translations, 'shared_with' : shared_with }) elif shared_with == '2': return json.dumps({ 'listname' : listname, 'language_1_tag' : list_data.get("language_1_tag"), 'language_2_tag' : list_data.get("language_2_tag"), 'words' : translations, 'shared_with' : shared_with }) else: abort(401) else: return json.dumps({ 'username': '******'t happen' }) else: return json.dumps({ 'username': '******'t happen' })
def search_locally_with_partial(partial, exclude_ref_types=None): start_index = int(partial['start_index']) limit = int(partial['limit']) if 'limit' in partial else None # Apparently Python DB API and Sqlite and commas (,), parans ((,)), and colons (:) do not play nice with FTS? search_strings = u" ".join([unicode(v) for k, v in partial['description'].items()]) for ref_type in exclude_ref_types: search_strings += u" AND NOT (tags:{})".format(ref_type) uuids = dbm.retrieve_from_fts(search_strings, start_index=start_index, limit=limit) def get_cite_for_uuid(result): ref_type = result['tags'] uuid = result['uuid'] if ref_type == GAME_CITE_REF: table = dbm.GAME_CITATION_TABLE if ref_type == PERF_CITE_REF: table = dbm.PERFORMANCE_CITATION_TABLE if ref_type == STATE_CITE_REF: table = dbm.GAME_SAVE_TABLE if ref_type in (GAME_CITE_REF, PERF_CITE_REF): db_values = dbm.retrieve_attr_from_db('uuid', uuid, table, limit=1)[0] citation = dbm.create_cite_ref_from_db(ref_type, db_values) else: citation = dbm.retrieve_save_state(uuid=uuid)[0] citation['ref_type'] = STATE_CITE_REF return citation # Results should already be sorted by rank citations = map(get_cite_for_uuid, uuids) return citations
def __init__(self): QDialog.__init__(self) 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 __init__(self, config): config.events.StartInitSession() # init alpm if p.alpm_initialize() == -1: raise SessionError("Could not initialize session (alpm_initialize)") self.config = config p.alpm_option_set_root(config.rootpath) p.alpm_option_set_arch(config.architecture) # set up and register databases if p.alpm_option_set_dbpath(config.local_db_path) == -1: raise SessionError("Could not open the database path: %s" % \ config.local_db_path) self.db_man = DatabaseManager(config.events) self.db_man.register("local", LocalDatabase()) for repo, url in config.available_repositories.items(): self.db_man.register(repo, SyncDatabase(repo, url)) if config.aur_support: self.db_man.register("aur", AURDatabase(config)) self.apply_config() self.config.events.DoneInitSession()
def update_save_state(uuid): update_fields = json.loads(request.form.get('update_fields')) # if linking to a performance, do that and then throw away since GAME_SAVE_TABLE doesn't refer to performance if 'performance_uuid' in update_fields: performance_uuid = update_fields['performance_uuid'] performance_time_index = update_fields['performance_time_index'] action = update_fields['action'] dbm.link_save_state_to_performance(uuid, performance_uuid, performance_time_index, action) del update_fields['performance_uuid'] del update_fields['performance_time_index'] del update_fields['action'] # make sure that there are still fields to update if len(update_fields.keys()) > 0: dbm.update_table(dbm.GAME_SAVE_TABLE, update_fields.keys(),update_fields.values(), ['uuid'], [uuid]) return jsonify(dbm.retrieve_save_state(uuid=uuid)[0])
def add_save_state_data(uuid): save_state_data = request.form.get('buffer') compressed = True if request.form.get('compressed') == u'true' else False data_length = int(request.form.get('data_length')) save_state_b_array = bytearray(base64.b64decode(save_state_data)) # The base64 library will interpret trailing zeros as padding and remove them, this adds them back in if len(save_state_b_array) != data_length: save_state_b_array.extend([0 for _ in range(len(save_state_b_array), data_length)]) source_data_hash, file_name = save_byte_array_to_store(save_state_b_array, file_name=uuid) dbm.update_table(dbm.GAME_SAVE_TABLE, ['save_state_source_data', 'compressed'], [source_data_hash, compressed], ['uuid'], [uuid]) return jsonify({'record': dbm.retrieve_save_state(uuid=uuid)[0]})