def get_user(eid):
email, guid = (eid, None)[::'@' not in eid and -1 or 1]
if email:
result = User.by_email(email)
if not result:
return "Email available", 404
return 'Email in use', 200
return User.by_guid(guid)
def setUp(self):
self._db_path = os.path.join(
os.path.dirname(os.path.realpath(__file__)), 'test.db')
if os.path.exists(self._db_path):
os.remove(self._db_path)
self._db = PeerReviewDB('sqlite:///' + self._db_path, echo=False)
# define test records
self._test_users = [
User(id=0, login='******'),
User(id=1, login='******'),
User(id=2, login='******'),
]
self._test_tasks = [
Task(name='task0'),
Task(name='task1'),
Task(name='task2'),
]
self._test_user_tasks = [
UserTask(user=self._test_users[0],
task=self._test_tasks[0],
url='!',
status=TaskStatus.WAITING_REVIEW,
timestamp=0),
UserTask(user=self._test_users[0],
task=self._test_tasks[1],
url='@',
status=TaskStatus.COMPLETE,
timestamp=1),
UserTask(user=self._test_users[1],
task=self._test_tasks[0],
url='#',
status=TaskStatus.IN_WORK,
timestamp=0),
UserTask(user=self._test_users[2],
task=self._test_tasks[2],
url='^',
status=TaskStatus.COMPLETE,
timestamp=0),
]
self._test_reviews = [
Review(reviewer=self._test_users[0],
reviewed_task=self._test_user_tasks[2],
status=ReviewStatus.IN_WORK,
issue_url='$'),
Review(reviewer=self._test_users[1],
reviewed_task=self._test_user_tasks[1],
status=ReviewStatus.CLOSED,
issue_url='%'),
]
def setup():
global user_data
user01 = User(
userID="1000",
name="Roxie Joddens",
email="*****@*****.**",
phone="+358-119-977-5220",
friends=[],
)
user02 = User(
userID="1001",
name="Aundrea Izard",
email="*****@*****.**",
phone="+4084687956",
friends=[],
)
user03 = User(
userID="1002",
name="Teddy Bolan",
email="*****@*****.**",
phone="+4084689120",
friends=[],
)
user04 = User(
userID="1003",
name="Avril Joyson",
email="*****@*****.**",
phone="+4086884546",
friends=[],
)
user01.friends.append(user02)
user01.friends.append(user04)
user02.friends.append(user04)
user02.friends.append(user03)
user03.friends.append(user02)
user_data.append(user01)
user_data.append(user02)
user_data.append(user03)
user_data.append(user04)
def post(self):
user = User.get(users.get_current_user())
if not user.superuser:
self.redirect('/invite',
error="Must be an admin to edit configuration.")
return
err = []
msg = []
flags = {}
for name in config.keys():
v = self.request.get('config_%s' % name)
if v != "":
logging.info("Updating %s: %s" % (name, v))
flags[name] = Config.update(name, v)
if flags[name] == True:
config[name] = v
elif flags[name] is None:
err.append("Failed to update %s." % name)
else:
Config.query(Config.name==name).get().key.delete()
del(config[name])
msg.append("'%s' deleted." % name)
logging.info("Deleted key '%s'." % name)
new_name = self.request.get('new_name')
if new_name:
value = self.request.get('new_value')
logging.info("New config key %s: %s" % (new_name, value))
Config(name=new_name, value=value).put()
flags[new_name] = True
config[new_name] = value
self.get(error=", ".join(err), msg=", ".join(msg), flags=flags)
def get(self):
days = defaultdict(dict)
for gn in Gamenight.future(10):
days[gn.date]['date'] = gn.date
days[gn.date]['scheduled'] = True
days[gn.date]['status'] = gn.status
days[gn.date]['owner'] = gn.owner
days[gn.date]['time'] = gn.time
days[gn.date]['where'] = gn.location
invitations = Invitation.query(Invitation.date >= Utils.now()).\
order(Invitation.date).iter()
for invite in invitations:
if not days[invite.date].get('invitations'):
days[invite.date]['date'] = invite.date
days[invite.date]['invitations'] = []
days[invite.date]['invitations'].append(invite)
day_sorter = lambda x: x.get('date')
template_values = { 'days': sorted(days.values(), key=day_sorter) }
current_user = users.get_current_user()
if current_user:
user = User.get(users.get_current_user())
template_values.update({
'logout': users.create_logout_url('/'),
'user': user,
})
template = JINJA_ENVIRONMNT.get_template('schedule.html')
self.response.write(template.render(template_values))
def create_user(login_session):
new_user = User(username=login_session['username'],
email=login_session['email'])
session.add(new_user)
session.commit()
user = session.query(User).filter_by(email=login_session['email']).first()
return user.id
def get(self):
days = defaultdict(dict)
for gn in Gamenight.future(10):
days[gn.date]['date'] = gn.date
days[gn.date]['scheduled'] = True
days[gn.date]['status'] = gn.status
days[gn.date]['owner'] = gn.owner
days[gn.date]['time'] = gn.time
days[gn.date]['where'] = gn.location
invitations = Invitation.query(Invitation.date >= Utils.now()).\
order(Invitation.date).iter()
for invite in invitations:
if not days[invite.date].get('invitations'):
days[invite.date]['date'] = invite.date
days[invite.date]['invitations'] = []
days[invite.date]['invitations'].append(invite)
day_sorter = lambda x: x.get('date')
template_values = { 'days': sorted(days.values(), key=day_sorter) }
current_user = users.get_current_user()
if current_user:
user = User.get(users.get_current_user())
template_values.update({
'logout': users.create_logout_url('/'),
'user': user,
})
template = JINJA_ENVIRONMNT.get_template('schedule.html')
self.response.write(template.render(template_values))
def post(self):
user = User.get(users.get_current_user())
if not user.superuser:
self.redirect('/invite',
error="Must be an admin to edit configuration.")
return
err = []
msg = []
flags = {}
for name in config.keys():
v = self.request.get('config_%s' % name)
if v != "":
logging.info("Updating %s: %s" % (name, v))
flags[name] = Config.update(name, v)
if flags[name] == True:
config[name] = v
elif flags[name] is None:
err.append("Failed to update %s." % name)
else:
Config.query(Config.name==name).get().key.delete()
del(config[name])
msg.append("'%s' deleted." % name)
logging.info("Deleted key '%s'." % name)
new_name = self.request.get('new_name')
if new_name:
value = self.request.get('new_value')
logging.info("New config key %s: %s" % (new_name, value))
Config(name=new_name, value=value).put()
flags[new_name] = True
config[new_name] = value
self.get(error=", ".join(err), msg=", ".join(msg), flags=flags)
def get(self, template_values={}, msg=None, error=None):
user = User.get(users.get_current_user())
if user.superuser:
invitations = Invitation.query(ancestor=Invitation.dummy())
else:
invitations = Invitation.query(Invitation.owner==user.key,
ancestor=Invitation.dummy())
invitations = invitations\
.filter(Invitation.date >= Utils.now())\
.order(Invitation.date).iter()
template_values.update({
'user': user,
'msg': msg,
'error': error,
'invitations': invitations,
'logout': users.create_logout_url('/'),
})
if not template_values.has_key('where') and user.location:
template_values['where'] = user.location
template = JINJA_ENVIRONMNT.get_template('invite.html')
self.response.write(template.render(template_values))
def test_hash_and_eq(self):
user0 = self._test_users[0]
identical_user = User(id=user0.id, login=user0.login)
self.assertIsNot(user0, identical_user)
self.assertEqual(user0, identical_user)
self.assertEqual(hash(user0), hash(identical_user))
def get(self):
init = db.GqlQuery("SELECT * FROM User WHERE username=:1",'testadmin')
if len(list(init)) == 0:
username = '******'
u = User(key_name = username,
username = username,
usernamehash = get_hash(username),
userrole = "admin",
password = str(get_hash('testadmin')),
email = '',
firstName = '',
lastName = '')
u.put()
else:
self.write('Application has already been initialized. Please contact an administrator')
def get(self, template_values={}, msg=None, error=None):
user = User.get(users.get_current_user())
if user.superuser:
invitations = Invitation.query(ancestor=Invitation.dummy())
else:
invitations = Invitation.query(Invitation.owner==user.key,
ancestor=Invitation.dummy())
invitations = invitations\
.filter(Invitation.date >= Utils.now())\
.order(Invitation.date).iter()
template_values.update({
'user': user,
'msg': msg,
'error': error,
'invitations': invitations,
'logout': users.create_logout_url('/'),
})
if not template_values.has_key('where') and user.location:
template_values['where'] = user.location
template = JINJA_ENVIRONMNT.get_template('invite.html')
self.response.write(template.render(template_values))
def login():
# For GET requests, display the login form; for POST, log in the current user by processing the form.
print(f"LOGGING IN\n", file=sys.stdout)
if current_user.is_authenticated:
return redirect(url_for("index"))
form = LoginForm(request.form)
if request.method == 'POST':
user = User.objects(email=request.form['email']).first()
print(f"user is {user}\n", file=sys.stdout)
if user is None or not user.check_password(bcrypt,
request.form['password']):
flash("Invalid username or password")
return redirect(url_for('login'))
login_user(user, remember=True)
user = {
'email': current_user.email,
'first_name': current_user.first_name,
'last_name': current_user.last_name,
}
if isinstance(current_user, CompanyUser):
user['company_name'] = current_user.company_name
else:
user['company_name'] = None
response = make_response(json.dumps(user))
response.status_code = 200
print(f"login {response}\n")
return response
context_dict = {"title": "Sign In", "form": form, "user": current_user}
return render_template('login.html', **context_dict)
def create_user(phone=None, name=None, start_session=True):
result = User.by_phone(phone)
if result:
raise BadRequest("Phone in use")
user = User()
user.value = name
user.save()
user.phone(phone)
token = gen_token(phone)
user.token(token)
if start_session:
init_session(user)
return [user.guid, token, phone]
def test_insert2(env):
with Transaction(env, write=True) as txn:
for i in range(100):
user = User()
user.oid = i + 10
user.name = 'Test {}'.format(i)
user.authid = 'test-{}'.format(i)
user.email = '{}@example.com'.format(user.authid)
for j in range(10):
user.ratings['test-rating-{}'.format(j)] = random.random()
_user = txn.users[user.oid]
if not _user:
txn.users[user.oid] = user
#txn.users_by_authid[user.authid] = user.oid
print('user stored', user, user.oid, user.authid)
else:
print('user loaded', _user, _user.oid, _user.authid)
def add_users():
return "nothing to add"
users = dbmock.format_mocked_users()
encrypted_password = lambda password_as_string: bcrypt.generate_password_hash(
password_as_string)
for u in users:
# Add user to database.
try:
new_user = User(email=u['email'],
first_name=u['first_name'],
last_name=u['last_name'],
password=encrypted_password(str(u['password'])),
is_verified=u["is_verified"])
new_user.save()
except:
print(f"Error. \n Couldn't add user {u}..\n")
print(f"Added {u['first_name'] + ' ' + u['last_name']}")
return str(User.objects[:10])
def registerUser(username, email, password, zipcode):
user = User(username=username, email=email, password=password, zipcode=zipcode)
try:
db.session.add(user)
db.session.commit()
return True
except Exception as e:
print e
db.session.rollback()
return False
def post(self):
user = User.get(users.get_current_user())
if user.superuser:
edit = self.request.get('edit', False)
if edit:
self.get(profile=edit, msg='Editing %s' % edit)
return
profile = User.lookup(self.request.get('pid'))
profile.superuser = self.request.get('admin')=='on'
else:
profile = user
profile.location = self.request.get('location')
profile.name = self.request.get('name')
profile.nag = self.request.get('nag')=='on'
profile.put()
self.get(msg='Profile updated!', profile=profile.key.id())
def login(phone=None, token=None):
user = User.by_phone(phone)
if not user:
raise NotFound('User not found')
if token != user.token().value:
raise Unauthorized()
init_session(user)
return user.guid
def post(self):
loggedInCheck(self)
adminCheck(self)
have_error = False
username = (self.request.get('username')).lower()
password = self.request.get('password')
verify = self.request.get('verify')
email = self.request.get('email')
firstName = self.request.get('firstName')
lastName = self.request.get('lastName')
params = dict(username = username,
email = email)
if username.lower() == "testadmin":
params['error_username'] = "******"
have_error = True
if not valid_username(username):
params['error_username'] = "******"
have_error = True
if not valid_password(password):
params['error_password'] = "******"
have_error = True
elif password != verify:
params['error_verify'] = "Your passwords didn't match."
have_error = True
if not valid_email(email):
params['error_email'] = "That's not a valid email."
have_error = True
if have_error:
self.render('templates/admin/adduser.html', **params)
else:
init = db.GqlQuery("SELECT * FROM User WHERE username=:1",username)
u = User(key_name = username,
username = username,
usernamehash = get_hash(username),
userrole = "nonadmin",
password = password,
email = email,
firstName = firstName,
lastName = lastName)
#u.put()
if len(list(init)) == 0:
u.put()
time.sleep(2)
self.redirect("/admin/adduser?e=false&u="+username)
else:
u.password = password #new password
u.userrole = init[0].userrole
u.put()
time.sleep(2)
self.redirect("/admin/adduser?e=true&u="+username)
def post(self):
user = User.get(users.get_current_user())
if user.superuser:
edit = self.request.get('edit', False)
if edit:
self.get(profile=edit, msg='Editing %s' % edit)
return
profile = User.lookup(self.request.get('pid'))
profile.superuser = self.request.get('admin')=='on'
else:
profile = user
profile.location = self.request.get('location')
profile.name = self.request.get('name')
profile.nag = self.request.get('nag')=='on'
profile.put()
self.get(msg='Profile updated!', profile=profile.key.id())
def createSampleUsers():
coords = ip2coords.getCoordsFromIP('131.151.88.173')
hobbyist = User(
username='******',
email='*****@*****.**',
password='******',
lat=coords[0],
lon=coords[1],
)
newbie = User(
username='******',
email='*****@*****.**',
password='******',
lat=coords[0],
lon=coords[1],
)
return hobbyist, newbie
def test_insert3(env):
oid = 4
with Transaction(env, write=True) as txn:
user = txn.users[oid]
if not user:
user = User()
user.oid = oid
user.name = 'Foobar Space'
user.authid = 'foobar'
user.email = '*****@*****.**'
user.birthday = datetime.date(1970, 5, 7)
user.is_friendly = True
user.tags = ['relaxed', 'beerfan']
user.referred_by = 1
txn.users[oid] = user
print('user stored', user)
else:
print('user loaded', user)
def mutate(self, info, username, small_app_id):
user = User.get_query(info).filter(
models.User.name == username).first()
assert user is not None, f"User '{username}' does not exist"
small_app = SmallApp.get_query(info).filter(
models.SmallApp.id == small_app_id).first()
assert small_app is not None, f"Small app '{small_app_id}' does not exist"
existing_privilege = (Privilege.get_query(info).filter(
models.SmallApp.id == small_app_id).first())
db_session.delete(existing_privilege)
db_session.commit()
return DeletePrivilege(ok=True)
def mutate(self, info, username, small_app_id, **kwargs):
user = User.get_query(info).filter(
models.User.name == username).first()
assert user is not None, f"User '{username}' does not exist"
small_app = SmallApp.get_query(info).filter(
models.SmallApp.id == small_app_id).first()
assert small_app is not None, f"Small app '{small_app_id}' does not exist"
new_comment = models.Comment(user=user, small_app=small_app, **kwargs)
db_session.add(new_comment)
db_session.commit()
return CreateComment(comment=new_comment, ok=True)
def dec(self, **kwargs):
sys_user = users.get_current_user()
if not sys_user:
self.redirect(users.create_login_url(self.request.uri))
return
user = User.lookup(sys_user.email())
if not user or not user.superuser:
self.redirect("/invite")
return
return func(self, **kwargs)
def register():
proto = request.get_json()
user = User.query.filter_by(username=proto["username"]).first()
if user:
return jsonify({"STATE": RegisterState.ALREADY.name})
elif not (proto["username"] and proto["password"]):
return jsonify({"STATE": RegisterState.EMPTY.name})
else:
user = User(username=proto["username"], password=proto["password"])
db.session.add(user)
db.session.commit()
return jsonify({"STATE": RegisterState.SUCCESS.name})
def login(email=None, password=None):
user = User.by_email(email)
if not user:
raise exceptions.NotFound('User not found')
hashed = user.password().value
if bcrypt.hashpw(password, hashed) != hashed:
raise exceptions.Unauthorized()
init_session(user)
return user.guid
def dec(self, **kwargs):
sys_user = users.get_current_user()
if not sys_user:
self.redirect(users.create_login_url(self.request.uri))
return
user = User.lookup(sys_user.email())
if not user or not user.superuser:
self.redirect("/invite")
return
return func(self, **kwargs)
def register():
json = request.json
email = json['email']
password = json['password']
user = User.query.filter_by(email=email).first()
if user:
raise InvalidApiUsage('User with same email id already exists', 409)
else:
user = User(email, password)
db.session.add(user)
db.session.commit()
return jsonify({'message': 'Account successfully created'})
def add_user(db_session, data):
user = User(username=data['username'],
name=data['name'],
password=data['password'],
score=0,
team=None)
try:
db_session.add(user)
db_session.commit()
return True, "Successfully added User {}".format(data["username"])
except Exception as e:
db_session.rollback()
return False, "Could not add User {}; already exists".format(
data["username"])
def register():
# IMPORTANT: Encrypt the password for the increased security.
encrypted_password = lambda password_as_string: bcrypt.generate_password_hash(
password_as_string)
if current_user.is_authenticated:
return redirect(url_for("index"))
form = RegistrationForm(request.form)
if request.method == "POST":
# Add user to database.
if request.form['company_name'] != "":
print(f"company user {form} \n")
try:
new_user = CompanyUser(
email=request.form['email'],
first_name=request.form['first_name'],
last_name=request.form['last_name'],
company_name=request.form['company_name'],
password=encrypted_password(request.form['password']))
new_user.save()
except Exception as e:
raise Exception\
(f"Error {e}. \n Couldn't add company user {new_user},\n with following registration form: {form}")
else:
print(f"normal user {form} \n")
try:
new_user = User(email=request.form['email'],
first_name=request.form['first_name'],
last_name=request.form['last_name'],
password=encrypted_password(
request.form['password']))
new_user.save()
except Exception as e:
raise Exception\
(f"Error {e}. \n Couldn't add user {new_user},\n with following registration form: {form}")
login_user(new_user, remember=True)
user = {
'email': new_user.email,
'first_name': new_user.first_name,
'last_name': new_user.last_name,
'company_name': new_user.last_name
}
response = make_response(json.dumps(user))
response.status_code = 200
print(f"register {response}\n")
return response
if request.args.get("email"):
form.email.data = request.args.get("email")
context_dict = {"title": "Register", "form": form, "user": current_user}
return render_template("register.html", **context_dict)
def test_insert3(env):
oid = 4
with Transaction(env, write=True) as txn:
user = txn.users[oid]
if not user:
user = User()
user.oid = oid
user.name = 'Foobar Space'
user.authid = 'foobar'
user.email = '*****@*****.**'
user.birthday = datetime.date(1970, 5, 7)
user.is_friendly = True
user.tags = ['relaxed', 'beerfan']
user.referred_by = 1
txn.users[oid] = user
print('user stored', user)
else:
print('user loaded', user)
def get(self):
# don't bother starting to nag before Tuesday 10am
today = datetime.today()
email = self.request.get('email', False)
priority = None
# sun-tue only check high priority
if today.weekday() in (6, 0, 1) and not email:
logging.debug('Only checking high priority invites.')
priority = 'Insist'
status = self.request.get('status', None)
gn = Gamenight.schedule(status=status, priority=priority)
if gn and gn.status == 'Yes' or not email:
logging.debug('No need to nag.')
self.redirect('/')
return
# saturday afternoon just give up and say no
if today.weekday() == 5 and today.hour > 16:
logging.debug('Giving up on scheduling this week.')
gn = Gamenight.schedule(status='No', date=today.date())
self.redirect('/')
return
logging.debug('Sending out email template: %s', email)
subjects = { 'first': 'Want to host gamenight?',
'second': 'Still looking to find a host for gamenight this week!' }
bodies = {'first': "Seems that no one has offered to host gamenight this week. " +
"Want to host? Go to http://%(url)s/invite!" ,
'second': "We still haven't had anyone volunteer to host gamenight this week. " +
"For now, the site will show '%(status)s', but if you'd like to host, " +
"please go to http://%(url)s/invite to have people come over. ",
}
footer = ("\nThanks!\n\n(You asked to get these emails if no one is hosting gamenight. " +
"If you want to stop getting these, go to http://%(url)s/profile and uncheck " +
"the 'nag emails' option.)")
message = mail.EmailMessage()
message.sender = 'Gamenight <%s>' % config.get('sender')
message.to = message.sender
message.subject = subjects[email]
message.body = (bodies[email] + footer) % { 'url': config.get('url', "TBD"), 'status': status }
message.bcc = [u.key.id() for u in User.query(User.nag==True).fetch()]
logging.info('Sending nag email to %r', message.to)
message.send()
self.redirect('/')
def get(self):
# don't bother starting to nag before Tuesday 10am
today = datetime.today()
email = self.request.get('email', False)
priority = None
# sun-tue only check high priority
if today.weekday() in (6, 0, 1) and not email:
logging.debug('Only checking high priority invites.')
priority = 'Insist'
status = self.request.get('status', None)
gn = Gamenight.schedule(status=status, priority=priority)
if gn and gn.status == 'Yes' or not email:
logging.debug('No need to nag.')
self.redirect('/')
return
# saturday afternoon just give up and say no
if today.weekday() == 5 and today.hour > 16:
logging.debug('Giving up on scheduling this week.')
gn = Gamenight.schedule(status='No', date=today.date())
self.redirect('/')
return
logging.debug('Sending out email template: %s', email)
subjects = { 'first': 'Want to host gamenight?',
'second': 'Still looking to find a host for gamenight this week!' }
bodies = {'first': "Seems that no one has offered to host gamenight this week. " +
"Want to host? Go to http://%(url)s/invite!" ,
'second': "We still haven't had anyone volunteer to host gamenight this week. " +
"For now, the site will show '%(status)s', but if you'd like to host, " +
"please go to http://%(url)s/invite to have people come over. ",
}
footer = ("\nThanks!\n\n(You asked to get these emails if no one is hosting gamenight. " +
"If you want to stop getting these, go to http://%(url)s/profile and uncheck " +
"the 'nag emails' option.)")
message = mail.EmailMessage()
message.sender = 'Gamenight <%s>' % config.get('sender')
message.to = message.sender
message.subject = subjects[email]
message.body = (bodies[email] + footer) % { 'url': config.get('url', "TBD"), 'status': status }
message.bcc = [u.key.id() for u in User.query(User.nag==True).fetch()]
logging.info('Sending nag email to %r', message.to)
message.send()
self.redirect('/')
def mutate(self, info, username, small_app_id, privilege):
user = User.get_query(info).filter(
models.User.name == username).first()
assert user is not None, f"User '{username}' does not exist"
small_app = SmallApp.get_query(info).filter(
models.SmallApp.id == small_app_id).first()
assert small_app is not None, f"Small app '{small_app_id}' does not exist"
privilege = models.PrivilegeEnum(privilege)
new_privilege = models.Privilege(user=user,
small_app=small_app,
privilege=privilege)
db_session.add(new_privilege)
db_session.commit()
return CreatePrivilege(privilege=new_privilege, ok=True)
def get(self, template_values={}, msg=None, error=None, profile=None):
user = User.get(users.get_current_user())
template_values.update({
'user': user,
'msg': msg,
'error': error,
'logout': users.create_logout_url('/'),
})
template_values['profile'] = user
if user.superuser:
template_values['users'] = User.query().fetch()
if profile:
template_values['profile'] = User.lookup(profile)
if not profile:
template_values['profile'] = user
template_values['error'] = "Couldn't find user %s" % profile
template = JINJA_ENVIRONMNT.get_template('profile.html')
self.response.write(template.render(template_values))
def mutate(self, info, username, small_app_id, privilege):
user = User.get_query(info).filter(
models.User.name == username).first()
assert user is not None, f"User '{username}' does not exist"
small_app = SmallApp.get_query(info).filter(
models.SmallApp.id == small_app_id).first()
assert small_app is not None, f"Small app '{small_app_id}' does not exist"
existing_privilege = (Privilege.get_query(info).filter(
models.SmallApp.id == small_app_id).first())
assert existing_privilege is not None, f'No privilege found'
existing_privilege.privilege = models.PrivilegeEnum(privilege)
db_session.add(existing_privilege)
db_session.commit()
return UpdatePrivilege(privilege=existing_privilege, ok=True)
def get(self, template_values={}, msg=None, error=None, profile=None):
user = User.get(users.get_current_user())
template_values.update({
'user': user,
'msg': msg,
'error': error,
'logout': users.create_logout_url('/'),
})
template_values['profile'] = user
if user.superuser:
template_values['users'] = User.query().fetch()
if profile:
template_values['profile'] = User.lookup(profile)
if not profile:
template_values['profile'] = user
template_values['error'] = "Couldn't find user %s" % profile
template = JINJA_ENVIRONMNT.get_template('profile.html')
self.response.write(template.render(template_values))
async def give_users_to_client(self, client, users_database):
data = []
clients_users = await users_database.count_documents(
{'client': client.token})
needed_users = max(0, MAX_USERS_PER_CLIENT - clients_users)
free_users = users_database.find({'client': None}).limit(needed_users)
async for i in free_users:
await users_database.update_one(
filter={'_id': i['_id']},
update={"$set": {
'client': client.token
}})
data.append(User(**i))
await client.send_users(data)
def get(self):
users = User.all()
if users:
s = []
for user in users:
o = {'username': user.username,
'password': "******",
'firstName': user.firstName,
'lastName': user.lastName,
'email': user.email,
'created': user.created.strftime('%B %d %Y') }
s.append(o)
self.response.headers['Content-Type']= 'application/json; charset=utf-8'
self.write(json.dumps(s))
def mutate(self, info, username, small_app_id, slide_id):
user = User.get_query(info).filter(
models.User.name == username).first()
assert user is not None, f"User '{username}' does not exist"
small_app = SmallApp.get_query(info).filter(
models.SmallApp.id == small_app_id).first()
assert small_app is not None, f"Small app '{small_app_id}' does not exist"
existing_comment = (Comment.get_query(info).filter(
models.Comment.user_id == user.id).filter(
models.Comment.small_app_id == small_app_id).filter(
models.Comment.slide_id == slide_id).first())
assert existing_comment is not None, f'No comment found for slide_id: {slide_id}'
db_session.delete(existing_comment)
db_session.commit()
return DeleteComment(ok=True)
def create_account(email=None, password=None):
result = User.by_email(email)
if result:
raise exceptions.BadRequest("Email in use")
user = User()
user.email = email
user.password = bcrypt.hashpw(password, bcrypt.gensalt())
user.save()
init_session(user)
return user.guid
def get(self, error=None, msg=None, flags={}):
user = User.get(users.get_current_user())
if not user.superuser:
self.redirect('/invite',
error="Must be an admin to edit configuration.")
return
template_values = {
'config': config,
'flags': flags,
'logout': users.create_logout_url('/'),
'user': user,
'error': error,
'msg': msg,
}
template = JINJA_ENVIRONMNT.get_template('config.html')
self.response.write(template.render(template_values))
def upsert_user(self, userinfo):
user = self.get_user(userinfo['id'])
if user:
user.email = userinfo['email']
user.name = userinfo['name']
user.avatar = userinfo['picture']
else:
user = User(id=int(userinfo['id']),
email=userinfo['email'],
name=userinfo['name'],
avatar=userinfo['picture'])
self.db.add(user)
self.db.commit()
return user
def mutate(self, info, name, groups=None, role=None):
user = User.get_query(info).filter(models.User.name == name).first()
_groups = []
if groups is not None:
existing_groups = [g.name for g in Group.get_query(info).all()]
for g in groups:
assert g in existing_groups, f'Group {g} does not exist. ' \
f'Existing groups: {existing_groups}'
_groups.append(
Group.get_query(info).filter(
models.Group.name == g).first())
user.groups = _groups
if role is not None:
user.role = Role.get(role)
db_session.add(user)
db_session.commit()
return UpdateUser(user=user, ok=True)
def get(self, error=None, msg=None, flags={}):
user = User.get(users.get_current_user())
if not user.superuser:
self.redirect('/invite',
error="Must be an admin to edit configuration.")
return
template_values = {
'config': config,
'flags': flags,
'logout': users.create_logout_url('/'),
'user': user,
'error': error,
'msg': msg,
}
template = JINJA_ENVIRONMNT.get_template('config.html')
self.response.write(template.render(template_values))
def add_user(fb_id,
email,
password,
name,
fb_updated_time,
email_verified,
uuid=None):
user = User(fb_id=fb_id,
email=email,
password=db.func.md5(password + app.config['SALT']),
name=name,
fb_updated_time=fb_updated_time,
email_verified=email_verified,
uuid=uuid)
db.session.add(user)
db.session.commit()
return user
def post(self):
have_error = False
username = (self.request.get('username')).lower()
password = self.request.get('password')
params = dict(username = username)
userFound = None
if not valid_username(username):
params['error_username'] = "******"
have_error = True
else:
if not valid_password(password):
params['error_password'] = "******"
have_error = True
else:
userFound = User.get_by_key_name(username, parent=None)
if userFound:
if userFound.password != password:
have_error = True
else:
logging.info("USERNAME: "******" PASSWORD: "******":")+ str(get_hash(userFound.userrole))
self.response.headers.add_header('Set-Cookie', 'user_hash='+str(cookie_value)+'; Path=/')
self.response.headers.add_header('Set-Cookie', 'user_id='+str(username)+'; Path=/')
if isAdmin(str(cookie_value)):
self.redirect('/admin')
else:
self.redirect('/welcome?username=' + username)
def endpoint_requires_login(*args, **kwargs):
guid = logged_in_guid()
if guid:
req.user = User.by_guid(guid)
return fn(*args, **kwargs)
raise Unauthorized()
def post(self, template_values={}):
user = User.get(users.get_current_user())
if self.request.get('withdraw'):
invite = Invitation.get(self.request.get('withdraw'))
if not invite:
self.get(error="Can't find this invitation.")
return
if invite.owner != user.key and not user.superuser:
self.get(error='Not your invitation.')
return
msg = ''
gn = Gamenight.query(Gamenight.invitation==invite.key).get()
logging.info('Invite id: %s, gn: %s', invite.key, gn)
invite.key.delete()
msg = 'Invitation withdrawn. '
if gn:
gn.key.delete()
msg += 'Rescheduling gamenight. '
Gamenight.schedule()
self.get(msg=msg)
return
args = {}
for k in ['when', 'where', 'priority', 'notes']:
args[k] = self.request.get(k)
error = None
warning = None
msg = ''
if args['when']:
try:
orig = args['when']
args['when'] = parser.parse(args['when'].replace('today', ''))
logging.info('Parsed "%s" as "%s"', orig, args['when'])
except ValueError:
error = 'Not sure what you mean by "%s"' % args['when']
logging.error('Failed to parse when: %s', args['when'])
else:
checks = []
if not time(18, 0, 0) <= args['when'].time() <= time(21, 0, 0):
checks.append(args['when'].time().strftime('%I:%M %p'))
if args['when'].date().weekday() != 5:
checks.append(args['when'].date().strftime('%A'))
if args['when'].date() < Utils.now().date():
checks.append(args['when'].date().strftime('%x'))
if checks:
warning = 'Just checking, did you really mean %s?' % ', '.join(checks)
else:
error = 'When do you want to host?'
if error:
self.get(template_values=args, error=error)
return
if not args['where']:
error = 'Where do you want to host?'
self.get(template_values=args, error=error)
return
if not args['priority']:
error = '''Gotta have a priority. Also, don't mess with me.'''
self.get(template_values=args, error=error)
return
args['owner'] = user.key
updated, invite = Invitation.create(args)
if updated:
gn = Gamenight.query(Gamenight.invitation==invite.key).get()
if gn:
gn.update()
msg += 'Invitation and gamenight updated! '
else:
msg += 'Invitation updated! '
self.get(msg=msg, error=warning)
else:
msg += 'Invitation created! '
self.get(msg=msg, error=warning)
def authd_endpoint(*args, **kwargs):
guid = logged_in_guid()
if guid:
req.user = User.by_guid(guid)
return fn(*args, **kwargs)
raise exceptions.Unauthorized()
def test_insert1(env):
users = []
user1 = User()
user1.oid = 1
user1.name = 'Homer Simpson'
user1.authid = 'homer'
user1.email = '*****@*****.**'
user1.birthday = datetime.date(1950, 12, 24)
user1.is_friendly = True
user1.tags = ['relaxed', 'beerfan']
users.append(user1)
user2 = User()
user2.oid = 2
user2.name = 'Crocodile Dundee'
user2.authid = 'crocoboss'
user2.email = '*****@*****.**'
user2.birthday = datetime.date(1960, 2, 4)
user2.is_friendly = False
user2.tags = ['red', 'yellow']
user2.referred_by = user1.oid
users.append(user2)
user3 = User()
user3.oid = 3
user3.name = 'Foobar Space'
user3.authid = 'foobar'
user3.email = '*****@*****.**'
user3.birthday = datetime.date(1970, 5, 7)
user3.is_friendly = True
user3.tags = ['relaxed', 'beerfan']
user3.referred_by = user1.oid
users.append(user3)
with Transaction(env, write=True) as txn:
for user in users:
_user = txn.users[user.oid]
if not _user:
txn.users[user.oid] = user
#txn.users_by_authid[user.authid] = user.oid
print('user stored', user)
else:
print('user loaded', _user)
