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