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 _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 _valid_request(self, user, attr, deadline_id, value):
# User parameters must be defined
if not user or not attr or not value or not deadline_id:
print "Invalid Request. Parameters Missing"
return False
notes = value[0].decode("utf-8")
# The deadline associated with the deadline_id must exist
deadline_repo = DeadlineRepository()
dead = deadline_repo.deadline_for_user(user.id, deadline_id)
deadline_repo.close()
if not dead or not dead.meta or not dead.group_id:
print "Something is wrong with the deadline object."
return False
group_repo = GroupRepository()
group = group_repo.fetch(dead.group_id)
group_repo.close()
if not group:
print "Associated group doesn't exist."
return False
if not (dead.type == "PER" or
(group.maintainerId == dead.group_id and dead.type == "END")):
print "User cannot modify this deadline"
return False
return True
def _perform_request(self, user, prefix, group_id):
group_repo = GroupRepository()
group = group_repo.fetch(group_id)
group_repo.close()
deadline_repo = DeadlineRepository()
deadline_list = deadline_repo.find_deadlines_with_name_prefix(group_id, prefix)
deadline_repo.close()
formatted_names = [{"value": deadline.name} for deadline in deadline_list]
return json.dumps(formatted_names)
def get( self ):
gr = GroupRepository()
dr = DeadlineRepository()
root_group = self.get_root_group()
user = self.get_current_user()
root_group_tree = gr.get_user_group_tree(user.id, root_group.id)
gr.get_group_maintainer_rec(root_group_tree)
deadline_list = dr.deadlines_for_user(user.id)
for deadline in deadline_list:
deadline.group = gr.fetch(deadline.group_id)
self.render( self.get_url(),
user = user,
deadlines = deadline_list,
groups = [ root_group_tree ]
)
def _perform_request(self, user, name, values):
group_id = values[u"group_id"]
name = values[u"name"]
deadline = values[u"deadline"]
notes = values[u"notes"]
curr_user = self.get_current_user()
dr = DeadlineRepository()
gr = GroupRepository()
group = gr.fetch(group_id)
gr.get_group_maintainer(group)
new_deadline = Deadline()
new_deadline.meta = DeadlineMetadata()
new_deadline.name = name
new_deadline.group_id = group_id
new_deadline.deadline = datetime.strptime(deadline, u'%m/%d/%Y %I:%M %p') # private group
if(group.maintainer and group.maintainer.id == user.id):
new_deadline.type = 'END'
else:
new_deadline.type = 'PER'
new_deadline.meta.user_id = user.id
new_deadline.meta.notes = notes
new_deadline = dr.persist(new_deadline)
dr.close()
result = {}
result['id'] = new_deadline.id
result['name'] = new_deadline.name
result['group'] = new_deadline.group
result['type'] = new_deadline.type
result['time'] = new_deadline.deadline.strftime(u'%A %b %d, %H:%M')
result['notes'] = new_deadline.meta.notes
result['can_edit'] = (new_deadline.type == "PER" or (group.maintainerId == user.id and new_deadline.type == "END"))
self.write(json.dumps(result))
self.flush
self.finish
def _perform_request(self, user, attr, deadline_id, value):
notes = value[0].decode("utf-8")
deadline_repo = DeadlineRepository()
dead = deadline_repo.deadline_for_user(user.id, deadline_id)
dead.meta.notes = notes
deadline_repo.persist(dead)
deadline_repo.close()
def _perform_request(self, user, attr, deadline_id, value):
new_name = value[0].decode("utf-8")
deadline_repo = DeadlineRepository()
dd = deadline_repo.deadline_for_user(user.id, deadline_id)
dd.name = new_name
deadline_repo.persist(dd)
deadline_repo.close()
def _valid_request(self, user, attr, deadline_id, value):
# User parameters must be defined
if not user or not attr or not value or not deadline_id:
print "Invalid Request. Parameters Missing"
return False
new_time = value[0].decode("utf-8")
# Strip the 0000- year off the time.
new_time = datetime.strptime(new_time[5:], "%m-%d %H:%M")
# Add the correct year
new_time = new_time + (date(datetime.now().year, 1, 1) - date(new_time.year, 1, 1))
if new_time < datetime.now():
print "Invalid time"
return False
# The deadline associated with the deadline_id must exist
deadline_repo = DeadlineRepository()
dead = deadline_repo.deadline_for_user(user.id, deadline_id)
deadline_repo.close()
if not dead or not dead.name or not dead.group_id:
print "Something is wrong with the deadline object."
return False
group_repo = GroupRepository()
group = group_repo.fetch(dead.group_id)
group_repo.close()
if not group:
print "Associated group doesn't exist."
return False
if not (dead.type == "PER" or
(group.maintainerId == dead.group_id and dead.type == "END")):
print "User cannot modify this deadline"
return False
return True
def _perform_request(self, user, attr, deadline_id, value):
new_time = value[0].decode("utf-8")
# Strip the 0000- year off the time.
new_time = datetime.strptime(new_time[5:], "%m-%d %H:%M")
# Add the correct year
new_time = new_time + (date(datetime.now().year, 1, 1) - date(new_time.year, 1, 1))
deadline_repo = DeadlineRepository()
dead = deadline_repo.deadline_for_user(user.id, deadline_id)
dead.deadline = new_time
deadline_repo.persist(dead)
deadline_repo.close()
def _perform_request(self, user, name, values):
print "Performing request"
deadline_id = values["deadline_id"]
curr_user = self.get_current_user()
dr = DeadlineRepository()
gr = GroupRepository()
deadline = dr.deadline_for_user(curr_user.id, deadline_id)
group = gr.fetch(deadline.group_id)
if(group.maintainerId == curr_user.id or group.type == 'PER'):
dr.delete(deadline.id)
else:
dr.drop_metadata(deadline)
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
