def post( self ):
user_email = self.get_argument( "user_email" )
user_password = self.get_argument( "user_password" )
repo = UserRepository()
user = repo.get_user_by_email(user_email)
repo.close()
params = {}
if user is not None:
# user exists. does the password match?
if user.match_password(user_password):
# password is correct. Has user confirmed their email?
if user.confirmed:
self.set_current_user(user.id)
else:
params["unconfirmed"] = True
self.redirect( "/?" + urllib.urlencode(params) )
else:
params["badpass"] = True
self.redirect( "/?" + urllib.urlencode(params) )
else:
params["baduser"] = True
self.redirect( "/?" + urllib.urlencode(params) )
self.redirect( "/main" )
def _persist_user(self, user):
"""Save any user changes to the database"""
user_repo = UserRepository()
user = user_repo.persist(user)
user_repo.close()
return user
def post( self, group_id ):
ur = UserRepository()
gr = GroupRepository()
user = self.get_current_user()
group = gr.fetch(group_id)
gr.get_group_maintainer(group)
user_group_ids = [ g.id for g in gr.get_groups_of_user(user.id) ]
supergroups = gr.get_supergroup_list(group_id)
# TODO: Add logic to prevent user from leaving if they're in a subgroup
# of the current group.
group_root = gr.get_user_group_tree(user.id, long(group_id))
# The group must be a non-root group to consider removal. Also, the user
# cannot be in any of the subgroups.
if len(supergroups) != 0 and len(group_root.subgroups) == 0:
supergroup = supergroups[-1]
# Case 1: User requested group deletion (user is maintainer + empty).
if group.maintainerId == user.id and gr.get_group_size(group.id) == 1:
gr.remove(group)
self.redirect( "/group/" + str(supergroup.id) )
return
# Case 2: User requested to leave the group (user is in group).
if group.id in user_group_ids:
user.groups = [ gid for gid in user_group_ids if gid != group.id ]
ur.persist(user)
self.redirect( "/group/" + str(supergroup.id) )
return
self.redirect( "/group/" + str(group_id) )
def _valid_request(self, user, name, values):
# Malformed request
if u"group_members" not in values or u"deadline" not in values or u"duration" not in values or u"off_limits_start" not in values or u"off_limits_end" not in values:
return False
# Malformed request
group_members = values[u"group_members"]
deadline = values[u"deadline"]
duration = values[u"duration"]
off_limits_start = values[u"off_limits_start"]
off_limits_end = values[u"off_limits_end"]
if not group_members or not deadline or not duration or not off_limits_start or not off_limits_end:
return False
#real deadline
dr = DeadlineRepository()
dl = dr.fetch(deadline)
dr.close()
if not dl:
sys.stderr.write("invalid deadline id: " + str(dl))
return False
#real users
for email in group_members:
new_user_repo = UserRepository()
new_user = new_user_repo.get_user_by_email(email)
new_user_repo.close()
if not new_user:
sys.stderr.write("invalid email: " + email)
return False
return True
def get( self, group_id ):
ur = UserRepository()
gr = GroupRepository()
dr = DeadlineRepository()
# TODO: 404 if the user is not a member of the group.
user = self.get_current_user()
# TODO: 404 if the page doesn not exist in the DB.
group = gr.get_user_group_tree(user.id, long(group_id))
gr.get_group_maintainer_rec(group)
supergroup_list = gr.get_supergroup_list(group_id)
group_is_public = group.maintainerId == None
user_is_maintainer = group.maintainerId == user.id
member_list = ur.get_members_of_group(group_id)
deadline_list = dr.deadlines_for_user_for_group(user.id, group.id)
print "Deadline List: ", deadline_list
for deadline in deadline_list:
deadline.group = group
self.render( self.get_url(),
user = user,
group = group,
supergroups = supergroup_list,
subgroups = group.subgroups,
group_is_public = group_is_public,
user_is_maintainer = user_is_maintainer,
members = member_list,
deadlines = deadline_list,
)
def get_current_user( self ):
user_id_str = self.get_secure_cookie(self.cookie_name)
if user_id_str is None:
return None
user_id = long(user_id_str)
repo = UserRepository()
user = repo.fetch(user_id)
repo.close()
return user
def _perform_request(self, user, prefix, group_id):
group_repo = GroupRepository()
parent = group_repo.get_supergroup_of_group(group_id)
group_repo.close()
user_repo = UserRepository()
user_list = user_repo.find_users_with_email_prefix(user.id, parent.id, prefix)
user_repo.close()
formatted_names = [{"value": u.email} for u in user_list]
return json.dumps(formatted_names)
def _valid_request(self, user, prefix, group_id):
group_repo = GroupRepository()
group = group_repo.fetch(group_id)
group_repo.close()
if not group:
print "Group doesn't exist."
return False
user_repo = UserRepository()
member_list = user_repo.get_members_of_group(group_id)
user_repo.close()
if not any(member.id == user.id for member in member_list):
print "User is not a member of the associated group."
return False
group_repo = GroupRepository()
parent_group = group_repo.get_supergroup_of_group(group_id)
group_repo.close()
if not group_repo:
print "Attempting to add membrer to the root."
return False
user_repo = UserRepository()
parent_member_list = user_repo.get_members_of_group(parent_group.id)
user_repo.close()
if not any(member.id == user.id for member in parent_member_list):
print "New user is not a member of the supergroup."
return False
return True
def post( self ):
unique = str(uuid.uuid4())
user_email = self.get_argument( "user_email" )
user_nickname = self.get_argument( "user_nickname" )
user_password = self.get_argument( "user_password" )
# add this user to the database.
user = User()
user.email = self.get_argument("user_email")
user.name = self.get_argument("user_nickname")
user.password = self.get_argument("user_password")
user.confirmUUID = unique
uiuc = self.get_root_group()
repo = UserRepository()
repo.persist(user)
user = repo.get_user_by_email(user_email)
repo.add_user_to_group(user, uiuc)
repo.close()
## Send a verification email to the user
m = CukeMail()
m.send_verification(unique, user.email)
self.redirect( "/" )
def _valid_request(self, user, prefix, group_id):
group_repo = GroupRepository()
group = group_repo.fetch(group_id)
group_repo.close()
if not group:
print "Group doesn't exist."
return False
user_repo = UserRepository()
member_list = user_repo.get_members_of_group(group_id)
user_repo.close()
if not any(member.id == user.id for member in member_list):
print "User is not a member of the associated group."
return False
return True
def _perform_request(self, user, name, values):
meeting_time = values[u"meeting_time"]
meeting_message = values[u"meeting_message"]
group_id = values[u"group_id"]
curr_user = self.get_current_user()
ur = UserRepository()
users = ur.get_members_of_group(group_id)
ur.close()
gr = GroupRepository()
group = gr.fetch(group_id)
gr.close()
cm = CukeMail()
cm.subject(group.name + " meeting @ " + meeting_time)
cm.message(meeting_message)
cm.send([user.email for user in users])
self._persist_user(curr_user)
def _perform_request(self, user, name, values):
group_id = values[u"group_id"]
new_group_name = values[u"group_name"]
new_group_desc = values[u"group_description"]
curr_user = self.get_current_user()
gr = GroupRepository()
new_group = Group()
new_group.name = new_group_name
new_group.description = new_group_desc
new_group.type = 0 # private group
new_group.maintainerId = curr_user.id
new_group = gr.persist(new_group)
# assign the subgroup as a child of the parent group
gr.add_group_as_subgroup(group_id, new_group.id)
gr.close()
# assign the user as a member of the subgroup
user_repo = UserRepository()
user_repo.add_user_to_group(curr_user, new_group)
user_repo.close()
self._persist_user(curr_user)
result = {}
result['id'] = new_group.id
result['name'] = new_group.name
user_repo2 = UserRepository()
user = user_repo2.fetch(new_group.maintainerId)
user_repo2.close()
result['maintainer'] = user.name
self.write(json.dumps(result))
self.flush
self.finish
def handle_response(response):
sys.stderr.write("response = " + str(response) + '\n')
data = json.loads(response.body)
r_token = data['refresh_token']
user_id = self.get_query_argument("state")
sys.stderr.write("user_id = " + str(user_id) + '\n')
sys.stderr.write("refresh_token = " + r_token + '\n')
user_repo = UserRepository()
user = user_repo.fetch(user_id)
user.refreshTok = r_token
user_repo.persist(user)
user_repo.close()
def _perform_request(self, user, name, values):
group_id = values[u"group_id"]
new_user_email = values[u"user_email"]
group_repo = GroupRepository()
group = group_repo.fetch(group_id)
group_repo.close()
new_user_repo = UserRepository()
new_user = new_user_repo.get_user_by_email(new_user_email)
new_user_repo.add_user_to_group(new_user, group)
new_user_repo.close()
self._persist_user(new_user)
result = {}
result['name'] = new_user.name
result['email'] = new_user.email
result['iconURL'] = new_user.iconSmallURL
self.write(json.dumps(result))
self.flush
self.finish
def get(self, unique):
repo = UserRepository()
repo.mark_verified(unique)
self.redirect("/")
def _perform_request(self, user, name, values):
parser = ConfigParser.ConfigParser()
parser.read('./config/app.conf')
section = 'General'
client_id = parser.get(section, 'client_id')
client_secret = parser.get(section, 'client_secret')
group_emails = values[u"group_members"]
deadline = values[u"deadline"]
duration = values[u"duration"]
off_limits_start = values[u"off_limits_start"]
off_limits_end = values[u"off_limits_end"]
#real deadline
dr = DeadlineRepository()
deadline = dr.fetch(deadline).deadline
dr.close()
duration = timedelta(minutes=int(duration))
off_limits_start = datetime.strptime(off_limits_start, u'%I:%M %p').time()
off_limits_end = datetime.strptime(off_limits_end, u'%I:%M %p').time()
group_members = {}
for email in group_emails:
new_user_repo = UserRepository()
new_user = new_user_repo.get_user_by_email(email)
new_user_repo.close()
#must have refresh token
if not new_user.refreshTok:
sys.stderr.write(email + "has not given google permission to view calendar information" + '\n')
None.hi()
ref_tok = new_user.refreshTok
#sys.stderr.write("refresh_token = " + ref_token + '\n\n')
#get access token
url = "https://accounts.google.com/o/oauth2/token"
access_token_request = "refresh_token=" + ref_tok + "&" +\
"client_id=" + client_id + "&" +\
"client_secret=" + client_secret + "&" +\
"grant_type=refresh_token"\
sys.stderr.write("access_token request = " + access_token_request + '\n\n')
http_client = tornado.httpclient.HTTPClient()
http_request = tornado.httpclient.HTTPRequest(url, 'POST', body=access_token_request)
response = http_client.fetch(http_request)
#handle the access token response
#sys.stderr.write("response = " + str(response) + '\n\n')
data = json.loads(response.body)
a_token = data['access_token']
sys.stderr.write("access_token = " + a_token + '\n\n')
events = []
cal_list_http_client = tornado.httpclient.HTTPClient()
response2 = cal_list_http_client.fetch("https://www.googleapis.com/calendar/v3/users/me/calendarList?access_token=" + a_token)
#handle google calendar list
#sys.stderr.write("calendar list response = " + str(response2) + '\n\n')
data2 = json.loads(response2.body)
#sys.stderr.write(str(data2) + '\n\n')
for calendar in data2['items']:
calendar_id = calendar['id']
#calendars without the 'selected' attribute appear to be invalid
if 'selected' not in calendar:
continue
sys.stderr.write("Reading calendar: " + str(calendar_id) + '\n')
event_list_http_client = tornado.httpclient.HTTPClient()
response3 = event_list_http_client.fetch("https://www.googleapis.com/calendar/v3/calendars/" + calendar_id + "/events?singleEvents=true&access_token=" + a_token)
#handle event list
#sys.stderr.write("event list response = " + str(response3) + '\n\n')
data3 = json.loads(response3.body)
#sys.stderr.write(str(data3) + '\n\n')
#add each event
for event in data3['items']:
#I have many doubts this will work for arbitrary calendars
#and I am certain it will error for other timezones.....
if 'start' not in event:
continue
if 'dateTime' not in event['start']:
continue
if 'end' not in event:
continue
if 'dateTime' not in event['end']:
continue
start = datetime.strptime(event['start']['dateTime'][:19], u'%Y-%m-%dT%H:%M:%S')
end = datetime.strptime(event['end']['dateTime'][:19], u'%Y-%m-%dT%H:%M:%S')
events.append((start, end))
#sys.stderr.write("Event found: " + str(start) + " - " + str(end) + '\n')
sys.stderr.write('\n')
group_members[email] = events
meets = schedule_meeting(group_members, deadline, duration, off_limits_start, off_limits_end)
result = []
for meet in meets:
result.append(meet[0].strftime(u'%A %b %d (%Y) at %I:%M %p'))
i = 0
real = []
for r in result:
if i % 4 == 0:
real.append(r)
i+=1
self.write(json.dumps(real[:15]))
self.flush
self.finish
def _valid_request(self, curr_user, name, values):
# Malformed request
if u"group_id" not in values or u"user_email" not in values:
print "Malformed request detected."
return False
# Malformed request
group_id = values[u"group_id"]
new_user_email = values[u"user_email"]
if not group_id or not new_user_email:
print "Required data is missing."
return False
user_repo = UserRepository()
member_list = user_repo.get_members_of_group(group_id)
user_repo.close()
if not any(member.id == curr_user.id for member in member_list):
print "User is not a member of the associated group."
return False
group_repo = GroupRepository()
parent_group = group_repo.get_supergroup_of_group(group_id)
group_repo.close()
if not group_repo:
print "Cannot add member to the root group."
return False
user_repo = UserRepository()
parent_member_list = user_repo.get_members_of_group(parent_group.id)
user_repo.close()
if not any(member.id == curr_user.id for member in parent_member_list):
print "New user is not a member of the supergroup."
return False
# New user is already a member of the group
new_user_repo = UserRepository()
new_user = new_user_repo.get_user_by_email(new_user_email)
new_user_repo.close()
if not new_user:
print "New user doesn't exist."
return False
if not new_user.groups:
print "New user isn't a member of any groups."
return False
if group_id in new_user.groups:
print "New user is already already a member of the group."
return False
group_repo = GroupRepository()
group = group_repo.fetch(group_id)
group_repo.close()
if not group:
print "Group doesn't exist"
return False
# 1 => Public
if group.type == 1:
print "Cannot add members to public groups"
return False
return True
