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 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 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 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
