def echo_endpoint():
try:
#print(type(request.data))
#print(request.data)
image_bytes = construct_image(raw_bytes=request.data)
token = get_token(request)
users.get_user(token=token)
except classes.UserAuthenticationError as bad_token_error:
return error_response_unauthorized(message=str(bad_token_error))
except classes.UserNotFoundError:
return error_response_unauthorized(
message='No user associated with your token.')
except classes.ImageNotFoundError:
return error_response_bad_request(
message='Please include an image in your request body.')
try:
request_id = make_request_in_queue(image=image_bytes, queue='echo')
request_done = wait_for_request_done(request_id)
except classes.AppServerTimeoutError:
return error_response_service_unavailable(
message='Request timeout. Please try again.')
except Exception as e:
print(e)
return error_response_internal_server_error(
message='Error during echo.')
return request_done.results
def modifyuser(id):
if "user_id" not in session:
return redirect("/")
if session["role"] != "admin":
return render_template(
"error.html",
message="Sinulla ei ole oikeuksia tälle sivulle.")
roles = users.get_roles()
if request.method == "GET":
user = users.get_user(id)
return render_template(
"modifyuser.html",
user=user,
roles=roles)
if request.method == "POST":
if session["csrf_token"] != request.form["csrf_token"]:
abort(403)
if users.update_user(request.form):
user = users.get_user(id)
return render_template(
"modifyuser.html",
user=user,
roles=roles,
message="Käyttäjätiedot päivitetty onnistuneesti!")
else:
return render_template(
"error.html",
message="Käyttäjätietojen päivitys epäonnistui.")
def GET(self):
user = users.get_user()['username']
access = users.get_user()['access']
if access > 1:
players = mongo.playerList(access)
sizes = mongo.sectorSizes()
hw = mongo.homeworldList()
return render('dbstuff.html', players = players, sizes = sizes, hw = hw)
else:
return web.seeother('/')
def GET(self):
user = users.get_user()['username']
access = users.get_user()['access']
if access >= 1:
players = mongo.playerList(access)
alliance = mongo.alliances(access)
score_time = mongo.scoreTime()
sector_time = mongo.sectorTime()
return render('intelViewer.html', players = players, alliances = alliance, score_time = score_time, sector_time = sector_time, access = access)
else:
return web.seeother('/')
def GET(self):
st = time_stamp()
user = users.get_user()['username']
access = users.get_user()['access']
if access >= 3:
info = ""
db.users.update({'username' : user},{"$push" :{'updates' : {'time' : st, 'action' : "View Users in Admin", 'info' : info}}})
uws_users = mongo.userControl()
return render('admin.html', access = uws_users)
else:
return web.seeother('/')
def GET(self):
user = users.get_user()['username']
access = users.get_user()['access']
if access > 2:
map = db.map_time.find().sort('utime', -1).limit(1)
for a in map:
last_map = a['utime']
print last_map
return render('upload.html', last_map = last_map)
else:
return web.seeother('/')
def POST(self):
st = time_stamp()
user = users.get_user()['username']
access = users.get_user()['access']
if access >= 3:
uws_users = mongo.userControl()
post = web.input(_method='POST')
new_access_level = int(post['lvl'])
update_user = post['user']
user_updated = db.users.find_one({'_id' : ObjectId(post['user'])})['username']
info = "%s updated to lvl %d" %(user_updated, new_access_level)
db.users.update({'username' : user},{"$push" :{'updates' : {'time' : st, 'action' : "Update Users in Admin", 'info' : info}}})
new_access = mongo.updateAccess(update_user, new_access_level)
return render('admin.html', access = uws_users)
def add_server():
user, err = users.get_user()
if not user.exists:
print('User [{}] does not exist'.format(user.username))
input()
return
server = get_server()
get_groups(server)
ret, err = user.add_server(server)
if not ret:
print(err)
input()
return
ret, err = user.write_to_db()
if err:
print('Error adding server: {}'.format(err))
else:
print('Server '+\
'[{}] was successfully added!'.format(server["servername"]))
input()
def owned_course(request):
new_url=connections()
url = "http://%s/course/list" % (new_url)
email=request.session['email']
general_list=get_user(request, email)
print general_list
owned_list=general_list.get('own')
print owned_list
if owned_list is None:
return render_to_response('home.html',{'error':"sorry you had not uploaded any course yet"})
data={}
combined_data={}
lists=[]
for list in owned_list:
print "this is list %s"%list
data=get_course(request, list)
print data
old_data={"courseID":list}
# appending courseId
new_data = dict(data.items() + old_data.items())
print "newly listed and updated data %s"%new_data
lists.append(new_data)
#combined_data.update(data)
#print data
print "New data %s"%lists
return render_to_response('course_edit.html',{'data':lists})
def POST(self, username):
post = web.input(_method='POST')
errors = {}
user = users.get_user()
contact = db.users.find_one({'username':username})
forms.validate(errors, 'username', lang.NO_CONTACT_FOUND, lambda c: bool(c), (contact,))
if contact:
forms.validate(errors, 'username', lang.ALREADY_CONNECTED(contact['username']), lambda u, c: ('contacts' not in u) or (c not in u['contacts']), (user, contact))
forms.validate(errors, 'username', lang.CANT_CONNECT_TO_SELF, lambda u, c: c!=u, (user, contact))
if contact and not errors:
#Add to the user's contacts
if 'contacts' not in user or not user['contacts']:
user['contacts'] = []
user['contacts'].append(DBRef('users',contact['_id']))
#Add user to the other persons contacts
if 'contacts' not in contact or not contact['contacts']:
contact['contacts'] = []
contact['contacts'].append(DBRef('users',user['_id']))
#Save them both
db.users.save(user)
db.users.save(contact)
return render('/users/profile.html', profile=contact, errors=errors, connected=self.connected(contact))
def GET(self):
u_id = users.get_user()['_id']
print u_id
fleet = db.player_items.find({'u_id': u_id, 'item': "Ship"})
ship_id = []
name = []
health = []
type = []
ship_fleet = []
list_fleet = []
count = 0
list = 0
for x in fleet:
ship_id.append(x['_id'])
name.append(x['name'])
type.append(x['type'])
health.append(x['health'])
ship_fleet.append(x['fleet'])
if (x['fleet'] in list_fleet) == False:
list_fleet.append(x['fleet'])
list += 1
count += 1
return render('fleet.html',
name=name,
type=type,
health=health,
count=count,
list=list,
list_fleet=list_fleet,
ship_fleet=ship_fleet,
ship_id=ship_id)
def test_get_one_user(self, mock_get_users):
"""
Test for getting one user using their userID
Demonstrates mocking third party functions
"""
users = [{
'phone': '514-794-6957',
'first_name': 'Brant',
'last_name': 'Mekhi',
'id': 0
}, {
'phone': '772-370-0117',
'first_name': 'Thalia',
'last_name': 'Kenyatta',
'id': 1
}, {
'phone': '176-290-7637',
'first_name': 'Destin',
'last_name': 'Soledad',
'id': 2
}]
mock_get_users.return_value = Mock()
mock_get_users.return_value.json.return_value = users
user = get_user(2)
self.assertEqual(user, users[2])
def assert_broker():
identity = get_jwt_identity()
current_user = get_user(identity, brokers)
if not current_user:
raise Unauthorized(
"Access denied, you have to be a broker to read this")
return current_user
def update_user(user_id):
if not request.is_json():
return 'Request type is not json'
json_data = request.get_json()
if users.update_user(user_id, json_data):
return 'User not updated'
return users.get_user(user_id)
def single_user_endpoint(name):
try:
user = users.get_user(name=name)
except classes.UserNotFoundError as e:
return error_response_not_found(message=str(e))
return success_response_with_json(user=user)
def add_recipe(name, ingredients, quantities, steps, image):
username = users.get_user()
if username is None:
return False
sql = "INSERT INTO Recipes (name) VALUES (:name) RETURNING id"
result = db.session.execute(sql, {"name":name})
recipe_id = result.fetchone()[0]
for index, ingredient in enumerate(ingredients):
sql = "SELECT id FROM Ingredients WHERE name=:name"
result = db.session.execute(sql, {"name":ingredient})
if result.rowcount == 0:
sql = "INSERT INTO Ingredients (name) VALUES (:name) RETURNING id"
result = db.session.execute(sql, {"name":ingredient})
ingredient_id = result.fetchone()[0]
sql = "INSERT INTO RecipeIngredients (recipe_id, ingredient_id, quantity) VALUES (:recipe_id, :ingredient_id, :quantity)"
db.session.execute(sql, {"recipe_id":recipe_id, "ingredient_id":ingredient_id, "quantity":quantities[index]})
for index, step in enumerate(steps):
sql = "INSERT INTO Steps (recipe_id, step, instructions) VALUES (:recipe_id, :step, :instruction)"
order_number = index + 1
db.session.execute(sql, {"recipe_id":recipe_id, "step":order_number, "instruction":step})
if image is not None:
image_data = image.read()
sql = "INSERT INTO Images (recipe_id, image) VALUES (:recipe_id, :image)"
db.session.execute(sql, {"recipe_id":recipe_id, "image":image_data})
db.session.commit()
return True
def on_post(self, req, resp):
doc = req.context['doc']
lat = doc['lat']
lon = doc['lon']
date_in = datetime.datetime.utcnow()
if lat and lon:
user = get_user(req, resp)
if lon >= -79.8921061:
if lon <= -79.8833942:
if lat <= 36.0984408:
if lat >= 36.0903956:
signin = Signin(date_in=date_in, user=user)
user.signedin = True
Session.add(signin)
Session.commit()
resp.status = falcon.HTTP_201
resp.location = '/signins/%s' % (signin.id)
req.context['result'] = {"action": "sign in", "result": "success"}
else:
resp.status = falcon.HTTP_409
req.context['result'] = {"action": "sign in", "result": "failure"}
else:
resp.status = falcon.HTTP_409
req.context['result'] = {"action": "sign in", "result": "failure"}
def on_post(self, req, resp):
doc = req.context['doc']
title = doc['title']
description = doc['description']
from_date = doc['from_date']
to_date = doc['to_date']
from_date_datetime = datetime.datetime.strptime(from_date, "%Y-%m-%d")
to_date_datetime = datetime.datetime.strptime(to_date, "%Y-%m-%d")
user = get_user(req, resp)
event = Event(from_date=from_date_datetime, to_date=to_date_datetime, title=title,
description=description, user=user)
Session.add(event)
Session.commit()
resp.status = falcon.HTTP_201
req.context['result'] = {"action": "add event", "result": "success",
"event": {
'id': event.id,
'from_date': from_date,
'to_date': to_date,
'title': event.title,
'description': event.description
}
}
def test_request_response_with_decorator(self, mock_get):
mockuser = [{
'phone': '514-794-6957',
'first_name': 'Brant',
'last_name': 'Mekhi',
'id': 0
}, {
'phone': '772-370-0117',
'first_name': 'Thalia',
'last_name': 'Kenyatta',
'id': 1
}, {
'phone': '176-290-7637',
'first_name': 'Destin',
'last_name': 'Soledad',
'id': 2
}]
# Mock status code of response.
mock_get.return_value.status_code = 200
mock_get.return_value.json.return_value = mockuser
response = get_users()
# filter to find user 2
user = get_user(2)
# Assert that the request-response cycle completed successfully.
self.assertEqual(response.status_code, 200)
self.assertEqual(response.json(), mockuser)
self.assertEqual(user, mockuser[2])
def create_user():
if request.is_json():
return 'Request type is not json'
json_data = request.get_json()
user_id = users.create_user(json_data)
if user_id is None:
return 'User not updated'
return users.get_user(user_id)
def get_user_and_account():
user = None
account = None
if g.user_id:
user = get_user(g.db, g.user_id)
if user:
account = get_account(g.db, user['account_id'])
return user, account
def hello(self,args):
self.name=args.strip()
self.user=get_user(self.name)
if not self.user:
self.error('unknownUser','Did you register at http://hearts.luispedro.org/?')
else:
self.cookie='chocolate_chip'
self.output('authQ %s %s' % (_Authentication_Method,self.cookie))
def add_members(obj, srcId, dstId): # delete all the existing members first (objects' creator should be here) for mbr in map(lambda m: m['id'], obj.get_members(dstSys, dstId)): obj.del_member(dstSys, dstId, mbr) # return an user_id in the destination system according to a given member dict from the source system usr = Users() uidByMember = lambda mbr: get_user(dstSys, usr.by_id(srcSys, mbr['id'])) for mbr in obj.get_members(srcSys, srcId): obj.add_member(dstSys, dstId, uidByMember(mbr), mbr['access_level'])
def get_user(userId):
if userId is None:
return False, None
else:
oneUser = users.get_user(userId)
if oneUser is None:
return False, None
else:
return True, oneUser
def _deref_contacts(self):
user = users.get_user()
try:
user.update({'contacts': mongo_utils.deref_list(db, user['contacts'])})
except KeyError:
user['contacts'] = []
return user
def welcome(request):
cookie = request.COOKIES['name']
if cookie:
user_id, cookie_hash = cookie.split('|')
user = get_user(userid=user_id)
if user and user.hashed_pw == cookie_hash:
c = {'usr': user.username}
return render_template(request, 'welcome.html', context=c)
return redirect('/signup')
def run(self):
start_time = time.time()
pwd = get_user("zh")
self.login("18895379450", pwd)
# 从我的主页开始爬取
self.user_links.append("/people/bi-zhong-liang-33")
self.get_followings()
time_used = time.time() - start_time
print u"一共用时%s秒" % time_used
def POST(self):
post = web.input(_method='POST')
errors = {}
user = users.get_user()
mode = ''
#Get all the stuff we want from POST
if 'from_username' in post:
mode = 'from'
other_username = forms.get_or_add_error(post, '%s_username' % mode, errors, lang.NO_FIELD_SUPPLIED('username'))
else:
mode = 'to'
other_username = forms.get_or_add_error(post, '%s_username' % mode, errors, lang.NO_FIELD_SUPPLIED('username'))
value_pounds = forms.get_or_add_error(post, '%s_value_pounds' % mode, errors, lang.NO_FIELD_SUPPLIED('pounds value'))
value_pence = forms.get_or_add_error(post, '%s_value_pence' % mode, errors, lang.NO_FIELD_SUPPLIED('pence value'))
reason = forms.get_or_add_error(post, '%s_reason' % mode, errors, lang.NO_FIELD_SUPPLIED('reason'))
#Process and validate the amount
try:
if value_pounds.strip() == '':
value_pounds = 0
if value_pence.strip() == '':
value_pence = 0
value_pounds = int(value_pounds)
value_pence = int(value_pence)
if value_pounds < 0 or value_pence < 0:
raise Exception
if value_pounds != None and value_pence != None:
forms.validate(errors, '%s_value' % mode, lang.MUST_BE_GREATER_THAN_ZERO('Value'), lambda po,pe: (po+pe*100)>0, (value_pounds,value_pence))
except:
errors['%s_value' % mode] = lang.MUST_BE_POS_INTEGER('Pounds and pence')
#Validate the reason
forms.validate(errors, '%s_reason' % mode, lang.NO_FIELD_SUPPLIED('reason'), lambda r: bool(r), (reason,))
#Validate and get the other user
if other_username:
other_user = db.users.find_one({'username':other_username})
forms.validate(errors, '%s_username' % mode, lang.NO_CONTACT_FOUND, lambda u: bool(u), (other_user,))
#Now do the rendering
if not errors:
value = round((float(value_pounds)*100 + float(value_pence)) / 100.0, 2)
if mode == 'to':
from_user, to_user = user, other_user
else:
from_user, to_user = other_user, user
trans = db.transactions.save({'from_user': from_user['_id'], 'to_user': to_user['_id'], 'value':value, 'timestamp':time.time(), 'reason':reason})
return render('transfer.html', success=True, user=self._deref_contacts(), from_user=from_user, to_user=to_user, value="%.2f" % value, mode=mode)
else:
return render('transfer.html', errors=errors, user=self._deref_contacts())
def GET(self):
user = users.get_user()['username']
if user == "Xariec":
site_users = []
query = db.users.find()
for a in query:
site_users.append((a))
return render('xariec.html', site_users = site_users)
def create_timeline(user_id, name, description):
luser = users.get_user(user_id)
if luser is None:
# TODO(dasarathi): create error handling, throw exceptions?
return
timeline = Timeline(name=name, description=description, user_id=user_id)
timeline_key = timeline.put()
luser.timeline_ids.append(timeline_key.id())
return timeline_key.id()
def create_timeline(user_id, name, description):
luser = users.get_user(user_id)
if luser is None:
# TODO(dasarathi): create error handling, throw exceptions?
return
timeline = Timeline(name=name, description=description, user_id=user_id)
timeline_key = timeline.put()
luser.timeline_ids.append(timeline_key.id())
return timeline_key.id()
def get_user(userId):
if userId is None:
return False,None
else:
oneUser = users.get_user(userId)
if oneUser is None:
return False, None
else:
return True, oneUser
def format_transaction(db, t):
u = users.get_user()
to_user = None if u['_id'] == t['to_user'] else db.users.find_one(t['to_user'])
from_user = None if u['_id'] == t['from_user'] else db.users.find_one(t['from_user'])
t.update({'from_user':from_user, 'to_user':to_user, 'value':u'£%.2f' % t['value'], 'timestamp': time.strftime('%d %b %Y',time.localtime(t['timestamp']))})
return t
def render(uri, **kwargs):
if 'user' not in kwargs:
kwargs['user'] = users.get_user()
try:
template = lookup.get_template(uri)
output = template.render_unicode(**kwargs)
return output
except:
return mako.exceptions.html_error_template().render()
def login():
if request.method == 'POST':
username = request.form.get('username')
password = request.form.get('password')
user = users.get_user(username, password)
if user and user.is_authenticated():
login_user(user, remember=True)
return redirect(request.args.get("next") or '/')
return redirect('/login')
return render_template("login.html")
def render(uri, **kwargs):
if 'user' not in kwargs:
kwargs['user'] = users.get_user()
try:
template = lookup.get_template(uri)
output = template.render_unicode(**kwargs)
return output
except:
return mako.exceptions.html_error_template().render()
def user_quota_endpoint():
try:
token = get_token(request)
user = users.get_user(token=token)
except classes.UserAuthenticationError as bad_token_error:
return error_response_unauthorized(message=str(bad_token_error))
except classes.UserNotFoundError:
return error_response_unauthorized(
message='No user associated with the token <{}>.'.format(token))
return success_response_with_json(quota=user['quota'], tier=user['tier'])
def get_users(is_admin):
if is_admin:
names = get_user_names()
else:
names = []
names.append(current_user.name)
users = []
for name in names:
users.append((name, ",".join(get_user(name).groups)))
return users
def on_query_connections(data):
result = []
response = []
try:
result = (db.session.query(tables.Connections).filter(
(tables.Connections.user1_email == data["user_email"])
| (tables.Connections.user2_email == data["user_email"])).all())
db.session.close()
for connection in result:
if connection.user1_email == data["user_email"]:
connected_user = users.get_user(connection.user2_email)
if connected_user != None:
response.append(connected_user)
elif connection.user2_email == data["user_email"]:
connected_user = users.get_user(connection.user1_email)
if connected_user != None:
response.append(connected_user)
return response
except Exception as err:
print(err)
def on_new_connection(data):
try:
for connection in (db.session.query(tables.Connections).filter(
(tables.Connections.user1_email == data["user1_email"])
&
(tables.Connections.user2_email == data["user2_email"])).all()):
return users.get_user(data["user2_email"])
for connection in (db.session.query(tables.Connections).filter(
(tables.Connections.user1_email == data["user2_email"])
&
(tables.Connections.user2_email == data["user1_email"])).all()):
return users.get_user(data["user2_email"])
db.session.add(
tables.Connections(data["user1_email"], data["user2_email"]))
db.session.commit()
db.session.close()
return users.get_user(data["user2_email"])
except:
return {"success": False}
def main():
# get new message from queue
events = queue.get_queue('IngressQueue')
for event in events:
d = event.get_body()
d = json.loads(d)
uid = d['from']
message = d['message']
# lookup user
try:
curr_user = users.get_user(uid)
except ItemNotFound:
curr_user = users.EndUser(uid)
curr_user.write()
print curr_user
print curr_user.last_question
# process question
if curr_user.last_question is None:
send_first_question(uid, event, curr_user)
break
else:
question = questions.get_question(curr_user.last_question)
for q, v in question.answers.iteritems():
v_json = json.loads(v)
print v[1].lower()
if message.lower() == v_json.values()[0].lower():
print "response match found"
next_question_id = json.loads(question.child_questions[q])
print next_question_id.values()[0]
# create response message & publish to queue
next_question = questions.get_question(
next_question_id.values()[0])
queue.put_queue(
json.dumps({
'to': uid,
'message': next_question.qstring
}), 'EgressQueue')
queue.delete_from_queue(event, 'IngressQueue')
else:
print "unable to find a response match"
# invalid response
queue.put_queue(
json.dumps({
'to': uid,
'message': "Sorry, that wasn't a valid response"
}), 'EgressQueue')
queue.delete_from_queue(event, 'IngressQueue')
break
def edit_user(id):
if users.is_admin() or users.user_id() == id:
form = EditInfoForm(request.form)
user = users.get_user(id)
if players.is_player(id):
player_id = players.get_player_id(id)
player = players.get_player(player_id[0])
return render_template("edit_user.html", user=user, player=player, form=form)
else:
return render_template("edit_user.html", user=user, form=form)
else:
return render_template("error.html", message="Ei oikeutta")
def handle_loc(message):
check_user(message)
cid = message.chat.id
uid = message.from_user.id
user = users.get_user(uid)
bot.send_message(cid,
'Мы получили геолокацию',
reply_markup=global_markup)
user.location = message.location
user.is_have_location = True
users.save_users()
def POST(self):
u_id = users.get_user()['_id']
post = web.input(_method='POST')
try:
button = post['button']
except:
print post
if button:
people = web_actions.Population()
single = people.getOnePersonnel(button, u_id)
button = people.getAllPersonnel(u_id)[1]
print single
return render('personnel.html', button=button, single=single)
def rate(recipe_id, rating):
username = users.get_user()
if username is None:
return False
user_id = users.get_id()
sql = "INSERT INTO Ratings(recipe_id, rating, user_id) VALUES (:recipe_id, :rating, :user_id)"
db.session.execute(sql, {
"recipe_id": recipe_id,
"rating": rating,
"user_id": user_id
})
db.session.commit()
return True
def post(self):
"""
Refresh access token
:raises Unauthorized: When JWT identity is invalid
"""
current_user = get_user(get_jwt_identity(), everyone)
if not current_user:
raise Unauthorized("Invalid user")
ret = {
'access_token': create_access_token(identity=current_user),
}
return ret
def get_rating_status(recipe_id):
username = users.get_user()
if username is None:
return True
user_id = users.get_id()
sql = "SELECT COUNT(*) FROM Ratings WHERE recipe_id=:recipe_id AND user_id=:user_id"
result = db.session.execute(sql, {
"recipe_id": recipe_id,
"user_id": user_id
})
count = result.fetchone()[0]
if count:
return True
return False
def login(request):
if request.method == 'GET':
return render_template(request, 'login.html')
elif request.method == 'POST':
usr = request.POST['username']
pw = request.POST['password']
user = get_user(username=usr)
if user:
hashed = hash_password(pw, salt=user.salt)[0]
if hashed == user.hashed_pw:
return successful_login(request, user)
else:
c = {'error': 'invalid login'}
return render_template(request, 'login.html', context=c)
def users_route(user_id=None):
if request.method == 'POST':
first_name = utils.get_field(request, 'first_name', required=True)
last_name = utils.get_field(request, 'last_name', required=True)
email = utils.get_field(request, 'email', required=True)
password = utils.get_field(request, 'password')
fb_id = utils.get_field(request, 'fb_id')
return users.new_user(first_name, last_name, email, password, fb_id)
if user_id is None:
return users.get_all_users()
return users.get_user(user_id)
def post(self):
"""
Perform a login to access restricted API endpoints.
:raises BadCredentials: In case of invalid credentials.
"""
email = api.payload["email"]
password = api.payload["password"]
if not check_user(email, password):
raise BadCredentials()
user = get_user(email, everyone)
return generate_login_response(user)
def main():
# get new message from queue
events = queue.get_queue('IngressQueue')
for event in events:
d = event.get_body()
d = json.loads(d)
uid = d['from']
message = d['message']
# lookup user
try:
curr_user = users.get_user(uid)
except ItemNotFound:
curr_user = users.EndUser(uid)
curr_user.write()
print curr_user
print curr_user.last_question
# process question
if curr_user.last_question is None:
send_first_question(uid, event, curr_user)
break
else:
question = questions.get_question(curr_user.last_question)
for q, v in question.answers.iteritems():
v_json = json.loads(v)
print v[1].lower()
if message.lower() == v_json.values()[0].lower():
print "response match found"
next_question_id = json.loads(question.child_questions[q])
print next_question_id.values()[0]
# create response message & publish to queue
next_question = questions.get_question(next_question_id.values()[0])
queue.put_queue(json.dumps({'to': uid,
'message': next_question.qstring}), 'EgressQueue')
queue.delete_from_queue(event, 'IngressQueue')
else:
print "unable to find a response match"
# invalid response
queue.put_queue(json.dumps({'to': uid,
'message': "Sorry, that wasn't a valid response"}), 'EgressQueue')
queue.delete_from_queue(event, 'IngressQueue')
break
def login():
"""Logs the user in."""
if g.user:
return redirect(url_for('hardware.control'))
error = None
if request.method == 'POST':
user = get_user('username', request.form['username'])
if user is None:
error = 'Invalid username'
elif not check_password_hash(user['password_hash'],
request.form['password']):
error = 'Invalid password'
else:
session['logged_in'] = True
flash('You were logged in')
session['user_id'] = user['user_id']
return redirect(url_for('hardware.control'))
return render_template('login.j2', error=error)
def on_get(self, req, resp):
user = get_user(req, resp)
if user.is_admin():
signins = Session.query(Signin).all()
else:
signins = Session.query(Signin).filter_by(user=user).all()
signins_json = []
for signin in signins:
date = signin.date_in.strftime("%Y-%m-%d")
signins_json.append({'id': signin.id, 'date': date})
req.context['result'] = {
'action': 'get signins',
'result': 'success',
'signins': signins_json
}
resp.status = falcon.HTTP_200
def add_points():
while True:
try:
r = urllib.request.urlopen("http://tmi.twitch.tv/group/user/"+cfg.CHANNEL_NAME+"/chatters")
except urllib.error.HTTPError as e:
print(e.code, e.reason)
continue
chattersJson = json.loads(r.read().decode("utf-8"))
for key in chattersJson['chatters']:
for name in chattersJson['chatters'][key]:
user = users.get_user(name)
user['points']+=cfg.PPM
if name.lower() == cfg.CHANNEL_NAME.lower():
user['status'] = 2
elif key!='viewers':
user['status'] = 1
else:
user['status'] = 0
users.update_user(user)
sleep(60)
def register():
"""Registers the user."""
# if g.user:
# return redirect(url_for('timeline'))
error = None
if request.method == 'POST':
if not request.form['username']:
error = 'You have to enter a username'
elif not request.form['email'] or \
'@' not in request.form['email']:
error = 'You have to enter a valid email address'
elif not request.form['password']:
error = 'You have to enter a password'
elif request.form['password'] != request.form['password2']:
error = 'The two passwords do not match'
elif get_user('username', request.form['username']) is not None:
error = 'The username is already taken'
else:
add_user(request.form['username'], request.form[
'password'], request.form['email'])
flash(
'You were successfully registered and can login now', 'success')
return redirect(url_for('login'))
return render_template('register.j2', error=error)
def on_get(self, req, resp):
user = get_user(req, resp)
events = Session.query(Event).all()
events_json = []
for event in events:
from_date = event.from_date.strftime("%Y-%m-%d")
to_date = event.to_date.strftime("%Y-%m-%d")
events_json.append({
'id': event.id,
'from_date': from_date,
'to_date': to_date,
'title': event.title,
'description': event.description
})
req.context['result'] = {
'action': 'get events',
'result': 'success',
'events': events_json
}
resp.status = falcon.HTTP_200
def enter_password(self, user):
self.driver.find_element(*LoginPageLocatars.PASSWORD).send_keys(users.get_user(user)["password"])
def enter_email(self, user):
self.driver.find_element(*LoginPageLocatars.EMAIL).send_keys(users.get_user(user)["email"])
def before_request():
g.user = None
if 'user_id' in session:
g.user = get_user('user_id', session['user_id'])
