def get(self):
user = self.user_model
get_notifications(user)
current_date = datetime.datetime.now() - datetime.timedelta(hours=8)
all_requests = Request.query(Request.start_time >= current_date).order(Request.start_time)
all_requests = [r for r in all_requests if r.sender != user.key]
pending_requests = Request.query(Request.status == 'pending').order(Request.start_time)
pending_requests = [r for r in pending_requests if r.start_time < current_date]
# Sort by food type
type_sort = sorted(all_requests, key=lambda x:x.food_type)
types = {}
for r in type_sort:
# Get all types
if r.food_type not in types:
types[r.food_type] = []
for r in type_sort:
for t in types:
if r.food_type == t:
types[t].append(r)
break
self.response.out.write(template.render('views/feed.html', {'user': user,
'pending_requests': pending_requests, 'all_requests': all_requests, 'food_type':types}))
def get(self):
current_time = datetime.datetime.now() - datetime.timedelta(hours=8)
max_time = current_time + datetime.timedelta(hours=1)
dead_accepted_requests = Request.query(Request.start_time > current_time, Request.start_time < max_time).fetch()
dead_accepted_requests = [x for x in dead_accepted_requests if x.status == "sms" and x.recipient != None]
for request in dead_accepted_requests:
request.status = "dead"
dead_requests = Request.query(Request.start_time < current_time).fetch()
dead_requests = [x for x in dead_requests if x.status == "waiting for a bid" or x.status =="pending"]
for request in dead_requests:
print "Removing request: " + str(request)
request.key.delete()
def get_notifications(user):
#Get Requests for Notifications
accepted_requests = []
new_requests = []
current_time = datetime.datetime.now() - datetime.timedelta(hours=8)
# Check for last login/update
check_time = user.last_check
print "Last Check: " , check_time
if check_time is None:
# Pull all results from previous week
check_time = datetime.datetime.now() - datetime.timedelta(days=7, hours=8)
print "Updated time: ", check_time
# New requests
available_requests = Request.query(Request.sender != user.key).fetch()
available_requests = [r for r in available_requests if r.creation_time >= check_time]
available_requests = [r for r in available_requests if r.start_time >= current_time]
available_requests = [r for r in available_requests if r.recipient == None]
# Approved requests
approved_requests = Request.query(Request.recipient == user.key).fetch()
approved_requests = [r for r in approved_requests if r.accept_time != None]
approved_requests = [r for r in approved_requests if r.start_time >= current_time]
approved_requests = [r for r in approved_requests if r.accept_time >= check_time]
# Pending requests
pend_requests = Request.query(Request.sender == user.key).fetch()
pend_requests = [r for r in pend_requests if r.start_time >= current_time]
pend_requests = [r for r in pend_requests if len(r.bidders) > 0]
new_bidders = 0
if len(pend_requests) > 0:
for r in pend_requests:
for bid in r.bidders:
bid = bid.get()
if bid.bid_time != None:
if bid.bid_time > check_time:
print "Bid Time: " , bid.bid_time
new_bidders += 1
else:
pend_requests = [r for r in pend_requests if r.creation_time >= check_time]
print "No bidders: ", pend_requests
user.pending_requests = new_bidders
user.available_requests = len(available_requests)
print len(available_requests)
user.approved_requests = len(approved_requests)
print len(approved_requests)
user.put()
print "user updated"
def get(self):
user = self.user_model
date = cgi.escape(self.request.get("date"))
time = cgi.escape(self.request.get("time"))
active_request = cgi.escape(self.request.get("edit_request"))
if active_request:
edit_request = ndb.Key(urlsafe=active_request).get()
# Check for lack of values
if len(date) < 1:
if active_request:
date = edit_request.start_time.strftime("%Y-%m-%d")
else:
self.response.out.write('Please choose date')
# Convert date and time to datetime
format_date = str(date+ " " +time+":00.0")
start_time = datetime.datetime.strptime(format_date, "%Y-%m-%d %H:%M:%S.%f")
# Check for current request within time limit
ongoing_request = Request.query(Request.sender == user.key).fetch()
# Remove current request if applicable
if active_request:
ongoing_request.remove(edit_request)
alloted_date = start_time + datetime.timedelta(minutes=20) #Max limit
create = timeCheck(ongoing_request, alloted_date, start_time)
if create is True:
self.response.out.write('Available')
else:
self.response.out.write('Time Already Passed/Reserved')
def get(self):
current_time = datetime.datetime.now() - datetime.timedelta(hours=8)
# Get all requests in accepted state
completed_requests = Request.query(Request.status == "foodie").fetch()
#completed_requests = [x for x in completed_requests if x.start_time + datetime.timedelta(minutes=10) < current_time]
for request in completed_requests:
send_fire_notification(request)
request.status = "attempt_fire"
request.put()
def get(self):
current_time = datetime.datetime.now() - datetime.timedelta(hours=8)
# 5 min before current
min_time = current_time - datetime.timedelta(minutes=5)
# 5 min after current
max_time = current_time + datetime.timedelta(minutes=5)
# Get all requests in accepted state
completed_requests = Request.query(Request.status == "accepted").fetch()
completed_requests = [x for x in completed_requests if x.recipient != None]
#completed_requests = [x for x in completed_requests if x.start_time >= min_time and x.start_time < max_time]
for request in completed_requests:
send_sms(request)
request.status = "sms"
request.put()
def get(self):
user = self.user_model
request_sort = cgi.escape(self.request.get('requests'))
current_date = datetime.datetime.now() - datetime.timedelta(hours=8)
# Return only those two hours or more in future
alloted_time = current_date + datetime.timedelta(minutes=20)
sorted_requests = []
available_requests = Request.query(Request.start_time >= alloted_time).order(Request.start_time)
print "alloted", alloted_time
print "current", current_date
if request_sort == 'price' or request_sort == 'location' or request_sort == 'hangouts' or request_sort == 'lessons':
sorted_requests = sortRequests(request_sort, alloted_time)
dead_requests = Request.query(Request.start_time <= alloted_time, Request.sender == user.key).order(Request.start_time)
empty_requests = []
pending_requests = []
approved_requests = []
# Get User requests
my_requests = Request.query(Request.start_time >= alloted_time - datetime.timedelta(minutes=30),
Request.sender == user.key).order(Request.start_time).fetch()
for request in my_requests:
if len(request.bidders) > 0:
if request.recipient != None:
approved_requests.append(request)
else:
pending_requests.append(request)
for request in available_requests:
# Get all requests you didn't send
if request.sender != user.key:
# Request not accepted yet
if request.recipient == None:
# Check for bidders
for bid in request.bidders:
bid = bid.get()
if bid.name == user.username:
# Bid by user
pending_requests.append(request)
empty_requests.append(request)
else:
# Request has recipient
if request.recipient == user.key:
# You are recipient
approved_requests.append(request)
# Get sorted requests
l_requests = Request.query().order(Request.location).fetch()
location_requests = [r for r in l_requests if r.start_time >= alloted_time ]
location_requests = [r for r in location_requests if r.recipient == None]
p_requests = Request.query().order(Request.price).fetch()
price_requests = [r for r in p_requests if r.start_time >= alloted_time]
price_requests = [r for r in price_requests if r.recipient == None]
h_requests = Request.query(Request.interest == 'fun').order(Request.start_time).fetch()
hangouts_requests = [r for r in h_requests if r.start_time >= alloted_time]
hangouts_requests = [r for r in h_requests if r.recipient == None]
fl_requests = Request.query(Request.interest == 'food lesson').order(Request.start_time).fetch()
foodlesson_requests = [r for r in fl_requests if r.start_time >= alloted_time]
foodlesson_requests = [r for r in fl_requests if r.recipient == None]
#user.last_check = datetime.datetime.now() - datetime.timedelta(hours=8)
#print "Updated check time to: " , user.last_check
user.put()
for request in approved_requests:
print "Approved:"
print "Request:", request.key.urlsafe()
print "Sender:", request.sender.urlsafe()
print "Recipient:", request.recipient.urlsafe()
self.response.out.write(template.render('views/requests.html',
{'user': user, 'sorted_requests': sorted_requests, 'my_requests': my_requests,
'price_requests': price_requests, 'location_requests': location_requests, 'hangouts_requests': hangouts_requests,
'foodlesson_requests': foodlesson_requests, 'empty_requests': empty_requests,
'accepted_requests':approved_requests, 'pending_requests': pending_requests}))
def get(self, profile_id):
viewer = self.user_model
get_notifications(viewer)
viewer.last_check =datetime.datetime.now() - datetime.timedelta(hours=8)
viewer.put()
# Get profile info
profile_owner = User.query(User.username == profile_id).get()
profile = Profile.query(Profile.owner == profile_owner.key).get()
if not profile:
# If profile isn't created, instantiate
new_profile = Profile()
new_profile.owner = profile_owner.key
new_profile.about_me = "I love to eat food"
new_profile.put()
current_date = datetime.datetime.now() - datetime.timedelta(hours=8)
# Get profile history
history = Request.query(Request.start_time <= current_date, Request.sender == profile_owner.key).order(Request.start_time)
# Get Request regarding the user
reqs = []
timeline_requests = []
waiting_requests = []
my_reqs = []
fired_requests = []
table_reqs = []
pending_requests = []
accepted_requests = []
completed_reqs = []
alloted_time = current_date + datetime.timedelta(minutes=20)
# Get all requests where profile owner is foodie and expert
available_requests = Request.query(Request.start_time >= alloted_time).order(Request.start_time)
my_reqs = Request.query(ndb.OR(Request.sender==profile_owner.key, Request.recipient == profile_owner.key), Request.start_time >= alloted_time).order(Request.start_time).fetch()
dead_reqs = Request.query(ndb.OR(Request.sender==profile_owner.key, Request.recipient == profile_owner.key), Request.start_time <= alloted_time).order(Request.start_time).fetch()
# Get all pending request that user has bid on
for request in available_requests:
# Get all requests you didn't send
if request.sender != profile_owner.key:
# Request not accepted yet
if request.recipient == None:
# Check for bidders
for bid in request.bidders:
bid = bid.get()
if bid.name == profile_owner.username:
# Bid by user
pending_requests.append(request)
table_requests = my_reqs[:] + dead_reqs[:] + pending_requests[:]
table_requests = sorted(table_requests, key=lambda x: x.start_time, reverse=True)
waiting_requests = [x for x in table_requests if x.status == "waiting for a bid"]
accepted_requests = [x for x in table_requests if x.status == "accepted"]
timeline_requests = table_requests
pending_requests = [x for x in timeline_requests if x.status == "pending"]
pending_requests = sorted(pending_requests, key = lambda x: x.start_time, reverse=True)
timeline_requests = [x for x in timeline_requests if x.status != "waiting for a bid"]
timeline_requests = [x for x in timeline_requests if x.status != "pending"]
timeline_requests = [x for x in timeline_requests if x.status != "dead"]
timeline_requests = [x for x in timeline_requests if x.status != "accepted"]
timeline_comments = []
for r in timeline_requests:
c = Endorsement.query(Endorsement.request == r.key).fetch()
if c:
timeline_comments.append(c)
else:
timeline_comments.append("None")
timeline_requests = zip(timeline_requests, timeline_comments)
completed_requests = [x for x in timeline_requests if x[0].status == "complete"]
fired_requests = [x for x in timeline_requests if x[0].status == "fired"]
self.response.out.write(template.render('views/profile.html',
{'owner':profile_owner, 'profile':profile, 'history': history, 'user': viewer, 'timeline_requests': timeline_requests,
'pending_requests': pending_requests, 'accepted_requests': accepted_requests, 'completed_requests': completed_requests,
'waiting_requests': waiting_requests, 'fired_requests': fired_requests}))
def get(self):
user = self.user_model
search = self.request.get('search').lower().strip()
print "Search Term: ", search
#Seach for people
results = []
profiles = []
# Search for requests
available_requests = []
available_users = []
completed_requests = []
completed_users = []
current_time = datetime.datetime.now() - datetime.timedelta(hours=8)
# Check for type
food_type_requests = Request.query(Request.food_type == search).fetch()
food_type = [x for x in food_type_requests if x.start_time > current_time]
if food_type:
print "Type Match: "
for match in food_type:
sender = User.query(User.username == match.sender_name).get()
if match.recipient != None:
print 'STATUS: COMPLETED REQUESTS'
print match.sender_name, "requested:", match.food_type,"for:", match.start_time, "in:", match.location
completed_requests.append(match)
completed_users.append(sender)
else:
print 'STATUS: AVAILABLE REQUESTS'
print match.sender_name, "requested:", match.food_type,"for:", match.start_time, "in:", match.location
available_requests.append(match)
available_users.append(sender)
# Location Search
location_requests = Request.query(Request.location == search).fetch()
locations = [x for x in location_requests if x.start_time > current_time]
if locations:
print "Location Match: "
for match in locations:
sender = User.query(User.username == match.sender_name).get()
if match.recipient != None:
print 'STATUS: COMPLETED REQUESTS'
print match.sender_name, "requested:", match.food_type,"for:", match.start_time, "in:", match.location
completed_requests.append(match)
completed_users.append(sender)
else:
print 'STATUS: AVAILABLE REQUESTS'
print match.sender_name, "requested:", match.food_type,"for:", match.start_time, "in:", match.location
available_requests.append(match)
available_users.append(sender)
if ' ' in search:
search_list = search.split(' ')
# Full name
print "Full name search..."
full_name = User.query(User.l_first_name == search_list[0], User.l_last_name == search_list[1]).fetch()
for user in full_name:
profile = Profile.query(Profile.owner == user.key).get()
results.append(user)
profiles.append(profile)
else:
print "First, last, or username search..."
search_names = User.query(ndb.OR(User.l_first_name == search, User.l_last_name == search, User.username == search)).fetch()
for user in search_names:
profile = Profile.query(Profile.owner == user.key).get()
results.append(user)
profiles.append(profile)
results = zip(results, profiles)
available = zip(available_users, available_requests)
completed = zip(completed_users, completed_requests)
self.response.out.write(template.render('views/search.html',
{'user':user, 'search_results':results, 'available_requests':available, 'completed_requests':completed}))
