def post(self, user_id):
upload_files = self.get_uploads("file") # 'file' is file upload field in the form
blob_info = upload_files[0]
user = User.get_by_id(int(user_id))
video = Video(
title="",
geo_center="",
sportcategory="",
subcategory="",
upvotes=0,
downvotes=0,
submitter=user.username,
comment_count=0,
user_id=int(user_id),
original_video_ref=blob_info.key(),
mp4_video_ref=None,
webm_video_ref=None,
tags=[],
spam=0,
spamComfirmed=False,
)
video.put()
# should I do this with some sort of response in a post request and send some sort of token so that it can't be done randomly
self.redirect("/encodevideo/%s" % video.key.id())
def post(self, video_id):
content = self.request.get("content")
vote = self.request.get("vote")
user = self.get_user()
user_id = user["model_id"]
if content:
c = VideoComment(
content=content,
video_id=int(video_id),
upvotes=0,
submitter=user["username"],
user_id=user_id,
downvotes=0,
)
c.put()
video = Video.get_by_id(int(video_id))
video.comment_count = video.comment_count + 1
video.put()
currentregistereduser = User.get_by_id(int(user["model_id"]))
currentregistereduser.prestige = currentregistereduser.prestige + 2
currentregistereduser.put()
# video_comment_cache(int(group_id), True)
self.redirect("/video/%s" % video_id)
elif vote:
keyname = str(user_id) + "-" + str(video_id) + "-post"
previous_vote = Vote.get_by_id(keyname)
# previous_vote = Vote.get_by_key_name(keyname)
if previous_vote != None:
video = Video.get_by_id(int(video_id))
vote_count = video.upvotes - video.downvotes
self.response.write(vote_count)
else:
vote_record = Vote.get_or_insert(keyname, vote_record=str(user_id))
video = Video.get_by_id(int(video_id))
vote_count = video.upvotes - video.downvotes
if vote == "upvote":
vote_count = vote_count + 1
video.upvotes = video.upvotes + 1
video.put()
currentregistereduser = User.get_by_id(int(video.user_id))
currentregistereduser.prestige = currentregistereduser.prestige + 1
currentregistereduser.put()
elif vote == "downvote":
vote_count = vote_count - 1
video.downvotes = video.downvotes + 1
video.put()
self.response.write(vote_count)
else:
something = "nada"
def encoded_video_receiver(mp4_url, webm_url, video_id):
logging.info("starting the encoded_video_receiver")
if mp4_url and webm_url:
video = Video.get_by_id(int(video_id))
try:
# adding the mp4 video ref
mp4_file_name = files.blobstore.create(mime_type="video/mp4")
mp4_video = urllib2.urlopen(mp4_url)
with files.open(mp4_file_name, "a") as mp4_f:
mp4_f.write(mp4_video.read())
files.finalize(mp4_file_name)
mp4_blob_key = files.blobstore.get_blob_key(mp4_file_name)
video.mp4_video_ref = mp4_blob_key
# adding the webm video ref
webm_file_name = files.blobstore.create(mime_type="video/webm")
webm_video = urllib2.urlopen(webm_url)
with files.open(webm_file_name, "a") as webm_f:
webm_f.write(webm_video.read())
files.finalize(webm_file_name)
webm_blob_key = files.blobstore.get_blob_key(webm_file_name)
video.webm_video_ref = webm_blob_key
video.put()
logging.info("just saved the video in the datastore")
except urllib2.HTTPError, e:
logging.error("HTTPError: Failed somehow with a HTTPerror: " + str(e))
# time.sleep(10)
except Exception, e:
logging.error("Exception: Failed somehow: " + str(e))
def get(self, video_id):
video = Video.get_by_id(int(video_id))
# Zencoder with API Key
client = Zencoder("9b3c90c93b718a83dba3e343e7ec014a")
# configure outputs with dictionaries
mp4 = {"label": ["mp4", video_id], "format": "mp4"}
webm = {"label": ["webm", video_id], "format": "webm"}
notifications = "http://thehighlightnetwork.appspot.com/videonotification"
# the outputs kwarg requires an iterable
outputs = (mp4, webm)
response_from_job = client.job.create(
"http://thehighlightnetwork.appspot.com/serve/" + str(video.original_video_ref),
outputs=outputs,
notifications=notifications,
)
# need to use this to test if the response is good
logging.info(response_from_job.code) # hopefully 201
# response_id = int(response_from_job.body['id'])
response_body = response_from_job.body
logging.info(response_body)
logging.info(video_id)
self.redirect("/videoinfo/%s" % video_id)
def post(self):
video_id = self.request.get("video_id")
user = self.get_user()
video = Video.get_by_id(int(video_id))
# TODO this isn't really secure
if user:
if video.user_id == user["model_id"]:
key = video.put()
blobstore.delete(video.original_video_ref)
blobstore.delete(video.webm_video_ref)
blobstore.delete(video.mp4_video_ref)
key.delete()
image = None
current_time = int(time.time())
if current_time % 4 == 0:
image = "http://i.imgur.com/5ayyxI7.jpg"
elif current_time % 3 == 0:
image = "http://i.imgur.com/FsNsx6G.jpg"
elif current_time % 2 == 0:
image = "http://i.imgur.com/apDsYlz.jpg"
else:
image = "http://i.imgur.com/2md8HRk.jpg"
self.render("deletesuccess.html", image=image, user=user)
else:
self.rediret("noaccess.html")
def get(self):
user = self.get_user()
video_query = Video.query().order(-Video.score).fetch(50)
video_list = list(video_query)
videos = []
for video in video_list:
if video.mp4_video_ref and video.webm_video_ref and video.title != "":
videos.append(video)
videos = videos[:12]
self.render("frontpage.html", user=user, videos=videos, top=True)
def get(self, video_id):
user = self.get_user()
video = Video.get_by_id(int(video_id))
if user:
if video.user_id == user["model_id"]:
self.render("videoinfo.html", user=user)
else:
self.redirect("/noaccess")
else:
self.redirect("/noaccess")
def get(self, search_tag):
user = self.get_user()
the_query = Video.query(Video.tags.IN([search_tag])).order(-Video.created)
videos = the_query.fetch(100)
videos_list = list(videos)
# just to make sure they're ready to serve
final_videos = []
for video in videos_list:
if video.mp4_video_ref and video.webm_video_ref and video.title != "":
final_videos.append(video)
self.render("frontpage.html", user=user, videos=final_videos, tag=search_tag)
def get(self, video_id):
user = self.get_user()
video = Video.get_by_id(int(video_id))
owner = False
if user:
if video.user_id == user["model_id"]:
owner = True
comments = VideoComment.query(VideoComment.video_id == int(video_id)).order(VideoComment.created).fetch(50)
potential_related_videos = Video.query(Video.subcategory == video.subcategory).order(Video.created).fetch(5)
if video in potential_related_videos:
potential_related_videos.remove(video)
related_videos = []
for potential_video in potential_related_videos:
if potential_video.mp4_video_ref and potential_video.webm_video_ref and potential_video.title != "":
related_videos.append(potential_video)
self.render(
"videopermalink.html", user=user, video=video, comments=comments, related_videos=related_videos, owner=owner
)
def get(self, *args, **kwargs):
user = self.get_user()
if user:
profile_id = int(kwargs.get("profile_id"))
profileowner = User.get_by_id(profile_id)
current_profile_id = user['model_id']
videos = Video.query(Video.user_id == int(profile_id)).order(-Video.created).fetch(10)
videos = list(videos)
videos_to_display = []
for video in videos:
if video.title != "":
videos_to_display.append(video)
quote = profileowner.quote
avatar=None
if profileowner.avatar:
try:
avatar = images.get_serving_url(profileowner.avatar, size=None, crop=False, secure_url=None)
except TransformationError:
logging.error('we just got a TransformationError while trying to open the users image')
avatar = None
if not avatar:
avatar = 'http://i.imgur.com/RE9OX.jpg'
owner = False
if current_profile_id == profile_id:
owner = True
upload_url = blobstore.create_upload_url('/profileupload/%s' % (profile_id))
self.render('profile.html', user=user, avatar=avatar, videos_to_display=videos_to_display,
profile_id=profile_id, upload_url=upload_url, profileowner=profileowner, owner=owner)
else:
self.render('login.html')
def get(self):
user = self.get_user()
if user["model_id"] == 5187942536445952:
user_model = User.get_by_id(5187942536445952)
user_model.admin = True
user_model.put
all_videos = Video.query()
video_count = 0
for v in all_videos:
video_count = video_count + 1
all_users = User.query()
user_count = 0
for u in all_users:
user_count = user_count + 1
all_comments = VideoComment.query()
comment_count = 0
for c in all_comments:
comment_count = comment_count + 1
all_votes = Vote.query()
vote_count = 0
for vs in all_votes:
vote_count = vote_count + 1
self.response.write("There are " + str(video_count) + " videos.")
self.response.write("<br>")
self.response.write("There are " + str(user_count) + " users.")
self.response.write("<br>")
self.response.write("There are " + str(comment_count) + " comments.")
self.response.write("<br>")
self.response.write("There are " + str(vote_count) + " votes.")
else:
self.redirect("/noaccess")
def post(self, video_id):
title = self.request.get("title")
sportcategory = self.request.get("sportcategory")
sportlevel = self.request.get("sportlevel")
tags = self.request.get("tags")
shoutouts = self.request.get("shoutouts")
subcategory = self.request.get("subcategory")
description = self.request.get("description")
winner = self.request.get("winner")
loser = self.request.get("loser")
geo_center = self.request.get("geo_center")
user = self.get_user()
if title and sportcategory != "choose" and sportlevel != "choose":
video = Video.get_by_id(int(video_id))
video.title = title
video.sportcategory = sportcategory
video.sportlevel = sportlevel
if tags:
try:
tags = tags.split(",")
for i in xrange(len(tags)):
if tags[i][0] == " ":
tags[i] = tags[i][1:]
if tags[i][0] == "#":
tags[i] = tags[i][1:]
except IndexError:
dud_value = None
if shoutouts:
shoutouts = shoutouts.split(", ")
for i in xrange(len(shoutouts)):
if shoutouts[i][0] == "@":
shoutouts[i] = shoutouts[i][1:]
video.shoutouts = shoutouts
if subcategory != "choose":
video.subcategory = subcategory
if description:
video.description = description
if winner:
video.winner = winner
if loser:
video.loser = loser
error = None
GPSlocation = None
if geo_center:
g = geocoders.GoogleV3()
# to catch an error where there is no corresponding location
try:
# to catch an error where there are multiple returned locations
try:
place, (lat, lng) = g.geocode(geo_center)
place, searched_location = g.geocode(geo_center)
except ValueError:
geocodespot = g.geocode(geo_center, exactly_one=False)
place, (lat, lng) = geocodespot[0]
place, searched_location = geocodespot[0]
GPSlocation = "(" + str(lat) + ", " + str(lng) + ")"
# this is straight from the docs: http://code.google.com/p/geopy/wiki/Exceptions and happens when there is no location that matches
except geocoders.googlev3.GQueryError:
logging.error("we hit an error here in that we could not find it")
error = (
"We cannot find '"
+ geo_center
+ "' try to be a little more specific or search a nearby location."
)
except geocoders.googlev3.GTooManyQueriesError:
logging.error("the request did not go through because there are too many queries")
# TODO
something = "nada"
if error:
self.render(
"videoinfo.html",
user=user,
error=error,
title=title,
sportcategory=sportcategory,
sportlevel=sportlevel,
tags=tags,
subcategory=subcategory,
description=description,
winner=winner,
loser=loser,
geo_center=geo_center,
)
else:
if GPSlocation:
video.geo_center = GPSlocation
if not video.geo_center:
video.geo_center = None
video.put()
currentregistereduser = User.get_by_id(int(user["model_id"]))
currentregistereduser.prestige = currentregistereduser.prestige + 10
currentregistereduser.put()
# get this to redirect to a permalink
self.redirect("/video/%s" % video_id)
else:
error = "Please complete all the required sections."
self.render(
"videoinfo.html",
user=user,
error=error,
title=title,
sportcategory=sportcategory,
sportlevel=sportlevel,
tags=tags,
subcategory=subcategory,
description=description,
winner=winner,
loser=loser,
geo_center=geo_center,
)
def get(self):
sportcategory = self.request.get("sportcategory")
subcategory = self.request.get("subcategory")
sportlevel = self.request.get("sportlevel")
user = self.get_user()
if (
(sportcategory == "" or sportcategory == "choose")
and (subcategory == "" or subcategory == "choose a subcategory")
and (sportlevel == "" or sportlevel == "choose")
):
the_query = Video.query().order(-Video.created)
videos = the_query.fetch(20)
videos_list = list(videos)
videos_list = sorted(videos_list, key=attrgetter("score"), reverse=True)
videos = []
for video in videos_list:
if video.mp4_video_ref and video.webm_video_ref and video.title != "":
videos.append(video)
videos = videos[:12]
self.render("frontpage.html", user=user, videos=videos)
else:
final_videos = []
filters = []
prelim_videos = []
videos_list = []
if subcategory != "choose a subcategory":
the_query = Video.query(Video.subcategory == subcategory).order(-Video.created)
videos = the_query.fetch(100)
videos_list = list(videos)
if sportlevel != "choose":
for video in videos_list:
if video.sportlevel == sportlevel:
prelim_videos.append(video)
videos_list = prelim_videos
elif sportcategory != "choose":
the_query = Video.query(Video.sportcategory == sportcategory).order(-Video.created)
videos = the_query.fetch(100)
videos_list = list(videos)
if sportlevel != "choose":
for video in videos_list:
if video.sportlevel == sportlevel:
prelim_videos.append(video)
videos_list = prelim_videos
elif sportlevel != "choose":
the_query = Video.query(Video.sportlevel == sportlevel).order(-Video.created)
videos = the_query.fetch(100)
videos_list = list(videos)
for video in videos_list:
if video.sportlevel == sportlevel:
prelim_videos.append(video)
videos_list = prelim_videos
else:
filters = None
the_query = Video.query().order(-Video.created)
videos = the_query.fetch(100)
videos_list = list(videos)
if sportcategory != "choose":
filters.append(sportcategory)
if subcategory != "choose a subcategory":
filters.append(subcategory)
if sportlevel != "choose":
filters.append(sportlevel)
# just to make sure they're ready to serve
for video in videos_list:
if video.mp4_video_ref and video.webm_video_ref and video.title != "":
final_videos.append(video)
# TODO will need to so some sort of paging mechanism here
self.render("frontpage.html", user=user, videos=final_videos, filters=filters)
