def serve_file(request, blob_key_or_info, as_download=False, content_type=None, filename=None, offset=None, size=None):
"""
Serves a file from the blobstore, reads most of the data from the blobinfo by default but you can override stuff
by passing kwargs.
You can also pass a Google Cloud Storage filename as `blob_key_or_info` to use Blobstore API to serve the file:
https://cloud.google.com/appengine/docs/python/blobstore/#Python_Using_the_Blobstore_API_with_Google_Cloud_Storage
"""
if isinstance(blob_key_or_info, BlobKey):
info = BlobInfo.get(blob_key_or_info)
blob_key = blob_key_or_info
elif isinstance(blob_key_or_info, basestring):
info = BlobInfo.get(BlobKey(blob_key_or_info))
blob_key = BlobKey(blob_key_or_info)
elif isinstance(blob_key_or_info, BlobInfo):
info = blob_key_or_info
blob_key = info.key()
else:
raise ValueError("Invalid type %s" % blob_key_or_info.__class__)
if info == None:
# Lack of blobstore_info means this is a Google Cloud Storage file
if has_cloudstorage:
info = cloudstorage.stat(blob_key_or_info)
info.size = info.st_size
blob_key = create_gs_key('/gs{0}'.format(blob_key_or_info))
else:
raise ImportError("To serve a Cloud Storage file you need to install cloudstorage")
response = HttpResponse(content_type=content_type or info.content_type)
response[BLOB_KEY_HEADER] = str(blob_key)
response['Accept-Ranges'] = 'bytes'
http_range = request.META.get('HTTP_RANGE')
if offset or size:
# Looks a little bonkers, but basically create the HTTP range string, we cast to int first to make sure
# nothing funky gets into the headers
http_range = "{}-{}".format(
str(int(offset)) if offset else "",
str(int(offset or 0) + size) if size else ""
)
if http_range is not None:
response[BLOB_RANGE_HEADER] = http_range
if as_download:
response['Content-Disposition'] = smart_str(
u'attachment; filename="%s"' % (filename or info.filename)
)
elif filename:
raise ValueError("You can't specify a filename without also specifying as_download")
if info.size is not None:
response['Content-Length'] = info.size
return response
def new_file(self, *args, **kwargs):
super(BlobstoreFileUploadHandler, self).new_file(*args, **kwargs)
blobkey = self.content_type_extra.get('blob-key')
self.active = blobkey is not None
if self.active:
self.blobkey = BlobKey(blobkey)
raise StopFutureHandlers()
def new_file(self, field_name, file_name, content_type, content_length, charset=None, content_type_extra=None):
"""
We can kill a lot of this hackery in Django 1.7 when content_type_extra is actually passed in!
"""
self.data.seek(0) # Rewind
data = self.data.read()
parts = data.split(self.boundary)
for part in parts:
match = re.search('blob-key="?(?P<blob_key>[:a-zA-Z0-9_=-]+)', part)
blob_key = match.groupdict().get('blob_key') if match else None
if not blob_key:
continue
# OK, we have a blob key, but is it the one for the field?
match = re.search('\sname="?(?P<field_name>[a-zA-Z0-9_-]+)', part)
name = match.groupdict().get('field_name') if match else None
if name != field_name:
# Nope, not for this field
continue
self.blobkey = blob_key
break
if self.blobkey:
self.blobkey = BlobKey(self.blobkey)
raise StopFutureHandlers()
else:
return super(BlobstoreFileUploadHandler, self).new_file(field_name, file_name, content_type, content_length, charset)
def post(self):
self.response.headers['Content-Type'] = 'text/html'
template = JINJA_ENVIRONMENT.get_template('main.html')
user = users.get_current_user()
blobkey = self.request.get('blobkey')
action = self.request.get('button')
if action == 'Post':
url = ''
tweet_text = self.request.get('tweet_text')
myuser_key = ndb.Key('MyUser', user.user_id())
myuser = myuser_key.get()
myuser.no_of_tweets += 1
if blobkey != '':
url = images.get_serving_url(BlobKey(blobkey),
size=20,
crop=True)
logging.info(url)
tweet_key = TweetModel(tweet_text=tweet_text,
tweet_time=datetime.now(),
tweet_username=myuser.username,
tweet_url=url)
tweet_key.put()
myuser.put()
self.redirect('/')
def get(self):
self.response.headers['Content-Type'] = 'text/html'
user = users.get_current_user()
if user:
myuser_key = ndb.Key('MyUser', user.user_id())
myuser = myuser_key.get()
upload_url = blobstore.create_upload_url('/edit')
pic_key = myuser.DP
key = BlobKey(str(myuser.DP))
url = get_serving_url(key)
template_values = {
'myuser': myuser,
'user': user,
'upload_url': upload_url,
'pic_key': pic_key,
'url': url,
}
template = JINJA_ENVIRONMENT.get_template('edit.html')
else:
template = JINJA_ENVIRONMENT.get_template("error.html")
template_values = {
"error": "Please login first!",
"url": "/",
}
self.response.write(template.render(template_values))
def _get_info(self, name):
if name.startswith('/gs/'):
assert cloudstorage, 'cloudstorage module is not available.'
return CloudStorageInfo(name)
else:
key = BlobKey(name.split('/', 1)[0])
return BlobInfo.get(key)
def post(self, nirmal):
photo_instance = UserPhoto.query(UserPhoto.photoKey == BlobKey(
self.request.get("blobkey"))).fetch()
for htc in photo_instance:
if self.session["userid"] not in htc.like:
htc.like.append(int(self.session["userid"]))
htc.put()
self.redirect("/user/?id=%s" % self.session['userid'])
def new_file(self, field_name, file_name, content_type, content_length, charset=None, content_type_extra=None):
if content_type_extra:
self.blobkey = content_type_extra.get('blob-key')
if self.blobkey:
self.blobkey = BlobKey(self.blobkey)
raise StopFutureHandlers()
else:
return super(BlobstoreFileUploadHandler, self).new_file(field_name, file_name, content_type, content_length, charset)
def new_file(self, *args, **kwargs):
super(AppEngineFileUploadHandler, self).new_file(*args, **kwargs)
blobkey = self.content_type_extra.get('blob-key')
self.activated = blobkey is not None
if self.activated:
self.blobkey = BlobKey(blobkey)
self.filename = kwargs.get('file_name', None)
self.file = StringIO()
raise StopFutureHandlers()
def post(self):
# key_media = ndb.Key(urlsafe=self.request.get("key_media"))
key_media = self.request.get("key_media")
blobkey = BlobKey(key_media)
media_query = Media.gql("WHERE key_media = :1", blobkey)
media = media_query.get()
blobstore.delete(key_media)
media.key.delete()
def new_file(self, *args, **kwargs):
"""field_name, file_name, content_type, content_length, charset=None"""
logger.debug('BlobstoreFileUploadHandler.new_file')
super(BlobstoreFileUploadHandler, self).new_file(*args, **kwargs)
blobkey = get_blobkey_from_body(self.request.body)
self.active = blobkey is not None
if self.active:
self.blobkey = BlobKey(blobkey)
raise StopFutureHandlers()
def receive(self, mail_message):
#Check that the subject contains a valid email address
email_valid = validate_email(mail_message.subject)
#If it does then proceed to assign the request
if email_valid == True:
#Make sure instructor is lower-case otherwise it is not assigned properly
instructor = str(mail_message.subject)
instructor = str.lower(instructor)
#Generate a fake BlobKey to not upset GAE - this should be restructured in future
blob_key = BlobKey("null")
#Generate a horrible uuid index for the request
requestId = str(uuid.uuid4())
#Get the body from the email as plain text - this acts as our request desciption
decodedBody = ''
textBody = mail_message.bodies('text/plain')
for content_type, body in textBody:
decodedBody = body.decode()
#Submit the request
main.submit_form(requestId, str(mail_message.sender),
str(mail_message.sender), "other", instructor,
str(decodedBody), blob_key, "email")
#Inform the instructor they have a new request
instructorMessage = mail.EmailMessage(
sender="MitCircs <*****@*****.**>",
subject="MitCircs - New Submission")
instructorMessage.to = instructor
instructorMessage.html = """<h1 style='text-align: center'>MitCircs - New Request</h1>
<br> <p style='text-align: center'> You have recieved a new request from:
<br> <b>""" + str(mail_message.sender) + """</b>
<br> <br> Request ID:
<br> <br> <b>""" + requestId + """</b>
<br> <br> To view this submission, please login to <a href='https://mitcircs.robtaylor.info'>MitCircs</a> and click on "manage requests".
<br> <br> Thanks,
<br> The MitCircs Team </p>"""
instructorMessage.send()
#The subject doesn't contain a valid email - inform the student of this and don't assign the request
else:
studentMessage = mail.EmailMessage(
sender="MitCircs <*****@*****.**>",
subject="MitCircs - Submission Error")
studentMessage.to = mail_message.sender
studentMessage.html = """<h1 style='text-align: center'>MitCircs - Submission Error</h1>
<br> <p style='text-align: center'> Your email submission has not been logged. Please ensure you include your instructor's email in the subjext line.
<br> <br> Thanks,
<br> The MitCircs Team</p>"""
studentMessage.send()
def serve_file(request,
blob_key_or_info,
as_download=False,
content_type=None,
filename=None,
offset=None,
size=None):
"""
Serves a file from the blobstore, reads most of the data from the blobinfo by default but you can override stuff
by passing kwargs.
"""
if isinstance(blob_key_or_info, BlobKey):
info = BlobInfo.get(blob_key_or_info)
elif isinstance(blob_key_or_info, basestring):
info = BlobInfo.get(BlobKey(blob_key_or_info))
elif isinstance(blob_key_or_info, BlobInfo):
info = blob_key_or_info
else:
raise ValueError("Invalid type %s" % blob_key_or_info.__class__)
response = HttpResponse(content_type=content_type or info.content_type)
response[BLOB_KEY_HEADER] = str(info.key())
response['Accept-Ranges'] = 'bytes'
http_range = request.META.get('HTTP_RANGE')
if offset or size:
# Looks a little bonkers, but basically create the HTTP range string, we cast to int first to make sure
# nothing funky gets into the headers
http_range = "{}-{}".format(
str(int(offset)) if offset else "",
str(int(offset or 0) + size) if size else "")
if http_range is not None:
response[BLOB_RANGE_HEADER] = http_range
if as_download:
response['Content-Disposition'] = smart_str(
u'attachment; filename="%s"' % filename or info.filename)
elif filename:
raise ValueError(
"You can't specify a filename without also specifying as_download")
if info.size is not None:
response['Content-Length'] = info.size
return response
def get(self):
self.response.headers['Content-Type'] = 'text/html'
user = users.get_current_user()
myuser_key = ndb.Key('MyUser', user.user_id())
myuser = myuser_key.get()
post = []
cap = []
keys = []
usr = ndb.Key('MyUser',self.request.get('id')).get()
for key in reversed(usr.post):
ndbk = key.get()
cap.append(ndbk.cap)
keys.append(ndbk.pst)
for key in keys:
post.append(get_serving_url(key))
fb = 'Follow'
if user:
myuser_key = ndb.Key('MyUser', user.user_id())
myuser = myuser_key.get()
key = BlobKey(str(usr.DP))
mimg= get_serving_url(key)
len1 = len(usr.follows)
len2 = len(usr.followers)
if usr.key in myuser.follows:
fb = 'Unfollow'
template_values = {
'myuser' : myuser,
'usr' : usr,
'mimg' : mimg,
'fb' : fb,
'len1' : len1,
'len2' : len2,
'post' : post,
'cap' : cap
}
template = JINJA_ENVIRONMENT.get_template('userinfo.html')
else:
template = JINJA_ENVIRONMENT.get_template("error.html")
template_values = {
"error" : "Please login first!" ,
"url" : "/",
}
self.response.write(template.render(template_values))
def get(self):
self.response.headers['Content-Type'] = 'text/html'
user = users.get_current_user()
if user:
myuser_key = ndb.Key('MyUser', user.user_id())
myuser = myuser_key.get()
mypost = None
post_key = ndb.Key('PostDb', user.user_id())
mypost = post_key.get()
upload_url = blobstore.create_upload_url('/adpost')
key = BlobKey(str(myuser.DP))
template_values = {
'myuser': myuser,
'user': user,
'upload_url': upload_url,
'mypost': mypost,
#'url' : url
}
template = JINJA_ENVIRONMENT.get_template('addpost.html')
self.response.write(template.render(template_values))
def _get_key(self, name):
return BlobKey(name.split('/', 1)[0])
def file_info(self, name):
key = BlobKey(name.split('/', 1)[0])
return BlobInfo(key)
def submit_handler():
#First let's deal with the submitted file
file = request.files['file']
#Check the filetype is allowed (doc, docx only)
if file and extension_check(file.filename):
#Get file type, generate BlobKey and create supportingDocument object
header = file.headers['Content-Type']
blob_string = parse_options_header(header)[1]['blob-key']
blob_key = BlobKey(blob_string)
supportingDocument = SupportingDocument(user=session['userId'],
blob_key=blob_key)
#Make sure we save the object
supportingDocument.put()
#Using a UUID as an index... see assignment write-up for why. Sorry in advance!
requestId = str(uuid.uuid4())
#Send all our form data to submit_form
submit = submit_form(id=requestId,
email=request.form['email'],
name=request.form['name'],
reason=request.form['reason'],
instructor=request.form['instructor'],
description=request.form['description'],
file_key=blob_key,
requestType="")
#Now let's notify the instructor that they have a new request
#Personal email address is used, sorry about that!
instructorMessage = mail.EmailMessage(
sender="MitCircs <*****@*****.**>",
subject="MitCircs - New Submission")
instructorMessage.to = request.form['instructor']
#Using some HTML with formatting to make the email less bland
instructorMessage.html = """<h1 style='text-align: center'>MitCircs - New Request</h1>
<p style='text-align: center'>Hello """ + request.form[
'instructor'] + """!
<br> <br> You have recieved a new request from:
<br> <b>""" + request.form['email'] + """</b>
<br> <br> Request ID:
<br> <b>""" + requestId + """</b>
<br> <br> To view this submission, please login to <a href='https://mitcircs.robtaylor.info'>MitCircs</a> and click on "manage requests".
<br> <br> Thanks,
<br> The MitCircs Team </p>"""
#Now let's notify the student that they submitted the request correctly
studentMessage = mail.EmailMessage(
sender="MitCircs <*****@*****.**>",
subject="MitCircs - Submission Reciept")
studentMessage.to = request.form['email']
studentMessage.html = """<h1 style='text-align: center'>MitCircs - Submission Reciept</h1>
<p style='text-align: center'>Hello """ + request.form['email'] + """!
<br> <br> This email is your reciept for your request to:
<br> <b>""" + request.form['instructor'] + """</b>
<br> <br> Request ID:
<br> <b>""" + requestId + """</b>
<br> <br> To view this submission, please login to <a href='https://mitcircs.robtaylor.info'>MitCircs</a> and click on "manage requests".
<br> <br> Thanks,
<br> The MitCircs Team </p>"""
#Attempt to send both emails, return to dashboard with error if this doesn't happen
try:
instructorMessage.send()
studentMessage.send()
except:
session[
'failure'] = "Failed to send email to instructor or student. Please check the submission in Manage Requests"
return render_template('submit_handler.html')
if submit is not None:
session['success'] = "The form has been submitted!"
#Student submitted an incorrect file, inform them of their mistake
else:
session[
'failure'] = "There was an error submitting the form. Please ensure all fields are filled correctly and the file extension is accepted."
return redirect(url_for('dashboard'))
def handle_upload(self):
print "test"
results = []
blob_keys = []
for name, fieldStorage in self.request.POST.items():
if type(fieldStorage) is unicode:
continue
result = {}
result['name'] = re.sub(
r'^.*\\',
'',
fieldStorage.filename
)
result['type'] = fieldStorage.type
result['size'] = self.get_file_size(fieldStorage.file)
if self.validate(result):
blob_key = str(
self.write_blob(fieldStorage.value, result)
)
blob_keys.append(blob_key)
result['deleteType'] = 'DELETE'
result['deleteUrl'] = self.request.host_url +\
'/?key=' + urllib.quote(blob_key, '')
#image = Image(parent=streamKey)
#upload_files = self.get_uploads('file')
#if (len(upload_files) > 0 ):
# blob_info = upload_files[0]
# website = images.get_serving_url(blob_info)
# image.blob_url = website
# image.blob_key = blob_info.key()
# image.comment = self.request.get("comments")
# image.put()
# stream_obj.date_updated = datetime.datetime.now()
# stream_obj.date_only_updated = datetime.datetime.now().date()
# stream_obj.num_pics = stream_obj.num_pics + 1
# stream_obj.put()
#query_params = {'stream_key': stream_obj.key.urlsafe(), 'upload': True}
#self.redirect('/streamview?' + urllib.urlencode(query_params))
if (IMAGE_TYPES.match(result['type'])):
try:
print "hello"
result['url'] = images.get_serving_url(
blob_key,
secure_url=self.request.host_url.startswith(
'https'
)
)
print result['url']
result['thumbnailUrl'] = result['url'] +\
THUMBNAIL_MODIFICATOR
print str(fieldStorage.file)
print str(fieldStorage)
print str(fieldStorage.type)
print blob_key
urlString = self.request.get("stream_key")
streamKey = ndb.Key(urlsafe=urlString)
image = Image(parent=streamKey)
image.blob_url = result['url']
key = str(blob_key)
print key
image.blob_key = BlobKey(key)
image.comment = ""
long = uniform(-180,180)
lat = uniform(-70, 70)
image.longitude = long
image.latitude = lat
image.put()
stream_obj = streamKey.get()
stream_obj.date_updated = datetime.datetime.now()
stream_obj.date_only_updated = datetime.datetime.now().date()
stream_obj.num_pics = stream_obj.num_pics + 1
stream_obj.put()
except: # Could not get an image serving url
pass
if not 'url' in result:
result['url'] = self.request.host_url +\
'/' + blob_key + '/' + urllib.quote(
result['name'].encode('utf-8'), '')
results.append(result)
deferred.defer(
cleanup,
blob_keys,
_countdown=EXPIRATION_TIME
)
return results
