def post(self):
pictures = self.request.get_all('files[]')
results = []
if len(pictures) > 0:
stream_id = self.request.get('stream_id')
# print "stream name is ", stream_id
for image in pictures:
Stream.insert_with_lock(stream_id, image)
results.append({'name': '', 'url': '', 'type': '', 'size': 0})
s = json.dumps({'files': results}, separators=(',', ':'))
self.response.headers['Content-Type'] = 'application/json'
# print "duming material is ", s
return self.response.write(s)
def post(self):
pictures = self.request.get_all('files[]')
results = []
if len(pictures) > 0:
stream_id = self.request.get('stream_id')
# print "stream name is ", stream_id
for image in pictures:
Stream.insert_with_lock(stream_id, image)
results.append({'name': '', 'url': '', 'type': '', 'size': 0})
s = json.dumps({'files': results}, separators=(',', ':'))
self.response.headers['Content-Type'] = 'application/json'
# print "duming material is ", s
return self.response.write(s)
def post(self):
print 'stream id is', self.request.get('stream_id')
try:
upload = self.get_uploads()[0]
print "upload size is", len(self.get_uploads())
print "before error1"
print users.get_current_user().nickname()
user = users.get_current_user()
ancestor_key = ndb.Key('User', str(user))
user_streams = Stream.query_stream(ancestor_key).fetch()
for stream in user_streams:
if stream.stream_id == self.request.get('stream_id'):
print 'find my stream'
print type(stream.blob_key)
stream.blob_key.insert(0, upload.key())
stream.num_images += 1
stream.last_add = str(datetime.now())
stream.put()
info = {'stream_id': self.request.get('stream_id')}
info = urllib.urlencode(info)
self.redirect('/view_single?' + info)
except:
print "error!"
def get(self):
pattern = self.request.get("qry")
print pattern
all_streams = Stream.query(Stream.stream_id != '').fetch()
search_result = []
if pattern:
for stream in all_streams:
if pattern in stream.tags:
stream_id = stream.stream_id
blob_key_list = stream.blob_key
if stream.cover_url != '':
image_url = stream.cover_url
elif len(blob_key_list) == 0:
image_url = ''
else:
image_url = images.get_serving_url(blob_key_list[0])
result = ShowStream(image_url, 0, stream_id)
search_result.append(result)
template_values = {
'nav_links': USER_NAV_LINKS,
'path': os.path.basename(self.request.path).capitalize(),
'user_id': self.request.get('user_id'),
'query_results': search_result,
}
template = JINJA_ENVIRONMENT.get_template('search.html')
self.response.write(template.render(template_values))
def get(self):
user = users.get_current_user()
stream_id = self.request.get('stream_id')
print 'stream id is', stream_id
info = {'stream_id': self.request.get('stream_id')}
info = urllib.urlencode(info)
upload_url = blobstore.create_upload_url('/upload_image?'+info)
# we should use the actual user
user_streams = Stream.query(Stream.stream_id == stream_id).fetch()
blob_key_list = []
image_url = [""] * 3
stream = user_streams[0]
owner = stream.owner
print 'stream id is', stream.stream_id
if owner != str(user):
stream.views += 1
while len(stream.view_queue) > 0 and (datetime.now() - stream.view_queue[0]).seconds > 3600:
del stream.view_queue[0]
stream.view_queue.append(datetime.now())
stream.put()
blob_key_list = stream.blob_key #get blob_key_list should be after stream.put()
counter = 0
has_image = True
if len(blob_key_list) > 0:
for blob_key in blob_key_list:
image_url[counter] = images.get_serving_url(blob_key)
counter += 1
if counter == 3:
break;
#calculate hasSub
qry = StreamInfo.query_stream(ndb.Key('User', str(user))).fetch()
has_sub = False
if len(qry) == 0:
has_sub = False
else:
for key in qry[0].subscribed:
if key.get().stream_id == stream_id:
has_sub = True
break
template_values = {
'nav_links': USER_NAV_LINKS,
'path': os.path.basename(self.request.path).capitalize(),
'owner': owner, #the owner of the stream
'user': str(users.get_current_user()), #current user
'upload_url': upload_url,
'image_url': image_url,
'has_image': has_image,
'hasSub': has_sub,
'stream_id': stream_id,
}
print "owner is ", template_values['owner']
print "user is ", template_values['user']
template = JINJA_ENVIRONMENT.get_template('viewstream.html')
self.response.write(template.render(template_values))
def post(self):
pictures = self.request.get_all('files')
results = []
print "Android_upload called"
if len(pictures) > 0:
stream_id = self.request.get('stream_id')
print "stream name is ", stream_id
str_lon = self.request.get('longitude')
str_lat = self.request.get('latitude')
print str_lon + " " + str_lat
for image in pictures:
if str_lon == "" or str_lat == "":
Stream.insert_with_lock(stream_id,image)
else:
Stream.insert_with_lock(stream_id, image,False,float(str_lat),float(str_lon))
def get(self):
target_long = (float)(self.request.get('longitude'))
target_lat = (float)(self.request.get('latitude'))
streams = Stream.query(Stream.stream_id != '').fetch()
image_url = []
for stream in streams:
image_query = db.GqlQuery("SELECT *FROM Image WHERE ANCESTOR IS :1 ORDER BY upload_date DESC",
db.Key.from_path('Stream', stream.stream_id))
for image in image_query[0:stream.num_images]:
d = dict()
d["url"] = SERVICES_URL + "image?image_id=" + str(image.key())
d["stream_id"] = stream.stream_id
d["long"] = image.geo_loc.lon
d["lat"] = image.geo_loc.lat
image_url.append(d)
mycmp = lambda a, b: (int)((target_long - a["long"]) * (target_long - a["long"]) +
(target_lat - a["lat"]) * (target_lat - a["lat"]) -
(target_long - b["long"]) * (target_long - b["long"]) -
(target_lat - b["lat"]) * (target_lat - b["lat"]))
image_url.sort(mycmp)
dict_passed = {'displayImages': image_url}
json_obj = json.dumps(dict_passed, sort_keys=True, indent=4, separators=(',', ': '))
self.response.write(json_obj)
def post(self):
user = users.get_current_user()
stream_id = self.request.get('stream_id')
print 'first', stream_id
streams = Stream.query(Stream.stream_id != '').fetch()
for stream in streams:
print 'hi', stream.stream_id
if stream.stream_id == stream_id:
info = {'error': 'you tried to create a stream whose name already existed'}
info = urllib.urlencode(info)
self.redirect('/error?'+info)
return
if self.request.get("subscribers"):
mail.send_mail(sender=str(user)+"<"+str(user)+"@gmail.com>",
to="<"+self.request.get("subscribers")+">",
subject="Please subscribe my stream",
body=self.request.get("message"))
form = {'stream_id': self.request.get('stream_id'),
'user_id': str(users.get_current_user()),
'tags': self.request.get('tags'),
# 'subscribers': self.request.get('subscribers'),
'cover_url': self.request.get('cover_url'),
'owner': str(users.get_current_user()),
'views': 0,
}
form_data = json.dumps(form)
result = urlfetch.fetch(payload=form_data, url=SERVICES_URL + 'create_a_new_stream',
method=urlfetch.POST, headers={'Content-Type': 'application/json'})
self.redirect('/manage')
def get(self):
user = users.get_current_user()
stream_id = self.request.get("stream_id")
print "stream id is", stream_id
info = {"stream_id": self.request.get("stream_id")}
info = urllib.urlencode(info)
upload_url = blobstore.create_upload_url("/upload_image?" + info)
# we should use the actual user
user_streams = Stream.query(Stream.stream_id == stream_id).fetch()
blob_key_list = []
image_url = [""] * 3
stream = user_streams[0]
owner = stream.owner
print "stream id is", stream.stream_id
if owner != str(user):
stream.views += 1
while len(stream.view_queue) > 0 and (datetime.now() - stream.view_queue[0]).seconds > 3600:
del stream.view_queue[0]
stream.view_queue.append(datetime.now())
stream.put()
blob_key_list = stream.blob_key # get blob_key_list should be after stream.put()
counter = 0
has_image = True
if len(blob_key_list) > 0:
for blob_key in blob_key_list:
image_url[counter] = images.get_serving_url(blob_key)
counter += 1
if counter == 3:
break
# calculate hasSub
qry = StreamInfo.query_stream(ndb.Key("User", str(user))).fetch()
has_sub = False
if len(qry) == 0:
has_sub = False
else:
for key in qry[0].subscribed:
if (not key) and key.get().stream_id == stream_id:
has_sub = True
break
template_values = {
"nav_links": USER_NAV_LINKS,
"path": os.path.basename(self.request.path).capitalize(),
"owner": owner, # the owner of the stream
"user": str(users.get_current_user()), # current user
"upload_url": upload_url,
"image_url": image_url,
"has_image": has_image,
"hasSub": has_sub,
"stream_id": stream_id,
}
print "owner is ", template_values["owner"]
print "user is ", template_values["user"]
template = JINJA_ENVIRONMENT.get_template("viewstream.html")
self.response.write(template.render(template_values))
def get(self):
pattern = self.request.get("qry")
print pattern
all_streams = Stream.query(Stream.stream_id != '').fetch()
search_result = []
if pattern:
for stream in all_streams:
if pattern in stream.tags:
stream_id = stream.stream_id
if stream.cover_url != '':
image_url = stream.cover_url
else:
image_url = "https://encrypted-tbn0.gstatic.com/images?" + \
"q=tbn:ANd9GcQ3DFxGhXSmn0MHjbEEtw-0N9sDKhyIP7tM_r3Wo1mY7WhY2xvZ"
result = ShowStream(image_url, 0, stream_id)
search_result.append(result)
template_values = {
'nav_links': USER_NAV_LINKS,
'path': os.path.basename(self.request.path).capitalize(),
'user_id': self.request.get('user_id'),
'query_results': search_result,
}
template = JINJA_ENVIRONMENT.get_template('search.html')
self.response.write(template.render(template_values))
def get(self):
user = users.get_current_user()
print 'user is ', user
subscribed_streams = []
qry = StreamInfo.query_stream(ndb.Key('User', str(user))).fetch()
if len(qry) > 0:
for key in qry[0].subscribed:
subscribed_streams.append(key.get())
print subscribed_streams
template_values = {
'nav_links': USER_NAV_LINKS,
'path': os.path.basename(self.request.path).capitalize(),
'user_id': users.get_current_user(),
'user_streams': Stream.query(Stream.owner == str(user)).fetch(),
'subscribed_streams': subscribed_streams,
'usr': user,
}
# all_streams = Stream.query(Stream.stream_id != '').fetch()
# for s in all_streams:
# print s.stream_id
#
# print 'length of user_stream', len(template_values['user_streams'])
# print 'length of subscribed streams', len(template_values['subscribed_streams'])
template = JINJA_ENVIRONMENT.get_template('manage.html')
self.response.write(template.render(template_values))
print "in manage page, "
def get(self):
pattern = self.request.get("qry")
print pattern
all_streams = Stream.query(Stream.stream_id != '').fetch()
search_result = []
if pattern:
for stream in all_streams:
if pattern in stream.tags:
stream_id = stream.stream_id
if stream.cover_url != '':
image_url = stream.cover_url
else:
image_url = "https://encrypted-tbn0.gstatic.com/images?" + \
"q=tbn:ANd9GcQ3DFxGhXSmn0MHjbEEtw-0N9sDKhyIP7tM_r3Wo1mY7WhY2xvZ"
result = ShowStream(image_url, 0, stream_id)
search_result.append(result)
template_values = {
'nav_links': USER_NAV_LINKS,
'path': os.path.basename(self.request.path).capitalize(),
'user_id': self.request.get('user_id'),
'query_results': search_result,
}
template = JINJA_ENVIRONMENT.get_template('search.html')
self.response.write(template.render(template_values))
def get(self):
user = users.get_current_user()
print 'user is ', user
subscribed_streams = []
qry = StreamInfo.query_stream(ndb.Key('User', str(user))).fetch()
if len(qry) > 0:
for key in qry[0].subscribed:
subscribed_streams.append(key.get())
print subscribed_streams
template_values = {
'nav_links': USER_NAV_LINKS,
'path': os.path.basename(self.request.path).capitalize(),
'user_id': users.get_current_user(),
'user_streams': Stream.query(Stream.owner == str(user)).fetch(),
'subscribed_streams': subscribed_streams,
'usr': user,
}
# all_streams = Stream.query(Stream.stream_id != '').fetch()
# for s in all_streams:
# print s.stream_id
#
# print 'length of user_stream', len(template_values['user_streams'])
# print 'length of subscribed streams', len(template_values['subscribed_streams'])
template = JINJA_ENVIRONMENT.get_template('manage.html')
self.response.write(template.render(template_values))
print "in manage page, "
def get(self):
print 'in report handler', str(users.get_current_user())
# data = json.loads(self.request.body)
# user = data['user']
print "NOW RATE BECOMES", REPORT_RATE_MINUTES
if REPORT_RATE_MINUTES == '0':
return
global LAST_REPORT
if not LAST_REPORT:
LAST_REPORT = datetime.now()
print "because LAST_REPORT is not set, i return"
return
delta = (datetime.now() - LAST_REPORT).seconds
if delta < int(REPORT_RATE_MINUTES) * 60:
print "because delta is not enough, i return"
return
LAST_REPORT = datetime.now()
#get trending information to send
first_three = []
all_streams = Stream.query(Stream.stream_id != '').fetch()
mycmp = lambda x, y: (len(y.view_queue) - len(x.view_queue))
all_streams.sort(mycmp)
size = 3 if (len(all_streams) - 3) > 0 else len(all_streams)
print size
for i in range(size):
stream = all_streams[i]
print "current stream is", stream.stream_id
views = len(stream.view_queue)
stream_id = stream.stream_id
blob_key_list = stream.blob_key
if stream.cover_url != '':
image_url = stream.cover_url
elif len(blob_key_list) == 0:
image_url = ''
else:
image_url = images.get_serving_url(blob_key_list[0])
trending_stream = ShowStream(image_url, views, stream_id)
print "current trending stream is", trending_stream
first_three.append(trending_stream)
print trending_stream.url
print "end for loop"
message = "Top three trending streams:"
for element in first_three:
message += element.stream_id + " viewed by " + str(element.views) + " times; "
print "message is *******************", message
mail.send_mail(sender="libo <*****@*****.**>",
to="<*****@*****.**>",
subject="Trending Report",
body=message)
print message
return
def post(self):
data = json.loads(self.request.body)
user = data['user']
for stream_id in data['stream_id']:
qry = Stream.query(Stream.stream_id == stream_id).fetch()
if len(qry) > 0:
qry[0].key.delete()
self.redirect('/manage')
def get(self):
user = users.get_current_user()
stream_id = self.request.get('stream_id')
print 'stream id is', stream_id
info = {'stream_id': self.request.get('stream_id')}
info = urllib.urlencode(info)
# we should use the actual user
user_streams = Stream.query(Stream.stream_id == stream_id).fetch()
stream = user_streams[0]
owner = stream.owner
print 'stream id is', stream.stream_id
if owner != str(user):
stream.views += 1
stream.view_queue.append(datetime.now())
stream.put()
has_image = True
image_url = []
image_query = db.GqlQuery("SELECT *FROM Image WHERE ANCESTOR IS :1 ORDER BY upload_date DESC",
db.Key.from_path('Stream', stream.stream_id))
# for image in image_query[0: len(stream.image_list)]:
for image in image_query[0:stream.num_images]:
d = dict()
d["url"] = "image?image_id=" + str(image.key())
d["lat"] = str(image.geo_loc.lat)
d["long"] = str(image.geo_loc.lon)
image_url.append(d)
#calculate hasSub
qry = StreamInfo.query_stream(ndb.Key('User', str(user))).fetch()
has_sub = False
if len(qry) == 0:
has_sub = False
else:
for key in qry[0].subscribed:
if key.get().stream_id == stream_id:
has_sub = True
break
template_values = {
'nav_links': USER_NAV_LINKS,
'path': os.path.basename(self.request.path).capitalize(),
'owner': owner, #the owner of the stream
'user': str(users.get_current_user()), #current user
'image_url': image_url,
'has_image': has_image,
'hasSub': has_sub,
'stream_id': stream_id,
}
print "owner is ", template_values['owner']
print "user is ", template_values['user']
template = JINJA_ENVIRONMENT.get_template('viewMoreWithMap.html')
self.response.write(template.render(template_values))
def get(self):
user = users.get_current_user()
stream_id = self.request.get('stream_id')
print 'stream id is', stream_id
info = {'stream_id': self.request.get('stream_id')}
info = urllib.urlencode(info)
# we should use the actual user
user_streams = Stream.query(Stream.stream_id == stream_id).fetch()
stream = user_streams[0]
owner = stream.owner
print 'stream id is', stream.stream_id
if owner != str(user):
stream.views += 1
stream.view_queue.append(datetime.now())
stream.put()
has_image = True
image_url = []
image_query = db.GqlQuery(
"SELECT *FROM Image WHERE ANCESTOR IS :1 ORDER BY upload_date DESC",
db.Key.from_path('Stream', stream.stream_id))
# for image in image_query[0: len(stream.image_list)]:
for image in image_query[0:stream.num_images]:
d = dict()
d["url"] = "image?image_id=" + str(image.key())
d["lat"] = str(image.geo_loc.lat)
d["long"] = str(image.geo_loc.lon)
image_url.append(d)
#calculate hasSub
qry = StreamInfo.query_stream(ndb.Key('User', str(user))).fetch()
has_sub = False
if len(qry) == 0:
has_sub = False
else:
for key in qry[0].subscribed:
if key.get().stream_id == stream_id:
has_sub = True
break
template_values = {
'nav_links': USER_NAV_LINKS,
'path': os.path.basename(self.request.path).capitalize(),
'owner': owner, #the owner of the stream
'user': str(users.get_current_user()), #current user
'image_url': image_url,
'has_image': has_image,
'hasSub': has_sub,
'stream_id': stream_id,
}
print "owner is ", template_values['owner']
print "user is ", template_values['user']
template = JINJA_ENVIRONMENT.get_template('viewMoreWithMap.html')
self.response.write(template.render(template_values))
def post(self):
data = json.loads(self.request.body)
user = data['user']
for stream_id in data['stream_id']:
qry = Stream.query(Stream.stream_id == stream_id).fetch()
if len(qry) > 0:
qry[0].key.delete()
self.redirect('/manage')
def post(self):
data = json.loads(self.request.body)
user = data['user_id']
print user, ' is creating'
new_stream = Stream(parent=ndb.Key('User', user),
stream_id=data['stream_id'],
user_id=data['user_id'],
tags=data['tags'],
cover_url=data['cover_url'] if 'cover_url' in data else '',
views=0,
num_images=0,
last_add=str(datetime.now()),
owner=data['owner'],
)
new_stream.put()
result = json.dumps({'status': '0'})
self.response.write(result)
def post(self):
print "************delete stream******************"
data = json.loads(self.request.body)
user = data['user']
for stream_id in data['stream_id']:
qry = Stream.query(Stream.stream_id == stream_id).fetch()
if len(qry) > 0:
#delete all the images in this stream
image_query = db.GqlQuery("SELECT *FROM Image WHERE ANCESTOR IS :1 ORDER BY upload_date DESC",
db.Key.from_path('Stream', stream_id))
for image in image_query[0:qry[0].num_images]:
image.delete()
print "******************delete images"
Stream.reset_image_num(qry[0].stream_id)
#delete stream
qry[0].key.delete()
self.redirect('/manage')
def post(self):
data = json.loads(self.request.body)
user = data["user_id"]
print user, " is creating"
new_stream = Stream(
parent=ndb.Key("User", user),
stream_id=data["stream_id"],
user_id=data["user_id"],
tags=data["tags"],
cover_url=data["cover_url"] if "cover_url" in data else "",
views=0,
num_images=0,
last_add=str(datetime.now()),
owner=data["owner"],
)
new_stream.put()
result = json.dumps({"status": "0"})
self.response.write(result)
def post(self):
data = json.loads(self.request.body)
user = data['user_id']
print user, ' is creating'
new_stream = Stream(
parent=ndb.Key('User', user),
stream_id=data['stream_id'],
user_id=data['user_id'],
tags=data['tags'],
cover_url=data['cover_url'] if 'cover_url' in data else '',
views=0,
num_images=0,
last_add=str(datetime.now()),
owner=data['owner'],
)
new_stream.put()
result = json.dumps({'status': '0'})
self.response.write(result)
def get(self):
print 'in report handler', str(users.get_current_user())
print "NOW RATE BECOMES", REPORT_RATE_MINUTES
if REPORT_RATE_MINUTES == '0':
return
global LAST_REPORT
if not LAST_REPORT:
LAST_REPORT = datetime.now()
print "because LAST_REPORT is not set, i return"
return
delta = (datetime.now() - LAST_REPORT).seconds
if delta < int(REPORT_RATE_MINUTES) * 60:
print "because delta is not enough, i return"
return
LAST_REPORT = datetime.now()
#get trending information to send
first_three = []
all_streams = Stream.query(Stream.stream_id != '').fetch()
mycmp = lambda x, y: (len(y.view_queue) - len(x.view_queue))
all_streams.sort(mycmp)
size = 3 if (len(all_streams) - 3) > 0 else len(all_streams)
print size
for i in range(size):
stream = all_streams[i]
print "current stream is", stream.stream_id
views = len(stream.view_queue)
stream_id = stream.stream_id
if stream.cover_url != '':
image_url = stream.cover_url
else:
image_url = "https://encrypted-tbn0.gstatic.com/images?" \
"q=tbn:ANd9GcQ3DFxGhXSmn0MHjbEEtw-0N9sDKhyIP7tM_r3Wo1mY7WhY2xvZ"
trending_stream = ShowStream(image_url, views, stream_id)
print "current trending stream is", trending_stream
first_three.append(trending_stream)
print trending_stream.url
print "end for loop"
message = "Top three trending streams:"
for element in first_three:
message += element.stream_id + " viewed by " + str(
element.views) + " times; "
print "message is *******************", message
mail.send_mail(sender="libo <*****@*****.**>",
to="<*****@*****.**>",
subject="Trending Report",
body=message)
print message
return
def get(self):
print 'in report handler', str(users.get_current_user())
print "NOW RATE BECOMES", REPORT_RATE_MINUTES
if REPORT_RATE_MINUTES == '0':
return
global LAST_REPORT
if not LAST_REPORT:
LAST_REPORT = datetime.now()
print "because LAST_REPORT is not set, i return"
return
delta = (datetime.now() - LAST_REPORT).seconds
if delta < int(REPORT_RATE_MINUTES) * 60:
print "because delta is not enough, i return"
return
LAST_REPORT = datetime.now()
#get trending information to send
first_three = []
all_streams = Stream.query(Stream.stream_id != '').fetch()
mycmp = lambda x, y: (len(y.view_queue) - len(x.view_queue))
all_streams.sort(mycmp)
size = 3 if (len(all_streams) - 3) > 0 else len(all_streams)
print size
for i in range(size):
stream = all_streams[i]
print "current stream is", stream.stream_id
views = len(stream.view_queue)
stream_id = stream.stream_id
if stream.cover_url != '':
image_url = stream.cover_url
else:
image_url = "https://encrypted-tbn0.gstatic.com/images?" \
"q=tbn:ANd9GcQ3DFxGhXSmn0MHjbEEtw-0N9sDKhyIP7tM_r3Wo1mY7WhY2xvZ"
trending_stream = ShowStream(image_url, views, stream_id)
print "current trending stream is", trending_stream
first_three.append(trending_stream)
print trending_stream.url
print "end for loop"
message = "Top three trending streams:"
for element in first_three:
message += element.stream_id + " viewed by " + str(element.views) + " times; "
print "message is *******************", message
mail.send_mail(sender="libo <*****@*****.**>",
to="<*****@*****.**>",
subject="Trending Report",
body=message)
print message
return
def get(self):
streams = Stream.query(Stream.stream_id != '').fetch()
image_info = []
for stream in streams:
image_info.append([stream.cover_url, stream.stream_id])
template_values = {
'nav_links': USER_NAV_LINKS,
'path': os.path.basename(self.request.path).capitalize(),
}
template = JINJA_ENVIRONMENT.get_template('geomap.html')
self.response.write(template.render(template_values))
def get(self):
streams = Stream.query(Stream.stream_id != '').fetch()
image_info = []
for stream in streams:
image_info.append([stream.cover_url, stream.stream_id])
template_values = {
'nav_links': USER_NAV_LINKS,
'path': os.path.basename(self.request.path).capitalize(),
}
template = JINJA_ENVIRONMENT.get_template('geomap.html')
self.response.write(template.render(template_values))
def get(self):
print "updating top 3 popular streams"
first_three = []
all_streams = Stream.query(Stream.stream_id != '').fetch()
mycmp = lambda x, y: (len(y.view_queue) - len(x.view_queue))
all_streams.sort(mycmp)
size = 3 if (len(all_streams) - 3) > 0 else len(all_streams)
print size
for i in range(size):
stream = all_streams[i]
#print "current stream is", stream
views = len(stream.view_queue)
stream_id = stream.stream_id
blob_key_list = stream.blob_key
if stream.cover_url != '':
image_url = stream.cover_url
elif len(blob_key_list) == 0:
image_url = ''
else:
image_url = images.get_serving_url(blob_key_list[0])
trending_stream = ShowStream(image_url, views, stream_id)
print "current trending stream is", trending_stream
first_three.append(trending_stream)
print trending_stream.url
print "end for loop"
checked = [""] * 4
cur_rate = REPORT_RATE_MINUTES;
if cur_rate:
if cur_rate == '0':
checked[0] = "checked=checked"
elif cur_rate == '5':
checked[1] = "checked=checked"
elif cur_rate == '60':
checked[2] = "checked=checked"
elif cur_rate == '1440':
checked[3] = "checked=checked"
else:
checked[0] = "checked=checked"
template_values = {
'nav_links': USER_NAV_LINKS,
'path': os.path.basename(self.request.path).capitalize(),
'user_id': self.request.get('user_id'),
'streams': first_three,
'checked': checked,
}
template = JINJA_ENVIRONMENT.get_template('trending.html')
self.response.write(template.render(template_values))
def get(self):
print "updating top 3 popular streams"
first_three = []
all_streams = Stream.query(Stream.stream_id != '').fetch()
mycmp = lambda x, y: (len(y.view_queue) - len(x.view_queue))
all_streams.sort(mycmp)
size = 3 if (len(all_streams) - 3) > 0 else len(all_streams)
print size
for i in range(size):
stream = all_streams[i]
#print "current stream is", stream
views = len(stream.view_queue)
stream_id = stream.stream_id
if stream.cover_url != '':
image_url = stream.cover_url
else:
image_url = "https://encrypted-tbn0.gstatic.com/images?" + \
"q=tbn:ANd9GcQ3DFxGhXSmn0MHjbEEtw-0N9sDKhyIP7tM_r3Wo1mY7WhY2xvZ"
trending_stream = ShowStream(image_url, views, stream_id)
print "current trending stream is", trending_stream
first_three.append(trending_stream)
print trending_stream.url
print "end for loop"
checked = [""] * 4
cur_rate = REPORT_RATE_MINUTES;
if cur_rate:
if cur_rate == '0':
checked[0] = "checked=checked"
elif cur_rate == '5':
checked[1] = "checked=checked"
elif cur_rate == '60':
checked[2] = "checked=checked"
elif cur_rate == '1440':
checked[3] = "checked=checked"
else:
checked[0] = "checked=checked"
template_values = {
'nav_links': USER_NAV_LINKS,
'path': os.path.basename(self.request.path).capitalize(),
'user_id': self.request.get('user_id'),
'streams': first_three,
'checked': checked,
}
template = JINJA_ENVIRONMENT.get_template('trending.html')
self.response.write(template.render(template_values))
def get(self):
print "updating top 3 popular streams"
first_three = []
all_streams = Stream.query(Stream.stream_id != '').fetch()
mycmp = lambda x, y: (len(y.view_queue) - len(x.view_queue))
all_streams.sort(mycmp)
size = 3 if (len(all_streams) - 3) > 0 else len(all_streams)
print size
for i in range(size):
stream = all_streams[i]
#print "current stream is", stream
views = len(stream.view_queue)
stream_id = stream.stream_id
if stream.cover_url != '':
image_url = stream.cover_url
else:
image_url = "https://encrypted-tbn0.gstatic.com/images?" + \
"q=tbn:ANd9GcQ3DFxGhXSmn0MHjbEEtw-0N9sDKhyIP7tM_r3Wo1mY7WhY2xvZ"
trending_stream = ShowStream(image_url, views, stream_id)
print "current trending stream is", trending_stream
first_three.append(trending_stream)
print trending_stream.url
print "end for loop"
checked = [""] * 4
cur_rate = REPORT_RATE_MINUTES
if cur_rate:
if cur_rate == '0':
checked[0] = "checked=checked"
elif cur_rate == '5':
checked[1] = "checked=checked"
elif cur_rate == '60':
checked[2] = "checked=checked"
elif cur_rate == '1440':
checked[3] = "checked=checked"
else:
checked[0] = "checked=checked"
template_values = {
'nav_links': USER_NAV_LINKS,
'path': os.path.basename(self.request.path).capitalize(),
'user_id': self.request.get('user_id'),
'streams': first_three,
'checked': checked,
}
template = JINJA_ENVIRONMENT.get_template('trending.html')
self.response.write(template.render(template_values))
def post(self):
data = json.loads(self.request.body)
user = data["user"]
for stream_id in data["stream_id"]:
qry = Stream.query(Stream.stream_id == stream_id).fetch()
if len(qry) > 0:
qry[0].key.delete()
#########helper code to delete zombie stream
# streams = Stream.query(Stream.stream_id != '').fetch()
# for stream in streams:
# if stream.stream_id == "ereraefdas":
# stream.key.delete()
self.redirect("/manage")
def get(self):
streams = Stream.query(Stream.stream_id != '').fetch()
print type(streams)
stream_url = []
stream_ids = []
for stream in streams:
stream_ids.append(stream.stream_id)
if stream.cover_url:
stream_url.append(stream.cover_url)
else:
stream_url.append(default_preface)
name = self.request.get('user_id')
print "adroid user is ", name
dict_passed = {'displayImages': stream_url, 'streamId': stream_ids, 'name': name}
json_obj = json.dumps(dict_passed, sort_keys=True, indent=4, separators=(',', ': '))
self.response.write(json_obj)
def get(self):
user = self.request.get('user_id')
stream_id = self.request.get('stream_id')
print 'stream id is', stream_id
# we should use the actual user
user_streams = Stream.query(Stream.stream_id == stream_id).fetch()
stream = user_streams[0]
owner = stream.owner
print 'stream id is', stream.stream_id
my_own = True
if owner != str(user):
my_own = False
stream.views += 1
stream.view_queue.append(datetime.now())
stream.put()
image_url = []
image_query = db.GqlQuery("SELECT *FROM Image WHERE ANCESTOR IS :1 ORDER BY upload_date DESC",
db.Key.from_path('Stream', stream.stream_id))
# for image in image_query[0: len(stream.image_list)]:
for image in image_query[0:stream.num_images]:
d = dict()
d["url"] = SERVICES_URL +"image?image_id=" + str(image.key())
d["lat"] = str(image.geo_loc.lat)
d["long"] = str(image.geo_loc.lon)
image_url.append(d)
#calculate hasSub
qry = StreamInfo.query_stream(ndb.Key('User', str(user))).fetch()
has_sub = False
if len(qry) == 0:
has_sub = False
else:
for key in qry[0].subscribed:
if key.get().stream_id == stream_id:
has_sub = True
break
dict_passed = {'displayImages': image_url, 'myOwn': my_own, 'hasSub': has_sub}
json_obj = json.dumps(dict_passed, sort_keys=True, indent=4, separators=(',', ': '))
self.response.write(json_obj)
def get(self):
streams = Stream.query(Stream.stream_id != '').fetch()
print type(streams)
image_url = []
for stream in streams:
if stream.cover_url:
image_url.append([stream.cover_url, stream.stream_id])
else:
image_url.append([default_preface, stream.stream_id])
template_values = {
'nav_links': USER_NAV_LINKS,
'path': os.path.basename(self.request.path).capitalize(),
'user': self.request.get('user'),
'image_url': image_url,
}
template = JINJA_ENVIRONMENT.get_template('viewall.html')
self.response.write(template.render(template_values))
def get(self):
pattern = self.request.get("term")
print pattern
all_streams = Stream.query(Stream.stream_id != '').fetch()
ret_tags = []
if pattern:
for stream in all_streams:
if pattern in stream.tags:
ret_tags.append(stream.tags)
ret_tags.sort();
if len(ret_tags) == 0:
ready = False
else:
ready = True
context = {"ready": ready, "tags": ret_tags}
print context
self.response.write(json.dumps(context))
def get(self):
streams = Stream.query(Stream.stream_id != '').fetch()
print type(streams)
image_url = []
for stream in streams:
if stream.cover_url:
image_url.append([stream.cover_url, stream.stream_id])
else:
image_url.append([default_preface, stream.stream_id])
template_values = {
'nav_links': USER_NAV_LINKS,
'path': os.path.basename(self.request.path).capitalize(),
'user': self.request.get('user'),
'image_url': image_url,
}
template = JINJA_ENVIRONMENT.get_template('viewall.html')
self.response.write(template.render(template_values))
def get(self):
pattern = self.request.get("term")
print pattern
all_streams = Stream.query(Stream.stream_id != '').fetch()
ret_tags = []
if pattern:
for stream in all_streams:
if pattern in stream.tags:
ret_tags.append(stream.tags)
ret_tags.sort()
if len(ret_tags) == 0:
ready = False
else:
ready = True
context = {"ready": ready, "tags": ret_tags}
print context
self.response.write(json.dumps(context))
def post(self):
user = users.get_current_user()
stream_id = self.request.get("stream_id")
print "first", stream_id
streams = Stream.query(Stream.stream_id != "").fetch()
for stream in streams:
print "hi", stream.stream_id
if stream.stream_id == stream_id:
print "change the world change the world"
info = {"error": "you tried to create a stream whose name already existed"}
info = urllib.urlencode(info)
self.redirect("/error?" + info)
return
if self.request.get("subscribers"):
mail.send_mail(
sender=str(user) + "<" + str(user) + "@gmail.com>",
to="<" + self.request.get("subscribers") + ">",
subject="Please subscribe my stream",
body=self.request.get("message"),
)
form = {
"stream_id": self.request.get("stream_id"),
"user_id": str(users.get_current_user()),
"tags": self.request.get("tags"),
# 'subscribers': self.request.get('subscribers'),
"cover_url": self.request.get("cover_url"),
"owner": str(users.get_current_user()),
"views": 0,
}
form_data = json.dumps(form)
result = urlfetch.fetch(
payload=form_data,
url="http://mini-project-phase1.appspot.com/create_a_new_stream",
method=urlfetch.POST,
headers={"Content-Type": "application/json"},
)
# result = urlfetch.fetch(payload=form_data, url='http://mini-project-phase1.appspot.com/create_a_new_stream',
# method=urlfetch.POST, headers={'Content-Type': 'application/json'})
self.redirect("/manage")
def get(self):
streams = Stream.query(Stream.stream_id != "").fetch()
print type(streams)
image_url = []
for stream in streams:
if stream.cover_url:
image_url.append([stream.cover_url, stream.stream_id])
else:
blob_key_list = stream.blob_key
if len(blob_key_list) > 0:
blob_key = blob_key_list[0]
image_url.append([images.get_serving_url(blob_key), stream.stream_id])
template_values = {
"nav_links": USER_NAV_LINKS,
"path": os.path.basename(self.request.path).capitalize(),
"user": self.request.get("user"),
"image_url": image_url,
}
template = JINJA_ENVIRONMENT.get_template("viewall.html")
self.response.write(template.render(template_values))
def post(self):
data = json.loads(self.request.body)
user = data["user"]
stream_id = data["stream_id"]
print stream_id, "hello"
qry = Stream.query(Stream.stream_id == stream_id).fetch()
print "lenght of qry is ", len(qry)
ancestor_key = ndb.Key("User", user)
stream_info = StreamInfo.query_stream(ancestor_key).fetch()
if len(stream_info) == 0:
print "create a new stream_info"
new_stream_info = StreamInfo(parent=ndb.Key("User", user))
new_stream_info.subscribed.insert(0, qry[0].key)
new_stream_info.put()
else:
new_stream_info = stream_info[0]
new_stream_info.subscribed.insert(0, qry[0].key)
new_stream_info.put()
print "finished"
self.redirect("/manage")
def post(self):
data = json.loads(self.request.body)
user = data['user']
stream_id = data['stream_id']
print stream_id, 'hello'
qry = Stream.query(Stream.stream_id == stream_id).fetch()
print 'lenght of qry is ', len(qry)
ancestor_key = ndb.Key('User', user)
stream_info = StreamInfo.query_stream(ancestor_key).fetch()
if len(stream_info) == 0:
print 'create a new stream_info'
new_stream_info = StreamInfo(parent=ndb.Key('User', user))
new_stream_info.subscribed.insert(0, qry[0].key)
new_stream_info.put()
else:
new_stream_info = stream_info[0]
new_stream_info.subscribed.insert(0, qry[0].key)
new_stream_info.put()
print 'finished'
self.redirect('/manage')
def post(self):
data = json.loads(self.request.body)
user = data['user']
stream_id = data['stream_id']
print stream_id, 'hello'
qry = Stream.query(Stream.stream_id == stream_id).fetch()
print 'lenght of qry is ', len(qry)
ancestor_key = ndb.Key('User', user)
stream_info = StreamInfo.query_stream(ancestor_key).fetch()
if len(stream_info) == 0:
print 'create a new stream_info'
new_stream_info = StreamInfo(parent=ndb.Key('User', user))
new_stream_info.subscribed.insert(0, qry[0].key)
new_stream_info.put()
else:
new_stream_info = stream_info[0]
new_stream_info.subscribed.insert(0, qry[0].key)
new_stream_info.put()
print 'finished'
self.redirect('/manage')
def post(self):
user = users.get_current_user()
stream_id = self.request.get('stream_id')
print 'first', stream_id
streams = Stream.query(Stream.stream_id != '').fetch()
for stream in streams:
print 'hi', stream.stream_id
if stream.stream_id == stream_id:
info = {
'error':
'you tried to create a stream whose name already existed'
}
info = urllib.urlencode(info)
self.redirect('/error?' + info)
return
if self.request.get("subscribers"):
mail.send_mail(sender=str(user) + "<" + str(user) + "@gmail.com>",
to="<" + self.request.get("subscribers") + ">",
subject="Please subscribe my stream",
body=self.request.get("message"))
form = {
'stream_id': self.request.get('stream_id'),
'user_id': str(users.get_current_user()),
'tags': self.request.get('tags'),
# 'subscribers': self.request.get('subscribers'),
'cover_url': self.request.get('cover_url'),
'owner': str(users.get_current_user()),
'views': 0,
}
form_data = json.dumps(form)
result = urlfetch.fetch(payload=form_data,
url=SERVICES_URL + 'create_a_new_stream',
method=urlfetch.POST,
headers={'Content-Type': 'application/json'})
self.redirect('/manage')
def get(self):
user = users.get_current_user()
stream_id = self.request.get('stream_id')
print 'stream id is', stream_id
info = {'stream_id': self.request.get('stream_id')}
info = urllib.urlencode(info)
# we should use the actual user
user_streams = Stream.query(Stream.stream_id == stream_id).fetch()
image_url = [""]*3
hidden_image = []
stream = user_streams[0]
owner = stream.owner
print 'stream id is', stream.stream_id
if owner != str(user):
stream.views += 1
while len(stream.view_queue) > 0 and (datetime.now() - stream.view_queue[0]).seconds > 3600:
del stream.view_queue[0]
stream.view_queue.append(datetime.now())
stream.put()
#get first three pictures
counter = 0
has_image = True
has_hidden = len(hidden_image)>0
image_query = db.GqlQuery("SELECT *FROM Image WHERE ANCESTOR IS :1 ORDER BY upload_date DESC",
db.Key.from_path('Stream', stream.stream_id))
logging.debug("type of gqlquery is %s", type(image_query))
maxdate = None
mindate = None
for image in image_query[0:stream.num_images]:
d = dict()
d["url"] = "image?image_id=" + str(image.key())
d["lat"] = str(image.geo_loc.lat)
d["long"] = str(image.geo_loc.lon)
date = str.split(str(image.upload_date))
dateint = int(date[0].replace("-",""))
d["time"] = dateint
if maxdate == None or dateint > maxdate:
maxdate = dateint
if mindate==None or dateint < mindate:
mindate = dateint
if counter < 3:
image_url[counter] = d
else:
hidden_image.append(d)
counter += 1
#calculate hasSub
qry = StreamInfo.query_stream(ndb.Key('User', str(user))).fetch()
has_sub = False
if len(qry) == 0:
has_sub = False
else:
for key in qry[0].subscribed:
if key.get().stream_id == stream_id:
has_sub = True
break
upload_url = ''
template_values = {
'nav_links': USER_NAV_LINKS,
'path': os.path.basename(self.request.path).capitalize(),
'owner': owner, #the owner of the stream
'user': str(users.get_current_user()), #current user
'upload_url': upload_url,
'image_url': image_url,
'hidden_image':hidden_image,
'has_image': has_image,
'hasSub': has_sub,
'stream_id': stream_id,
'has_hidden':has_hidden,
'maxdate':maxdate,
'mindate':mindate
}
print "owner is ", template_values['owner']
print "user is ", template_values['user']
template = JINJA_ENVIRONMENT.get_template('viewstream.html')
self.response.write(template.render(template_values))
def get(self):
user = users.get_current_user()
stream_id = self.request.get('stream_id')
print 'stream id is', stream_id
info = {'stream_id': self.request.get('stream_id')}
info = urllib.urlencode(info)
# we should use the actual user
user_streams = Stream.query(Stream.stream_id == stream_id).fetch()
image_url = [""] * 3
stream = user_streams[0]
owner = stream.owner
print 'stream id is', stream.stream_id
if owner != str(user):
stream.views += 1
while len(stream.view_queue) > 0 and (
datetime.now() - stream.view_queue[0]).seconds > 3600:
del stream.view_queue[0]
stream.view_queue.append(datetime.now())
stream.put()
#get first three pictures
counter = 0
has_image = True
image_query = db.GqlQuery(
"SELECT *FROM Image WHERE ANCESTOR IS :1 ORDER BY upload_date DESC",
db.Key.from_path('Stream', stream.stream_id))
print "type of gqlquery", type(image_query)
for image in image_query[0:stream.num_images]:
image_url[counter] = "image?image_id=" + str(image.key())
counter += 1
if counter == 3:
break
print "image url is", image_url
#calculate hasSub
qry = StreamInfo.query_stream(ndb.Key('User', str(user))).fetch()
has_sub = False
if len(qry) == 0:
has_sub = False
else:
for key in qry[0].subscribed:
if key.get().stream_id == stream_id:
has_sub = True
break
upload_url = ''
template_values = {
'nav_links': USER_NAV_LINKS,
'path': os.path.basename(self.request.path).capitalize(),
'owner': owner, #the owner of the stream
'user': str(users.get_current_user()), #current user
'upload_url': upload_url,
'image_url': image_url,
'has_image': has_image,
'hasSub': has_sub,
'stream_id': stream_id,
}
print "owner is ", template_values['owner']
print "user is ", template_values['user']
template = JINJA_ENVIRONMENT.get_template('viewstream.html')
self.response.write(template.render(template_values))
def get(self):
user = users.get_current_user()
stream_id = self.request.get('stream_id')
print 'stream id is', stream_id
info = {'stream_id': self.request.get('stream_id')}
info = urllib.urlencode(info)
# we should use the actual user
user_streams = Stream.query(Stream.stream_id == stream_id).fetch()
image_url = [""] * 3
hidden_image = []
stream = user_streams[0]
owner = stream.owner
print 'stream id is', stream.stream_id
if owner != str(user):
stream.views += 1
while len(stream.view_queue) > 0 and (
datetime.now() - stream.view_queue[0]).seconds > 3600:
del stream.view_queue[0]
stream.view_queue.append(datetime.now())
stream.put()
#get first three pictures
counter = 0
has_image = True
has_hidden = len(hidden_image) > 0
image_query = db.GqlQuery(
"SELECT *FROM Image WHERE ANCESTOR IS :1 ORDER BY upload_date DESC",
db.Key.from_path('Stream', stream.stream_id))
logging.debug("type of gqlquery is %s", type(image_query))
maxdate = None
mindate = None
for image in image_query[0:stream.num_images]:
d = dict()
d["url"] = "image?image_id=" + str(image.key())
d["lat"] = str(image.geo_loc.lat)
d["long"] = str(image.geo_loc.lon)
date = str.split(str(image.upload_date))
dateint = int(date[0].replace("-", ""))
d["time"] = dateint
if maxdate == None or dateint > maxdate:
maxdate = dateint
if mindate == None or dateint < mindate:
mindate = dateint
if counter < 3:
image_url[counter] = d
else:
hidden_image.append(d)
counter += 1
#calculate hasSub
qry = StreamInfo.query_stream(ndb.Key('User', str(user))).fetch()
has_sub = False
if len(qry) == 0:
has_sub = False
else:
for key in qry[0].subscribed:
if key.get().stream_id == stream_id:
has_sub = True
break
upload_url = ''
template_values = {
'nav_links': USER_NAV_LINKS,
'path': os.path.basename(self.request.path).capitalize(),
'owner': owner, #the owner of the stream
'user': str(users.get_current_user()), #current user
'upload_url': upload_url,
'image_url': image_url,
'hidden_image': hidden_image,
'has_image': has_image,
'hasSub': has_sub,
'stream_id': stream_id,
'has_hidden': has_hidden,
'maxdate': maxdate,
'mindate': mindate
}
print "owner is ", template_values['owner']
print "user is ", template_values['user']
template = JINJA_ENVIRONMENT.get_template('viewstream.html')
self.response.write(template.render(template_values))
