def _user_required(request_handler):
user = users.get_current_user()
u = User.get_by_key_name(user.email())
if not u:
u = User(email=user.email(),user_id=user.user_id())
u.put()
method(request_handler)
def post(self):
sender = self.request.get('from').split('/')[0]
u = User.get_by_key_name(sender)
if u == None:
u = User(email=sender)
u.is_subscribed = True
u.put()
logging.info('User subscribed ' + sender)
logging.info('stanza ' + self.request.get('stanza'))
def post(self):
sender = self.request.get('from').split('/')[0]
u = User.get_by_key_name(sender)
if u == None:
u = User(email=sender)
previously_available = u.is_available
u.is_available = False
u.put()
if previously_available:
Client.send_global_refresh()
logging.info('User unavailable ' + sender)
logging.info('stanza ' + self.request.get('stanza'))
def handle(self, isPost):
error = ''
if isPost:
username = self.request.get('username')
password = self.request.get('password')
success, newuser = self.user_model.create_user(
username, password_raw=password)
if not success:
error = 'User with given username already exists.'
newuser.instructor = Instructor.create(newuser.key)
newuser.put()
time.sleep(1)
lst = list(User.query().fetch())
for user in lst:
if user.name == ADMIN_USERNAME:
lst.remove(user)
break
self.send_page(HOME_TEMP, {
'error': error,
'users': lst,
'username': self.user_name,
})
def get(self):
user = users.get_current_user()
u = User.get_by_key_name(user.email())
categories = []
suggestions = set()
for category in Category.all():
areas = category.get_areas_of_expertise()
if areas:
area_data = [{
'user_name' : area.user.get_name(),
'user_email' : area.user.email,
'user_profile_pic' : area.user.profile_pic,
'user_available' : area.user.is_available_for_hangout(),
'description' : area.description.title(),
} for area in areas if area.user.is_expert]
for area in areas:
suggestions.add(category.name.title() + ' :: ' + area.description.title())
if area_data:
categories.append({'name':category.name, 'areas':area_data})
self.Render("main.html", {
'user': u,
'validate': u.validate(),
'contents': 'expert_list.html',
'token': channel.create_channel(user.user_id()),
'is_expert': u.is_expert,
'categories': categories,
'suggestions': [suggestion for suggestion in suggestions],
'login': users.create_login_url("/"),
'logout': users.create_logout_url("/"),
'is_admin': users.is_current_user_admin(),
})
def get(self):
user = users.get_current_user()
u = User.get_by_key_name(user.email())
template_values = {
'user': u,
'validate': u.validate(),
'url': decorator.authorize_url(),
'has_credentials': decorator.has_credentials(),
'contents': 'sign_up.html',
}
self.Render('main.html', template_values)
def get(self):
user = self.request.get('user')
category = self.request.get('category')
u = User.get_by_key_name(user)
if u == None or not u.validate() or not u.is_available_for_hangout():
logging.error('Connect request to invalid and/or unavailable user/expert ' + user)
self.redirect('/')
return
c = Category.get_by_key_name(category.lower())
if not c:
logging.error('Connect request with invalid category key: ' + category.lower())
self.redirect('/')
return
url = HangoutStats.get_hangout_url()
logging.info('Hangout url: %s in category %s' % (url, category))
xmpp.send_message(u.email, chat.REQUEST_MSG % (category, url))
for email in ['*****@*****.**', '*****@*****.**', '*****@*****.**']:
u = User.get_by_key_name(email)
if u and u.is_subscribed:
xmpp.send_message(email, chat.FACILITATOR_MSG % (category, url))
self.redirect(url)
def get(self, instructor, term, name):
user = User.get_by_auth_id(instructor)
syll = Syllabus.from_name(user.key, term, name)
if syll is None or not syll.active:
self.abort(404)
else:
sdict = syll.get_dict()
sdict['standalone'] = True
sdict['owner'] = user
sdict['list_url'] = uri_for('public-term',
instructor=instructor,
term=term)
self.send_page(TEMPLATE, sdict)
def post(self):
sender = self.request.get('from').split('/')[0]
u = User.get_by_key_name(sender)
if u == None:
u = User(email=sender)
previously_available = u.is_available
u.show = self.request.get('show')
u.show_time = datetime.datetime.now()
u.is_available = True
u.put()
if not previously_available:
Client.send_global_refresh()
logging.info('User available ' + sender)
logging.info('stanza ' + self.request.get('stanza'))
logging.info('show ' + self.request.get('show'))
def test_system_1(self):
# Create the user, no need to simulate logging in
success, user = User.create_user("test", password_raw="test")
self.assertEqual(success, True, "Unable to create user \"test\".")
# Create the syllabus
#term = Term.build_term("F", "2015")
syllabus = Syllabus.create(user.key, "F15/test")
# Modify the syllabus as if you were manually setting TAs, textbooks, etc.
"Blah Blah do stuff here"
# Test the dictionary created by the syllabus
di = syllabus.get_dict()
self.assertIsNotNone(di['term']) # For basically all of the different keys of the dictionary
""" List of all the dictionary keys for your convenience
def get(self):
user = users.get_current_user()
u = User.get_by_key_name(user.email())
if not u.is_expert and not u.convert_to_expert(service, calendar_service, decorator):
# Token access error. Go back to sign up page and restart flow
self.redirect('/signUp')
return
# get the areas of expertise for this user
user_areas = u.get_areas_of_expertise()
# user_areas_dict = dict((area.category.name, area) for area in user_areas)
#
# # construct a data structure of all categories
# all_categories = []
# for category in Category.all():
# category_data = {
# 'checked': False,
# 'name': category.name,
# 'description': category.name,
# }
# if category.name in user_areas_dict:
# category_data['checked'] = True
# category_data['description'] = \
# user_areas_dict[category.name].description
# all_categories.append(category_data)
suggestions = set()
for category in Category.all():
for area in category.get_areas_of_expertise():
suggestions.add(category.name.title() + ' :: ' + area.description.title())
# this is what we pass to the templating engine
template_values = {
# 'all_categories': all_categories,
'suggestions': [suggestion for suggestion in suggestions],
'user_categories': [(area.category.name.title(), area.category.name.title() + ' :: ' + area.description.title()) for area in user_areas],
'user': u,
'validate': u.validate(),
'logout': users.create_logout_url("/"),
'contents': 'add_expertise.html',
'is_expert': u.is_expert,
'is_admin': users.is_current_user_admin(),
}
self.Render('main.html', template_values)
def get(self, instructor, term):
user = User.get_by_auth_id(instructor)
if user is None:
self.abort(404)
syllabi = Syllabus.query_user_term_active(user.key, term).fetch()
office_term = user.instructor.get_office_user_term(user.key, term)
office_times = office_term.times if office_term is not None else []
if len(office_times) == 0 and len(syllabi) == 0:
self.abort(404)
self.send_page(
TEMPLATE, {
'heading':
"<span>Course List - " + user.instructor.name + "</span>",
'syllabi': syllabi,
'calendar': self.generate_calendar(office_times, syllabi),
})
def handle(self, isPost):
error=""
if isPost:
username = self.request.get('user')
password = self.request.get('pass')
try:
self.auth.get_user_by_password(username, password, remember=True, save_session=True)
except (InvalidAuthIdError, InvalidPasswordError):
error = "Invalid username/password."
if self.user_info:
if self.user_name == ADMIN_USERNAME:
self.redirect(uri_for('admin-home'))
else:
self.redirect(uri_for('manage-home'))
else:
if User.get_by_auth_id(ADMIN_USERNAME) is None:
self.user_model.create_user(ADMIN_USERNAME, password_raw=ADMIN_PASSWORD)
self.send_page(TEMPLATE, {'error':error})
def get(self):
for u in User.all().fetch(1000):
u.update_calendar(calendar_service)
def post(self):
# figure out the current user
user = users.get_current_user()
if user == None:
self.redirect(users.create_login_url("/manageAccount"))
return
u = User.get_by_key_name(user.email())
if u == None:
self.redirect(users.create_login_url("/signUp"))
return
# add all the existing categories
area = AreaOfExpertise.all()
area.filter("user ="******"expertoptout") != "true"
u.put()
for category_subcategory in self.request.get_all("usercategory"):
if category_subcategory and category_subcategory != "" and re.search("\s::\s", category_subcategory):
match = re.search("\s::\s", category_subcategory)
category_name = category_subcategory[0:match.start(0)].lower()
subcategory = category_subcategory[match.end(0):].lower()
if not Category.get_by_key_name(category_name):
category = Category(name=category_name)
category.put()
u.add_category(category_name, subcategory)
# for param in self.request.arguments():
# value = self.request.get(param)
# if param == "expertoptout":
# u.expert_opt_out = self.request.get("expertoptout") != "true"
# u.put()
# elif not re.search(" description$", param) and value == "true":
# if not Category.get_by_key_name(param):
# c = Category(name=param)
# c.put()
# description = self.request.get('%s description' % param)
# logging.error(param + " :: " + description)
# u.add_category(param, description)
# for category in Category.all().fetch(100):
# if self.request.get(category.name) == 'true':
# description = self.request.get('%s description' % category.name)
# u.add_category(category.name, description)
# # add the other category
# other_category = self.request.get("other").lower()
# if other_category and other_category != "" and other_category != "other":
# # Disallow empty category names and the "other" category name
# if not Category.get_by_key_name(other_category):
# category = Category(name=other_category)
# category.put()
# u.add_category(other_category, other_category)
# add_category = self.request.get("addcategory").lower()
# if add_category and add_category != "" and re.search("\s::\s", add_category):
# match = re.search("\s::\s", add_category)
# category_name = add_category[0:match.start(0)]
# subcategory = add_category[match.end(0):]
# if not Category.get_by_key_name(category_name):
# category = Category(name=category_name)
# category.put()
# u.add_category(category_name, subcategory)
# do the opt out stuff
self.redirect("/")
def test_get_user(user_row):
assert db.insert_user(*user_row) == True
user = db.get_user(user_row[0])
assert user is not None
assert user == User(*user_row)
def users_user_get(user_id):
rec = User.get(user_id)
if not rec:
return "No such user", 404
rec['permissions'] = Permission.get_list(user_id)
return json.dumps(rec), 200
def get_user(conn, _id):
"""SELECT a row from TABLE users, using id"""
query = "SELECT * FROM users WHERE id=?"
row = conn.execute(query, (_id, )).fetchone()
return User(*row) if row else None
