def register(): if request.form.get('terms') != 'agree': return redirect(url_for('error', e='You have to accept the Terms of Service')) if request.form.get('url'): return redirect(url_for('error', e='You seem to be a robot.')) if not re.match(r'^[^@]+@[^@]+\.[^@]+$', request.form.get('email')): return redirect(url_for('error', e='Your mail address is invalid.')) if not re.match(r'^[a-z]+$', request.form.get('user')): return redirect(url_for('error', e='Your username contains invalid characters')) for field in ['firstname', 'lastname', 'country', 'city', 'organization']: if not request.form.get(field): return redirect(url_for('error', e='Not all required data is provided.')) db = get_session() db.add(User( username=request.form.get('user'), firstname=request.form.get('firstname'), lastname=request.form.get('lastname'), email=request.form.get('email'), country=request.form.get('country'), city=request.form.get('city'), organization=request.form.get('organization'), department=request.form.get('department'), created=datetime.today(), usage=request.form.get('usage'), learned=request.form.get('learn-about'), admin=False, access=False)) try: db.commit() except IntegrityError: return redirect(url_for('error', e='User already exists.')) # Send registration mail to admin h_from = request.form.get('email') h_subject = config.adminmailsubject % {'username' : request.form.get('user')} body = config.adminmailtext % { 'username' : request.form.get('user'), 'firstname' : request.form.get('firstname'), 'lastname' : request.form.get('lastname') } try: for to in config.adminmailadress: print to email(h_from=h_from, h_to=to, h_subject=h_subject, body=body) except smtplib.SMTPSenderRefused as err: db = get_session() db.query(User).filter(User.username==request.form.get('user')).delete() db.commit() return redirect(url_for('error', e='There seems to be an error woth' 'your email address: %s.' % (err,))) return redirect('/success')
def test_add_score(): session = db.get_session(SESSION) db.create_user(session, 'kevin') db.create_user(session, 'kevin', 22) session = db.get_session() user = db.exists(session, 'kevin') assert_equal(22, user.score)
def forgot(): if request.form.get('url'): return redirect(url_for('error', e='You seem to be a robot.')) emailaddr = request.form.get('email') if not emailaddr: return render_template('forgot.html', config=config) key = passwdgen(64) db = get_session() user = db.query(User).filter(User.email==emailaddr) if not user.count(): return redirect(url_for('error', e='User does not exist.')) user = user[0] db.query(ActivationLink).filter(ActivationLink.username==user.username).delete() db.add(ActivationLink( username=user.username, created=datetime.today(), key=key)) db.commit() body = config.forgotmailtext % { 'firstname' : user.firstname, 'lastname' : user.lastname, 'resetlink' : url_for('resetview', username=user.username, key=key)} email(h_to=user.email, h_subject=config.forgotmailsubject, body=body) return redirect(url_for('error', e='We sent you a mail with further instructions.'))
def on_get(self, req, resp, company_name): session = db.get_session() employees = [] try: logging.info("into on_get method") result = session.execute( """ SELECT name from trans_people, dim_company where company_id = id and company_name = UPPER(:name) """, { "name": company_name }).fetchall() if not result: resp.status = falcon.HTTP_404 resp.body = json.dumps({ 'error': "Sorry.It looks like there are no employees listed for the particular company" }) else: for row in result: employees.append(row['name']) # Create a JSON representation of the resource resp.body = json.dumps({'employees': employees}, ensure_ascii=False) except Exception as e: db.PrintException() resp.status = falcon.HTTP_500 finally: session.close()
def load_database(handler): """ HTTP Request -Thread-local """ web.ctx.orm = db.get_session() akiyoshi.log.debug('Database session scope [start] - %s' % web.ctx.orm) try: ret = handler() web.ctx.orm.commit() akiyoshi.log.debug('Database session scope [commit] - %s' % web.ctx.orm) return ret except web.HTTPError: if web.ctx.status[:1] in ['2', '3']: web.ctx.orm.commit() akiyoshi.log.debug('Database session scope [commit] : HTTP Status=%s - %s' % (web.ctx.status, web.ctx.orm)) raise else: web.ctx.orm.rollback() akiyoshi.log.debug( 'Database session scope [rollback] : HTTP Status=%s - %s' % (web.ctx.orm, web.ctx.status)) raise except: web.ctx.orm.rollback() akiyoshi.log.debug('Database session scope [rollback] - %s' % web.ctx.orm) raise
def delete(ref='new'): username, admin, repoaccess = [None]*3 try: username, admin, repoaccess = session.get('login') except: pass if not username or not admin: return redirect(url_for('home')) user = request.form.get('user') reason = request.form.get('reason') db = get_session() users = db.query(User).filter(User.username==user) for user in users: body = config.deletemailtext % { 'firstname' : user.firstname, 'lastname' : user.lastname, 'reason' : reason} email(h_to=user.email, h_subject=config.deletemailsubject, body=body) users.delete() db.commit() return redirect(url_for('admin', who=ref))
def get_score(score_id): session = get_session() try: return session.query(Score).filter_by(id=score_id).options( joinedload('game.states.player')).first() except: return None
def sample_data(coordinates, model_radius=0.05): with get_session() as session: response = session.query(SearchResults.latitude, SearchResults.longitude, \ SearchResults.category, SearchResults.num_unique).\ filter((SearchResults.latitude-coordinates[0] < model_radius), (SearchResults.longitude-coordinates[1] < model_radius)).all() return response
def build(self): self.title = "Encomendas - J & N Artefatos de Cimento" # Session to use in all functionalities of the app. self.session = get_session() # Add an easy reference on the app to all main screens except menu to # later use. self.new_order = NewOrder(name='new_order') self.consult = Consult(name="consult") self.payments = Payments(name="payments") self.orders = Orders(name="orders") self.prices = Prices(name="prices") # Create the main screen manager and add an easy reference on the app. self.sm = ScreenManager(transition=SwapTransition()) # Add all the screens to the manager self.sm.add_widget(Menu(name="menu")) self.sm.add_widget(self.new_order) self.sm.add_widget(self.consult) self.sm.add_widget(self.payments) self.sm.add_widget(self.orders) self.sm.add_widget(self.prices) # Return the root widget. return self.sm
def admin_delete_picture(shoot_link, picturename): if not check_login(session): abort(403) db_session = db.get_session() try: obj = db_session.query(db.Shoot).filter_by(link=shoot_link).one() pic = db_session.query(db.Pictures).filter_by( shoot=obj, filename=picturename).one() except NoResultFound: abort(404) raise try: next_pic = pic.next_pic() next_link = url_for('.admin_shoot_picture', shoot_link=shoot_link, picturename=next_pic.filename) except StopIteration: next_link = url_for('.admin_shoot_overview', shoot_link=shoot_link) picture_path = os.path.join(app.config['UPLOAD_FOLDER'], pic.filename) try: os.unlink(picture_path) except FileNotFoundError: pass db_session.delete(pic) db_session.commit() return jsonify(next=next_link)
def index(): if request.method == "GET": if check_login(session): return redirect(url_for('.admin')) else: pw = "0" if request.args.get('pw') in ["1", "2"]: pw = request.args.get('pw') return render_template("index.html", pw=pw) if request.method == "POST": # Check password for admin login try: password = request.form['password'] except KeyError: abort(400) raise db_session = db.get_session() try: instance = db_session.query(db.Passwords).one() except NoResultFound: # Database is empty, accept default password, but give a warning if password == "DEF4ULT": session["login"] = True return redirect(url_for('.admin') + '?pw=1') else: return redirect('/?pw=1') if pbkdf2_sha256.verify(password, instance.password): session["login"] = True return redirect(url_for('.admin')) else: return redirect('/?pw=1')
def manage(): if not check_login(session): return redirect(url_for('.login')) db_session = db.get_session() user = db_session.query(db.Users).filter_by(username=session["user"]).one() return render_template("manage.html", user=user)
def reset(): if request.form.get('url'): return redirect(url_for('error', e='You seem to be a robot.')) if request.form.get('yes') != 'YES': return redirect(url_for('error', e='You need to confirm a reset.')) username = request.form.get('user') key = request.form.get('key') db = get_session() timebarrier = datetime.now() - timedelta(days=1) activation = db.query(ActivationLink).filter(ActivationLink.username==username)\ .filter(ActivationLink.key==key)\ .filter(ActivationLink.created>=timebarrier) if not activation.count(): return redirect(url_for('error', e='Invalid reset link.')) user = activation[0].user password = passwdgen() user.password_set(password) activation.delete() db.commit() body = config.accessmailtext % { 'firstname' : user.firstname, 'lastname' : user.lastname, 'username' : user.username, 'password' : password} email(h_to=user.email, h_subject=config.accessmailsubject, body=body) return redirect(url_for('error', e='We sent you a mail with further information.'))
def save_game(game, training): session = get_session() db_game = DBGame(game.type, game.start_deck, game.seed) name_to_player_map = {} player_to_score_map = {} last_elapsed_time = 0 for (board, tau) in zip(game.boards, game.taus): (elapsed_time, total_taus, player, cards) = tau if player in name_to_player_map: db_player = name_to_player_map[player] player_to_score_map[player] += 1 else: db_player = get_or_create_dbplayer(session, player) player_to_score_map[player] = 1 name_to_player_map[db_player.name] = db_player state = State(elapsed_time, board, cards, db_player) db_game.states.append(state) last_elapsed_time = elapsed_time players = name_to_player_map.values() team = get_or_create_team(session, players) score = Score(last_elapsed_time, datetime.datetime.utcnow(), db_game, players, team, player_to_score_map) if training: score.invalid = True session.add(score) session.add(db_game) session.commit() return (db_game, score, last_elapsed_time)
def get_all_high_scores(num_scores, leaderboard_type, players, conjunction, unique_players=False): session = get_session() ret = defaultdict(dict) for (number, game_type) in get_numbers(leaderboard_type, players): top_scores = simple_query(leaderboard_type, number, game_type, session.query(Score)).order_by( asc(Score.elapsed_time)) if players: top_scores = filter_for_players(players, top_scores) if conjunction == "and": top_scores = and_query(players, top_scores) if unique_players: q = simple_query( leaderboard_type, number, game_type, session.query( Score.team_id, func.min(Score.elapsed_time).label( 'min_elapsed_time'))).group_by( Score.team_id).subquery() top_scores = top_scores.join(q, Score.team_id == q.c.team_id) top_scores = top_scores.filter( Score.elapsed_time == q.c.min_elapsed_time) scores = list(top_scores.limit(num_scores)) if scores: ret[game_type][number] = scores return ret
def get(cls, id): result = {} session = get_session() try: s = session.query(Section).filter(Section.id == id).one() except NoResultFound: return error("No section with such id", http.NOT_FOUND) result['lection'] = s.lection result['subject'] = s.subject result['questions'] = [] for question in s.questions: result['questions'].append({ 'id': question.id, 'question': question.question, 'answer_variants': sorted( [ { 'id': a.id, 'text': a.text, } for a in question.answers ], key=lambda x: random.random()) }) return ok(result)
def put(cls, id, data): result = {} session = get_session() try: s = session.query(Section).filter(Section.id == id).one() except NoResultFound: return error("No section with such id", http.NOT_FOUND) try: h = data['answers'] answers = dict(zip(map(lambda k: int(k), h.keys()), h.values())) except Exception: return error("Malformed request") for question in s.questions: if len(question.answers) > 1: q_res = [] for answer in question.answers: q_res.append(answer.correct == answers.get(answer.id, False)) print("Question: {}, q_res: {}".format(question.question, q_res)) result[question.id] = all(q_res) else: for answer in question.answers: print("Question: {}, res: {}".format(question.question, answer.id)) result[question.id] = (answer.text == answers.get(answer.id, None)) return ok({'result': result})
def _add(cls, id, data): required = [] optional = [] for column in cls.model.__table__.columns: if column.name != 'id': if not column.nullable: required.append(column.name) else: optional.append(column.name) try: h = dict((attr, data[attr]) for attr in required) except KeyError as e: raise ApiError("Missing required parameter: {}".format(e.args[0])) if id: h['id'] = id for o in optional: if o in data: h.update({o: data[o]}) obj = cls.model(**h) session = get_session() session.add(obj) session.commit() return obj.to_dict(), http.CREATED
def home(): latitude = safe_float(request.args.get('city_lat')) longitude = safe_float(request.args.get('city_long')) radius = safe_int(request.args.get('radius')) closest = safe_int(request.args.get('closest')) python = bool(request.args.get('python')) r = bool(request.args.get('r')) people = db.get_session().query(Person).join(Person.facts).\ join(Facts.airport).\ filter(Facts.active == True) if python: people = people.filter(Facts.python == True) if r: people = people.filter(Facts.r == True) if latitude is not None and longitude is not None and radius: people = ( person for person in people if person.facts.airport.is_within_radius_of( radius, latitude, longitude, units='km' ) ) elif latitude is not None and longitude is not None and closest: # not searching radius but rather closest people people = sorted(people, key=lambda x: x.facts.airport.distance_from(latitude, longitude))[:closest] return render_template('index.html', people=people)
def linkaccount(): if not 'uid' in session: return redirect(url_for('login')) dbs = db.get_session() req_token,url = db.authapp(dbs,url_for('linked',_external=True)) session['db_req_token'] = req_token.key + '###' + req_token.secret return redirect (url)
def spamer(app): form = AppSearch() if form.validate_on_submit(): return redirect('/application/'+form.app.data) sess = db.get_session() events = [] for event in sess.query(db.Events).filter_by(applicationId = app).order_by(db.Events.time.desc()).all()[:50]: rez = event.__dict__ events.append(rez) db_app = sess.query(db.Applications).filter_by(id = app).first() if not db_app is None: app_view = {'id':db_app.id, 'base':db_app.base.name} else: app_view = None sess.close() return render_template("events.html", title = 'Unsorted', form = form, app_view = app_view, is_partial = True, events = events)
def home(): latitude = safe_float(request.args.get('city_lat')) longitude = safe_float(request.args.get('city_long')) radius = safe_int(request.args.get('radius')) python = bool(request.args.get('python')) r = bool(request.args.get('r')) people = db.get_session().query(Person).join(Person.facts).\ join(Facts.airport).\ filter(Facts.active == True) if python: people = people.filter(Facts.python == True) if r: people = people.filter(Facts.r == True) if latitude is not None and longitude is not None and radius: people = ( person for person in people if person.facts.airport.is_within_radius_of( radius, latitude, longitude, units='km' ) ) return render_template('index.html', people=people)
def manage_upload(name): if not check_login(session): abort(403) db_session = db.get_session() try: obj = db_session.query(db.Sites).filter_by(name=name).one() except NoResultFound: abort(404) file = request.files["files[]"] filename = file.filename.replace(" ", "_") if filename == '': # when no file is selected filename is empty, without data return jsonify(error="No file selected") if file: sec_filename = secure_filename(filename) # Check if the file already exists and rename it silently if os.path.isfile(os.path.join(app.config['UPLOAD_FOLDER'], sec_filename)): sec_filename = os.path.splitext(sec_filename)[0] + "_conflict" + os.path.splitext(sec_filename)[1] file.save(os.path.join(app.config['UPLOAD_FOLDER'], sec_filename)) obj.icon = sec_filename db_session.commit() return jsonify(files=[{ "name": sec_filename, "url": "/img/" + sec_filename, }, ])
def create_partitions(ctx): ctx.status("creating partitions") part_tbl = db.get_table('partitions') sess = db.get_session() created = set() try: for p in ctx.deployment_config.providers.values(): part_uuid = p.partition.uuid if part_uuid in created: continue metadata.create_object( sess, 'runm.partition', part_uuid, p.partition.name) # Create the base provider group record part_rec = dict( uuid=part_uuid, ) ins = part_tbl.insert().values(**part_rec) sess.execute(ins) created.add(part_uuid) sess.commit() ctx.status_ok() except Exception as err: sess.rollback() ctx.status_fail(err)
def _run(self): messenger = Messenger(db.get_session()) running_jobs = set() for dest in self._mapping: messenger.subscribe(dest) counter = 0 while self._running: print 'counter = ', counter counter += 1 messages = messenger.recv() for msg in messages: running_jobs.add((msg, self._dispatch_job(msg))) gevent.sleep(0.01) done = gevent.joinall( [j[1] for j in running_jobs], timeout=0, ) for j in done: for msg, job in running_jobs: if j == job: running_jobs.remove((msg, job)) messenger.retire(msg.id) break while self._outgoing_messages: to, params = self._outgoing_messages.pop() messenger.send(to, **params)
def update(table, data, identifier): try: results = [] with get_session() as session: user = session.query(Auth).filter_by(id=get_jwt_identity()).first() query = session.query(table).filter_by(id=identifier) record = query.first() data.pop('jwt', None) if record is None: return "Could not find record" ## create User Log # {foreign key column: id of updated record} fk = {"{}_id".format(table.__name__.lower()): record.id} # update info (username, timestamp) log = {"username": user.username, "last_updated": datetime.now()} # all update info log.update(fk) # find if last updated already exists for username, <table>_id existing = session.query(UserLog).filter_by(username=user.username, **fk).first() if existing: session.query(UserLog).update(log) else: session.add(UserLog(**log)) session.commit() session.flush() ## Update table with new data query.update(data) session.commit() # fetch newly updated record session.refresh(record) results = [obj_to_dict(record)] return results except (SQLAlchemyError, ValueError) as e: return str(e)
def track_books(): session = get_session() now = datetime.utcnow().replace(second=0, microsecond=0) try: q = session.query try: last_update_time = q(m.Rank).order_by( m.Rank.timestamp.desc()).first().timestamp except Exception: last_update_time = now - 2 * HOUR time_since_last_update = now - last_update_time if time_since_last_update < HOUR: timestamp = last_update_time + HOUR until_next_hour = (timestamp - now).seconds print( f'Sleeping {until_next_hour // 60} minutes until {timestamp}') time.sleep(until_next_hour) else: timestamp = now books = q(m.Book).filter_by(track=True).all() for book in books: print(f'[{timestamp}] --- {book.name} ---') r = scrape_page(book.url) for category_name, rank in r['categories'].items(): print(f'{category_name}: {rank}') update_rank(session, book, category_name, rank, timestamp) session.commit() except Exception as e: session.rollback() print(e) finally: naptime = (timestamp + HOUR - datetime.utcnow().replace(second=0, microsecond=0)).seconds time.sleep(naptime)
def admin_password(): if not check_login(session): abort(403) if request.method == "GET": if request.args.get('wrong') == "1": wrongpw = True else: wrongpw = False return render_template("pwchange.html", wrongpw=wrongpw) elif request.method == "POST": try: password = request.form['password'] password2 = request.form['password2'] except KeyError: abort(400) raise if password != password2: return redirect(url_for(".admin_password") + "?wrong=1") pwhash = pbkdf2_sha256.encrypt(password, rounds=200000, salt_size=16) db_session = db.get_session() db_session.query(db.Passwords).delete() db_session.commit() obj = db.Passwords(password=pwhash) db_session.add(obj) db_session.commit() session["login"] = False return redirect('/?pw=2')
def manage_create_site(): if not check_login(session): return redirect(url_for('.login')) if request.method == "GET": return render_template("create_site.html") else: try: pass # TODO take request.form['...'] data here except KeyError: abort(400) db_session = db.get_session() obj = db.Sites( # TODO ... ) db_session.add(obj) db_session.commit() # TODO add an uploaded icon here """ try: if request.form['img_list'] != "": images = request.form['img_list'].split(";") for image in images: pic_obj = db.Pictures(shoot=obj, filename=image) db_session.add(pic_obj) db_session.commit() except KeyError: pass """ return redirect(url_for('.manage_site', name=obj.name))
def admin_createshoot(): if not check_login(session): abort(403) if request.method == "GET": return render_template("create_shoot.html") elif request.method == "POST": try: description = request.form['description'] limit = request.form['limit'] except KeyError: abort(400) raise link = generate_string() db_session = db.get_session() obj = db.Shoot(link=link, description=description, max_images=limit, done=False, creation=datetime.now()) db_session.add(obj) db_session.commit() try: if request.form['img_list'] != "": images = request.form['img_list'].split(";") for image in images: pic_obj = db.Pictures(shoot=obj, filename=image) db_session.add(pic_obj) db_session.commit() except KeyError: pass return redirect(url_for('.admin_shoot_overview', shoot_link=link))
def clear_databases(): mg = get_mongo() mg.raw.delete_many({}) with get_session() as session: session.execute('DELETE FROM mpi_vectors WHERE 1=1;') session.commit()
def check_name(name, email=None): session = get_session() names = session.query(Name).filter_by(name=name) if list(names): user_name = names[0] return user_name.email == email return True
def save_game(game, training): session = get_session() db_game = DBGame(game.type, game.start_deck, game.seed) name_to_player_map = {} player_to_score_map = {} last_elapsed_time = 0 for (board, tau) in zip(game.boards, game.taus): (elapsed_time, total_taus, player, cards) = tau if player in name_to_player_map: db_player = name_to_player_map[player] player_to_score_map[player] += 1 else: db_player = get_or_create_dbplayer(session, player) player_to_score_map[player] = 1 name_to_player_map[db_player.name] = db_player state = State(elapsed_time, board, cards, db_player) db_game.states.append(state) last_elapsed_time = elapsed_time players = name_to_player_map.values() team = get_or_create_team(session, players) score = Score(last_elapsed_time, datetime.datetime.utcnow(), db_game, players, team, player_to_score_map) if training: score.invalid = True session.add(score) session.add(db_game) session.commit() return (db_game, score)
def train(): print('fetch and prepare data...') xs, ys, ts = [], [], [] with get_session() as session: for entry in session.query(FacebookRetinaEntry): sample_retina = np.zeros(128 * 128, dtype=int) sample_retina[entry.data['retina']] = 1 xs.append(sample_retina) ys.append(entry.slug) ts.append(entry.data['tokens']) xs, ys = np.array(xs), np.array(ys) x_train, x_test, y_train, y_test = train_test_split(xs, ys, test_size=0.33, random_state=42) print('... done;') print('training classifier...') clf = LinearSVC() clf.fit(x_train, y_train) predicted = clf.predict(x_test) print(metrics.classification_report(y_test, predicted)) print('done') with open(PICKLE_FILE_PATH, 'wb') as pickle_file: pickle.dump(clf, pickle_file)
def admin_user_create(): if not is_admin(session): abort(403) if request.method == "GET": return render_template("admin_create_user.html") else: try: username = request.form['username'] password = request.form['password'] make_admin = False try: make_admin = request.form['admin'] make_admin = make_admin == "on" except KeyError: pass db_session = db.get_session() pwhash = pbkdf2_sha256.encrypt(password, rounds=200000, salt_size=16) user_obj = db.Users(username=username, password=pwhash, admin=make_admin) db_session.add(user_obj) db_session.commit() return redirect(url_for('.admin_user_detail', user=username)) except KeyError: abort(400)
def admin(): if not is_admin(session): abort(403) db_session = db.get_session() users = db_session.query(db.Users).all() sites = db_session.query(db.Sites).all() return render_template("admin.html", users=users, sites=sites)
def login_page(): """User login page.""" # Bypass Login screen if user is logged in if current_user.is_authenticated: return redirect("/loggedin") login_form = LoginForm(request.form) # POST: Create user and redirect them to the app if request.method == 'POST': if login_form.validate(): # Get Form Fields email = request.form.get('email') password = request.form.get('password') # Validate Login Attempt session = get_session() user = session.query(User).filter_by(email=email).first() if user: if user.check_password(password=password): login_user(user) return redirect('/') flash('Invalid username/password combination') return redirect('/login') # GET: Serve Log-in page return render_template('login.html', form=LoginForm(), title='Log in | Flask-Login Tutorial.', template='login-page', body="Log in with your User account.")
def signup_page(): """User sign-up page.""" signup_form = SignupForm(request.form) # POST: Sign user in if request.method == 'POST': if signup_form.validate(): # Get Form Fields name = request.form.get('name') email = request.form.get('email') password = request.form.get('password') session = get_session() existing_user = session.query(User).filter_by(email=email).first() if existing_user is None: user = User(name=name, email=email, password=generate_password_hash(password, method='sha256')) session.add(user) session.commit() login_user(user) return redirect('/') flash('A user already exists with that email address.') return redirect('/login') # GET: Serve Sign-up page return render_template('/signup.html', title='Create an Account | Flask-Login Tutorial.', form=SignupForm(), template='signup-page', body="Sign up for a user account.")
def add_to_session(dict, session_id=None): if session_id is None: session_id = get_session_id() _, data = db.get_session(session_id)#vracanje do sada odabranih podataka for key, value in dict.items(): data[key] = value db.replace_session(session_id, data)
def get_session_data(): session_id = get_session_id() if session_id: _, data = db.get_session(session_id) else: data = None return data
def gen_session_code(): while True: session_code = "%s %s" % (random.randint(100, 1000), random.randint(100, 1000)) if not db.get_session(session_code): break db.create_session(session_code) return jsonify({"game_code": session_code})
def parse(soup): mata_data = soup.findAll('div', {'class': 'empInfo'}) link = soup.find('li', {'class': 'next'}) for company in mata_data: name = company.find('div', {'class': 'margBotXs'}).text website = company.find('span', {'class': 'subtle'}) web = '' if website != None: web = website.text logo = company.find('span', {'class': 'sqLogo'}) logo_url = None try: logo_url = logo.find('img')['src'] except Exception as error: pass try: db_session = get_session() if not db_session.query(Company).filter( Company.name == name).all(): new_company = Company(name=name, logo=logo_url, website=web) db_session.add(new_company) db_session.commit() except Exception as error: print('error in database', error) try: next_link = 'https://www.glassdoor.co.in' + link.find('a')['href'] company_data(next_link) except Exception as error: print("next page's link not found", error)
def admin_user_detail(user): if not is_admin(session): abort(403) db_session = db.get_session() try: user_obj = db_session.query(db.Users).filter_by(username=user).one() except NoResultFound: abort(404) raise if request.method == "GET": return render_template("admin_user_detail.html", user=user_obj) else: username = request.form['username'] password = request.form['password'] make_admin = False try: make_admin = request.form['admin'] make_admin = make_admin == "on" except KeyError: pass if password != "": # If the password is empty it has not been changed pwhash = pbkdf2_sha256.encrypt(password, rounds=200000, salt_size=16) user_obj.password = pwhash if username != user: # If the username has been changed user_obj.username = username if make_admin != user_obj.admin: user_obj.admin = make_admin db_session.commit() # TODO add a success message return redirect(url_for('.admin_user_detail', user=username))
def get(self,app_id): sess = db.get_session() db_app = sess.query(db.Applications).filter_by(id = app_id).first() if not db_app is None: app_view = {'id':str(db_app.id), 'base':str(db_app.base.name)} else: app_view = None self.write(json.dumps(app_view))
def get_graph_data(player): session = get_session() ret = {} for game_type in game_types: time_limit = (600 if game_type == '3tau' else 2700) raw_data = session.query(Score).filter(Score.elapsed_time < time_limit).filter(Score.date > datetime.datetime(year=2012, month=1, day=2)).filter(Score.players.any(name=player)).filter_by(num_players=1,game_type=game_type).filter(Score.invalid == False).order_by(asc(Score.date)) ret[game_type] = raw_data return ret
def list_people(id=None): session = db.get_session() if id is None: people = session.query(schema.Person).all() else: people = session.query(schema.Person).filter(schema.Person.id == id) return render_template("person.tpl", people=people)
def sites_json(): query = request.args.get('q', '') if not query: abort(400) sites = db.get_session().query(Site).filter(Site.named_like(query)) results = json.dumps([ {'name': s.fullname} for s in sites ]) return Response(results, mimetype='application/json')
def main(): print "# generated by generate_preset_decks.py" decks = {} tau_lists = {} target_lists = {} wrong_property_lists = {} seeds = {} for game_type in map(lambda x: x[0], GAME_TYPE_INFO): session = get_session() score = session.query(Score).filter_by(game_type=game_type).order_by(desc(Score.date)).first() try: deck = list(reversed(map(tuple, score.game.deck))) except: deck = [] need_deck = not deck taus = [] targets = [] wrong_properties = [] for state in score.game.states: space = fingeo.get_space(game_type) targets.append(space.sum_cards(state.cards)) wrong_properties.append(get_wrong_property(space, state.cards)) taus.append(state.cards) if need_deck: for card in state.board: if card and not tuple(card) in deck: deck.append(tuple(card)) decks[game_type] = list(reversed(deck)) tau_lists[game_type] = taus target_lists[game_type] = list(reversed(targets)) wrong_property_lists[game_type] = list(reversed(wrong_properties)) seeds[game_type] = score.game.seed print "PRESET_DECKS = {" for (game_type, deck) in decks.items(): print "'%s' : %s," % (game_type, str(deck)) print "}" print "PRESET_TAUS = {" for (game_type, taus) in tau_lists.items(): print "'%s' : %s," % (game_type, str(taus)) print "}" print "PRESET_TARGETS = {" for (game_type, targets) in target_lists.items(): print "'%s' : %s," % (game_type, str(targets or None)) print "}" print "PRESET_WRONG_PROPERTIES = {" for (game_type, wrong_properties) in wrong_property_lists.items(): print "'%s' : %s," % (game_type, str(wrong_properties or None)) print "}" print "PRESET_SEEDS = {" for (game_type, seed) in seeds.items(): print "'%s' : %d," % (game_type, seed) print "}"
def resetview(username, key): db = get_session() timebarrier = datetime.now() - timedelta(days=1) activation = db.query(ActivationLink).filter(ActivationLink.username==username)\ .filter(ActivationLink.key==key)\ .filter(ActivationLink.created>=timebarrier) if not activation.count(): return redirect(url_for('error', e='Invalid reset link.')) user = activation[0].user return render_template('forgot.html', config=config, user=user, key=key)
def worker(): session = db.get_session() while not STOP: try: username = QUEUE.get() get(username, session) QUEUE.task_done() except Exception as e: logger.error(str(e)) session.rollback() session.close()
def auth(): try: user, passwd = request.authorization.username, request.authorization.password u = get_session().query(User).filter(User.username==user, User.access==True) if u.count() and u[0].password_verify(passwd): session['login'] = (user, passwd) return '' # 200 OK except: pass return Response('', 401, {'WWW-Authenticate': 'Basic realm="Login Required"'})
def _delete(cls, id): session = get_session() try: s = session.query(cls.model).filter(cls.model.id == id).one() except NoResultFound: return None, http.NO_CONTENT session.delete(s) session.commit() return None, http.ACCEPTED
def main(): s = get_session() for score in s.query(Score): if not score.player_scores().keys(): player_scores = {} for state in score.game.states: if state.player.name in player_scores: player_scores[state.player.name] += 1 else: player_scores[state.player.name] = 1 score.player_scores_json = json.dumps(player_scores) s.add(score) s.commit()
def get(self,app_id): sess = db.get_session() events = [] for event in sess.query(db.Events).filter_by(applicationId = app_id).order_by(db.Events.time.desc()).all()[:50]: rez = event.__dict__ del rez['_sa_instance_state'] rez['time'] = rez['time'].isoformat() #rez['comment'] = rez['comment'].decode('utf-8') #rez = str(rez) #rez['comment'] = rez['comment'].replace('\n','</p><p>') rez['commentlines'] = rez['comment'].splitlines() events.append(rez) self.write(json.dumps(events))
def add_person(): session = db.get_session() new_person = schema.Person( first_name=request.form['fname'], last_name=request.form['lname'] ) session.add(new_person) session.commit() return 'Okay maaaade a person! {} {} has been saved'.format( new_person.first_name, new_person.last_name )
def get_all_high_games(num_results, leaderboard_type, players, conjunction): session = get_session() ret = defaultdict(dict) for (number, game_type) in get_numbers(leaderboard_type, players): query = simple_query(leaderboard_type, number, game_type, session.query(Score)).filter(Score.elapsed_time < 3600) if players: query = filter_for_players(players, query).group_by(Score.id) if conjunction == "and": query = and_query(players, query) results = list(query.from_self(Score, func.count().label("num_games"), func.sum(Score.elapsed_time)).group_by(Score.team_id).order_by('num_games desc').limit(num_results)) if results: ret[game_type][number] = results return ret
def whatis(term): """ Try to look up a term; returns a list of 0 or more definitions """ session = db.get_session() definitions = ( session .query(Definition) .filter(Definition.term == term) .all() ) return definitions
def define(term, definition): """Define a term""" session = db.get_session() new_definition = Definition(term=term, definition=definition) try: session.add(new_definition) session.commit() return True, term, definition except: import sys e = sys.exc_info()[0] return False, e, None