def __getBlob(cls, _key): """ Private method that gets blob content param @key is String return tuple (value, tll) """ if not _key is None: _clau = cls.__getBlobkey(_key) if not _clau is None: bi = blobstore.get(_clau) br = bi.open() value = br.read() return cls.__checkIfExpired(value); else: z=0 _clau = cls.__getBlobkey(_key+"_"+str(z)) s=[] while not _clau is None: bl = blobstore.get(_clau) br = bl.open() s.append(br.read()) z=z+1 _clau = cls.__getBlobkey(_key+"_"+str(z)) if z>0: value = "".join(s) return cls.__checkIfExpired(value); else: return (None,None) else: return (None,None)
def post(self): user = users.get_current_user() minIndex = int(self.request.get("minIndex")) maxIndex = int(self.request.get("maxIndex")) userID = self.request.get("userID") query = UserScreenshot.query(UserScreenshot.index >= minIndex, UserScreenshot.index < maxIndex, ancestor=ndb.Key('UserCollection', userID) ).order(UserScreenshot.index) results = query.fetch(None) images = [] for entry in results: blob_key = entry.blob_key blobstore.get(blob_key) reader = blobstore.BlobReader(blob_key) image = Image.open(reader) image.load() images.append(image) p = ScreenshotParser() cards = p.getCardsFromImages(images) for i in range(0, len(results)): # Bit of a fudge here, could get the ScreenshotParser to give us how many cards per image results[i].cards = "" for j in range(i * 8, min(i*8 + 8, len(cards))): results[i].cards += str(cards[j].toDict()) + "\n" results[i].cards = results[i].cards[:-1] # Remove last newline blobstore.delete(results[i].blob_key) results[i].processed = True results[i].put() return
def post(self): user = users.get_current_user() minIndex = int(self.request.get("minIndex")) maxIndex = int(self.request.get("maxIndex")) userID = self.request.get("userID") query = UserScreenshot.query(UserScreenshot.index >= minIndex, UserScreenshot.index < maxIndex, ancestor=ndb.Key('UserCollection', userID)).order( UserScreenshot.index) results = query.fetch(None) images = [] for entry in results: blob_key = entry.blob_key blobstore.get(blob_key) reader = blobstore.BlobReader(blob_key) image = Image.open(reader) image.load() images.append(image) p = ScreenshotParser() cards = p.getCardsFromImages(images) for i in range(0, len(results)): # Bit of a fudge here, could get the ScreenshotParser to give us how many cards per image results[i].cards = "" for j in range(i * 8, min(i * 8 + 8, len(cards))): results[i].cards += str(cards[j].toDict()) + "\n" results[i].cards = results[i].cards[:-1] # Remove last newline blobstore.delete(results[i].blob_key) results[i].processed = True results[i].put() return
def get(self): photo_key = self.request.get('img_id') blobinfo = blobstore.get(photo_key) if not blobstore.get(photo_key): self.error(404) else: self.send_blob(photo_key, blobinfo.content_type)
def get(self, blob_key): if blob_key: blob_info = blobstore.get(blob_key) if blobstore.get(blob_key): self.send_blob(blob_key) return # Either "id" wasn't provided, or there was no image with that ID # in the datastore. self.error(404)
def get(self, blob_key): blob_key = str(urllib.unquote(blob_key)) if not blobstore.get(blob_key): logging.error("we didnt get it on the first try") blob_key = str(urllib.unquote(blob_key)) if not blobstore.get(blob_key): self.error(404) logging.error("we didnt get it on the second try either") else: self.send_blob(blobstore.BlobInfo.get(blob_key))
def get(self): # Get the all user pics pics = Image.get_all_Images() params = {} if self.session.get('Error_Message'): params = { 'Error_Message': str(self.session.get('Error_Message')) } if self.session.get('mail'): mail = self.session.get('mail') params.update({ 'log': "", 'logged': "none" }) else: mail = '' params.update({ 'log': "none", 'logged': "" }) self.session['Error_Message'] = None page = template.render('templates/Home_Header.html', params) if not pics: self.error(404) else: for pic in pics: if not blobstore.get(pic.blob_key): logging.error('oops something went Terribly wrong.') else: key = blobstore.get(pic.blob_key) blob_info = blobstore.BlobInfo.get(pic.blob_key) # This Code Fails in Production url = '/view_photo/' + str(pic.blob_key) comments = Comment.get_Detail(pic.key) context = {'id': pic.key.id(), 'Name': pic.name, 'url': url, 'user': pic.author, 'comments': comments, 'nlikes': pic.Like, 'ndislikes': pic.Dislike, 'email': mail } if blob_info.content_type in image_types: page = page + \ template.render( 'templates/Home_Form_Image.html', context) elif blob_info.content_type in video_types: page = page + \ template.render( 'templates/Home_Form_Video.html', context) else: logging.error("Something is Missed" + str(pic.id)) page = page + template.render('templates/Home_footer.html', {}) self.response.write(page)
def view( self, *args, **kwargs ): """ View or download a file. """ try: return super(File, self).view(*args, **kwargs) except (errors.NotFound, errors.NotAcceptable, TypeError) as e: if len(args) > 0 and blobstore.get(args[0]): raise errors.Redirect("%s/download/%s" % (self.modulePath, args[0])) elif len(args) > 1 and blobstore.get(args[1]): raise errors.Redirect("%s/download/%s" % (self.modulePath, args[1])) elif isinstance( e, TypeError ): raise errors.NotFound() else: raise e
def get(self, photo_key): logging.error("in blbosend") if not blobstore.get(photo_key): logging.error('going here') self.error(500) else: self.send_blob(photo_key)
def post(self): resource = self.request.get('resource') blob_info = blobstore.get(resource) blob_info.delete() self.response.headers['Content-Type'] = 'text/html' self.response.write('<h1>Delete Done</h1>') self.response.write('<a href="%s">Main Page</a>' %('/'))
def img(blob_key): """ Serve an uploaded image """ blob_info = blobstore.get(blob_key) response = make_response(blob_info.open().read()) response.headers['Content-Type'] = blob_info.content_type return response
def send_blob_with_watermark(self, blob_key_or_info, watermark=""): if isinstance(blob_key_or_info, blobstore.BlobInfo): blob_key = blob_key_or_info.key() blob_info = blob_key_or_info else: blob_key = blob_key_or_info blob_info = blobstore.get(blob_key) if not blob_info: self.redirect(self.URL_PHOTO_NOT_FOUND) key = "blob_cache_%s_%s" % (blob_key, watermark) image_data = memcache.get(key) if not image_data: blob_reader = blobstore.BlobReader(blob_key) image_data = ccPhotoRequestHandler.create_watermark( blob_reader.read(), watermark=model.SITE_SETTINGS.watermark_img, position=model.SITE_SETTINGS.watermark_position, opacity=model.SITE_SETTINGS.watermark_opacity ) blob_reader.close() if image_data: try: memcache.set(key, image_data) except: pass else: self.redirect(self.URL_PHOTO_NOT_FOUND) self.response.headers['Content-Type'] = utils.ImageMime.PNG self.response.out.write(image_data)
def serve_work(request, photo_key): blob = blobstore.get(photo_key) if not blob: raise Http404 else: return HttpResponse(blobstore.BlobReader(blob.key()).read(), content_type=blob.content_type)
def get(self): greets = Photo.query(Photo.owner == owner).fetch() url=[] for greeting in greets: blob_key = blobstore.get(str(greeting.image)) img = images.Image(blob_key=blob_key) info = { "lien": images.get_serving_url(blob_key), "titre": greeting.titre, "description": greeting.description, } url.append(info) #self.response.out.write(url[0]) template = JINJA_ENVIRONMENT.get_template('portfolio.html') template_values = { 'url': url, } self.response.write(template.render(template_values ))
def download(bkey): blob_info = blobstore.get(bkey) response = make_response(blob_info.open().read()) response.headers['Content-Type'] = blob_info.content_type return response
def get(self,*args,**kargs): #current_user =self.auth.get_user_by_session() user_db = model.user.OurUser.query().fetch() user1=self.auth.get_user_by_session() role=self.user_model.get_by_id(user1['user_id']).role.get().role user = self.user if user.blob_key: user_image= blobstore.get(user.blob_key) else : user_image="" logging.info(user_image) # image_key=self.send_blob(self.OurUser.) upload_url = blobstore.create_upload_url('/admin/profile') # self.response.headers['Content-Type'] = 'image/png' self.render_template("admin_new/profile.html",{'user_image':user.blob_key,'permission':'success', 'user_db':user_db, 'role':role,"upload_url":upload_url})
def get(self, blob_key): if not blobstore.get(blob_key): self.error(404) return else: resource = str(urllib.unquote(blob_key)) self.send_blob(blob_key)
def migrate(image): """Copies blobs stored in Blobstore over to a GCS bucket. Args: image: main.Image instance representing a single entity in the Datastore. This does not delete migrated (old) blobs so it is safe to run the job multiple times. """ if image.blob_key and not image.gs_key: blob_info = blobstore.get(image.blob_key) if not blob_info: image.blob_key = None else: gs_key = '/'.join(['', BUCKET, blob_info.filename]) try: gcs.stat(gs_key) except gcs.NotFoundError: reader = blobstore.BlobReader(blob_info) with gcs.open(gs_key, 'w', content_type=blob_info.content_type) as f: while True: data = reader.read(1024**2) if not data: break f.write(data) blob_gs_key = blobstore.create_gs_key('/gs'+gs_key) image.url = images_api.get_serving_url(blob_gs_key, secure_url=True) image.gs_key = gs_key yield op.db.Put(image) if image.gs_key: yield op.counters.Increment('Migrated')
def get(self, photo_key): print "ViewPhotoHandler" if not blobstore.get(photo_key): self.error(404) else: self.send_blob(photo_key)
def get(self, blobkey): blob_key = str(urllib.unquote(blobkey)) if not blobstore.get(blob_key): self.error(404) return self.send_blob(blobstore.BlobInfo.get(blob_key), save_as=False)
def fetch_cached_thumbnail(cls, cached_key): blob_info = blobstore.get( blobstore.create_gs_key("/gs{0}".format(cached_key))) if blob_info: with blob_info.open() as f_blob: return f_blob.read()
def get(self): # Handles addition of data into ndb self.response.headers['Content-Type'] = 'text/html' user = users.get_current_user() data = 0 print('as') # Checking if user is logged in if user: main_header = 'Welcome to your DropBox' login_logout = 'Logout' login_logout_url = users.create_logout_url(self.request.uri) # Filter directories of current user. file_list = FileModel.query(FileModel.createdBy == user.user_id()).fetch() for each_file in file_list: blob_key = each_file.blob blob_info = blobstore.get(blob_key) data = data + blob_info.size print data else: main_header = 'Please Login to Access This Page..!!' # Error message to indicate user not logged in. login_logout = 'Login' login_logout_url = users.create_login_url(self.request.uri) template_values = { 'main_header': main_header, 'login_logout': login_logout, 'login_logout_url': login_logout_url, 'user': user, 'data': data } template = JINJA_ENVIRONMENT.get_template('data.html') self.response.write(template.render(template_values))
def size(self, name): blob_key = self._blobkey(name) blobinfo = blobstore.get(blob_key) if blobinfo: return blobinfo.size else: raise Exception("object does not exist at %s" % name)
def get(self,*args,**kargs): #current_user =self.auth.get_user_by_session() user_db = OurUser.query().fetch() user1=self.auth.get_user_by_session() role=self.user_model.get_by_id(user1['user_id']).role.get().role user = self.user if user.blob_key: user_image= blobstore.get(user.blob_key) else : user_image="" logging.info(user_image) # image_key=self.send_blob(self.OurUser.) upload_url = blobstore.create_upload_url('/profile') # self.response.headers['Content-Type'] = 'image/png' self.render_template("user_new/profile.html",{'user_image':user.blob_key,'permission':'success', 'user_db':user_db, 'role':role,"upload_url":upload_url})
def post(self): author = str(self.request.get('author')) blob_key = str(self.request.get('blob_key')) q = EntryIndex.all() q.filter("author =", users.User(author)) q.filter("blob_key =", blob_key) if q.count() > 0: return def txn(): entryindex = EntryIndex() entryindex.author = users.User(author) entryindex.blob_key = blob_key entryindex.put() db.run_in_transaction(txn) if not blobstore.get(blob_key): return else: blob_reader = blobstore.BlobReader(blob_key) data = blob_reader.read() t = xml.etree.ElementTree.fromstring(data) pre_lat, pre_long, pre_time, pre_alt, pre_heart = None, None, None, None, None t_dist = 0 t_alt = 0 rec = 0 for e in t.getiterator(): if e.tag.find("Time") > 0: time = e.text if e.tag.find("LatitudeDegrees") > 0: lat = float(e.text) if e.tag.find("LongitudeDegrees") > 0: long = float(e.text) if e.tag.find("AltitudeMeters") > 0: alt = float(e.text) if e.tag.find("HeartRateBpm") > 0: heart = int(e[0].text) if pre_lat != None: delta = distance([lat, long], [pre_lat, pre_long]) if fabs(alt - pre_alt) >= 1.2: t_alt = t_alt + fabs(alt - pre_alt) t_dist += delta taskqueue.add(url='/queue1', params={ 'author': author, 'blob_key': blob_key, 'lat': lat, 'long': long, 'rec': rec, 'heart': heart, 'alt': alt, 't_alt': t_alt, 'dist': delta, 't_dist': t_dist, 'time': time }, queue_name='queue1') pre_lat, pre_long, pre_time, pre_alt, pre_hr = lat, long, time, alt, heart rec = rec + 1
def image_uploaded(request, key = None): if not key: util.HttpJsonResponse('', request) blob_info = blobstore.get(key) thumbnail_url = images.get_serving_url(blob_info.key(), size=80, crop=False) small_url = images.get_serving_url(blob_info.key(), size=300, crop=False) big_url = "."#images.get_serving_url(blob_info.key(), size=1024, crop=False) results = { 'name': blob_info.filename, 'size': blob_info.size, 'thumbnail_url': thumbnail_url, 'small_url': small_url, 'big_url': big_url, 'delete_url': '/image/remove/%s/' % blob_info.key(), 'delete_type': 'DELETE', } results = json.dumps([results]) logging.info("results: %s",results) return util.HttpJsonResponse(results, request)
def get(self, blob_key): if not blobstore.get(blob_key): self.error(404) else: self.response.headers["Cache-Control"] = "public, max-age="+str(30*24*60*60) # 30 days self.response.headers["Expires"] = (datetime.now() + timedelta(days=30)).strftime("%a, %d %b %Y %H:%M:%S GMT") self.send_blob(blob_key)
def get(self, resource): if not blobstore.get(resource): self.error(404) else: resource = str(urllib.unquote(resource)) blob_info = blobstore.BlobInfo.get(resource) self.send_blob(blob_info)
def getBlob(self, blobKey): blob = blobstore.get(blobKey) if not blob: return self.error(404) with blob.open() as f: apkData = f.read() self.get(apkData)
def upload_img(self, logo_url): image_url = logo_url filetype = 'image/%s' % image_url.split('.')[-1] if len(filetype) > 10: filetype = 'image/jpg' filename = image_url.split('/')[-1] raw_img = None result = urlfetch.fetch(image_url) if result.status_code == 200: raw_img = result.content else: return "error fetching URL" multipart_param = MultipartParam( 'file', raw_img, filename=filename, filetype=filetype) datagen, headers = multipart_encode([multipart_param]) upload_url = blobstore.create_upload_url('/upload_image') result = urlfetch.fetch( url=upload_url, payload="".join(datagen), method=urlfetch.POST, headers=headers) blob = blobstore.get(json.loads(result.content)["key"]) self.logo = blob.key() self.put()
def get(self): existingFile = storage.FindBetaKey() if existingFile is not None: if blobstore.get(existingFile.id.key()): self.send_blob(existingFile.id, save_as=True) else: self.error(404)
def get(self, key, filename): if not blobstore.get(key): self.error(404) else: # Cache for the expiration time: self.response.headers["Cache-Control"] = "public,max-age=%d" % EXPIRATION_TIME self.send_blob(key, save_as=filename)
def upload_img(self, logo_url): image_url = logo_url filetype = 'image/%s' % image_url.split('.')[-1] if len(filetype) > 10: filetype = 'image/jpg' filename = image_url.split('/')[-1] raw_img = None result = urlfetch.fetch(image_url) if result.status_code == 200: raw_img = result.content else: return "error fetching URL" multipart_param = MultipartParam('file', raw_img, filename=filename, filetype=filetype) datagen, headers = multipart_encode([multipart_param]) upload_url = blobstore.create_upload_url('/upload_image') result = urlfetch.fetch(url=upload_url, payload="".join(datagen), method=urlfetch.POST, headers=headers) blob = blobstore.get(json.loads(result.content)["key"]) self.logo = blob.key() self.put()
def get(self, blob_key): blob_key = str(urllib.unquote(blob_key)) if not blobstore.get(blob_key): self.error(404) else: self.send_blob(blobstore.BlobInfo.get(blob_key), save_as=True)
def get(self, action, asset_key, filename=''): asset_key = ndb.Key(urlsafe=asset_key) asset = asset_key.get() if not asset: return self.error(404) if not asset.blob: return self.error(404) blob_info = blobstore.get(asset.blob) if not blob_info: return self.error(404) value = BlobReader(blob_info.key(), buffer_size=blob_info.size).read() # The code works with or without the following line. #value = unicode(value.decode('utf8')).encode('utf8')[0:-2] value = base64.b64decode(value.split('base64,')[1]) self.response.body = value self.response.headers['Content-Type'] = str(blob_info.content_type) if action == 'get': self.response.headers['Content-Disposition'] = str('attachment; filename=' + blob_info.filename) return self.response
def download(self, blobKey, fileName = "", download = "", *args, **kwargs): """ Download a file. :param blobKey: The unique blob key of the file. :type blobKey: str :param fileName: Optional filename to provide in the header. :type fileName: str :param download: Set header to attachment retrival, set explictly to "1" if download is wanted. :type download: str """ if download == "1": fname = "".join([c for c in fileName if c in string.ascii_lowercase+string.ascii_uppercase + string.digits+".-_"]) request.current.get().response.headers.add_header("Content-disposition", ("attachment; filename=%s" % (fname)).encode("UTF-8")) info = blobstore.get(blobKey) if not info: raise errors.NotFound() request.current.get().response.clear() request.current.get().response.headers['Content-Type'] = str(info.content_type) if self.blobCacheTime: request.current.get().response.headers['Cache-Control'] = "public, max-age=%s" % self.blobCacheTime request.current.get().response.headers[blobstore.BLOB_KEY_HEADER] = str(blobKey) return ""
def post_data(self, data, filename=None, mime_type=None): mime_type = mime_type or mimetypes.guess_type(filename)[0] if filename else None mime_type = mime_type or 'application/octet-stream' filename = filename or "{0}{1}".format(self.key_as_string, mimetypes.guess_extension(mime_type)) url = blobstore.create_upload_url('/_bscs/data') params = [] params.append(MultipartParam("file", filename=filename, filetype=mime_type, value=data)) payload_generator, headers = multipart_encode(params) payload = str().join(payload_generator) key = None try: result = urlfetch.fetch( url=url, payload=payload, method=urlfetch.POST, headers=headers, deadline=10, follow_redirects=False ) if "location" in result.headers: location = result.headers["location"] key = location[location.rfind("/") + 1:] return ndb.BlobKey(key) if key else None else: return None except Exception as e: logging.error(e) if key is not None: blob_info = blobstore.get(key) if blob_info is not None: blob_info.delete() return None
def render_photo(self, id): photo = Photo.get_by_id(int(id)) blobKey = photo.blobKey if blobKey: blobinfo = blobstore.get(blobKey) if blobinfo: aspect = 'h' img = images.Image(blob_key=blobKey) img.rotate(180) thumbnail = img.execute_transforms(output_encoding=images.JPEG) if img.width > img.height: pass else: aspect = 'v' img = images.Image(blob_key=blobKey) if aspect == 'h': img.resize(width=505) else: img.resize(width=355) thumbnail = img.execute_transforms(output_encoding=images.JPEG) return thumbnail return self.error(404)
def post(self, data, check, mutator): Form = self._form(data) form = Form(request_data=data, data=data.POST, files=data.request.file_uploads) profile = self._profile(data) if not form.is_valid(): # we are not storing this form, remove the uploaded blob from the cloud for blob_info in data.request.file_uploads.itervalues(): blob_info.delete() # since this is a file upload we must return a 300 response error = form.errors[form.fileFieldName()] return self._r(data).to( self._urlName(data), extra=['error=%s' % error.as_text()]) # delete the old blob, if it exists old_blob_key = getattr(profile.student_data, form.fileFieldName()) if old_blob_key: blob_info = blobstore.get(old_blob_key) if blob_info: blob_info.delete() # write information about the new blob to the datastore blob_key = form.cleaned_data[form.fileFieldName()].key() setattr(profile.student_data, form.fileFieldName(), blob_key) profile.put() return self._r(data).to(self._urlName(data), validated=True)
def serve(key): """ Endpoint for serving files Serves files from the blobstore by the given blob-key string Args: key: string value of BlobKey Returns: flask.Response object with the mimetype given by the BlobInfo entity Raises: NotFoundException in case of requested blog is nonexistent """ try: blob_info = blobstore.get(key) except BlobNotFoundError: abort(404) response = Response(mimetype=blob_info.content_type, headers={ 'content-length': blob_info.size, 'Content-Disposition': "attachment; filename=%s" % blob_info.filename }) response.stream.writelines(_reader(blob_info)) return response
def get_branding_blob_stream(branding): """A utility function to return a stream for the branding blob, mostly used with ZipFile Args: branding (Branding) Returns: a file-like object or None """ if not branding: return stream = None if branding.blob_key: if DEBUG: blob_info = blobstore.get(branding.blob_key) if blob_info: stream = blob_info.open() else: filename = get_branding_cloudstorage_path(branding.hash, branding.user) try: stream = cloudstorage.open(filename, 'r') except cloudstorage.errors.NotFoundError: pass else: stream = StringIO(branding.blob) return stream
def post(self, data, check, mutator): Form = self._form(data) form = Form(request_data=data, data=data.POST, files=data.request.file_uploads) profile = self._profile(data) if not form.is_valid(): # we are not storing this form, remove the uploaded blob from the cloud for blob_info in data.request.file_uploads.itervalues(): blob_info.delete() # since this is a file upload we must return a 300 response error = form.errors[form.fileFieldName()] return self._r(data).to(self._urlName(data), extra=['error=%s' % error.as_text()]) # delete the old blob, if it exists old_blob_key = getattr(profile.student_data, form.fileFieldName()) if old_blob_key: blob_info = blobstore.get(old_blob_key) if blob_info: blob_info.delete() # write information about the new blob to the datastore blob_key = form.cleaned_data[form.fileFieldName()].key() setattr(profile.student_data, form.fileFieldName(), blob_key) profile.put() return self._r(data).to(self._urlName(data), validated=True)
def testGetDirectBlobstoreServe(self): self.mox.StubOutWithMock(util, 'GetInstance') self.mox.StubOutWithMock(blobstore, 'get') server = dump.DumpServer() server.error = self.mox.CreateMockAnything() server.send_blob = self.mox.CreateMockAnything() server.response = self.mox.CreateMockAnything() server.response.headers = {} mock_resource = self.mox.CreateMockAnything() mock_resource.blob = self.mox.CreateMockAnything() dummy_id = object() dummy_key = object() cache_headers = { 'Expires': 'Sat, 19 Jul 2110 22:20:03 +0000', 'Cache-Control': 'max-age=31557600, public' } # Simulate blobstore returning failure. util.GetInstance(model.Resource, dummy_id).AndReturn(mock_resource) mock_resource.blob.key().AndReturn(dummy_key) blobstore.get(dummy_key).AndReturn(None) server.error(httplib.NOT_FOUND) # Image resource. util.GetInstance(model.Resource, dummy_id).AndReturn(mock_resource) mock_resource.blob.key().AndReturn(dummy_key) blobstore.get(dummy_key).AndReturn(object()) server.send_blob(dummy_key) # Model resource. util.GetInstance(model.Resource, dummy_id).AndReturn(mock_resource) mock_resource.blob.key().AndReturn(dummy_key) blobstore.get(dummy_key).AndReturn(object()) server.send_blob(dummy_key, content_type=settings.COLLADA_MIME_TYPE) # Model-in-KMZ resource. util.GetInstance(model.Resource, dummy_id).AndReturn(mock_resource) mock_resource.blob.key().AndReturn(dummy_key) blobstore.get(dummy_key).AndReturn(object()) server.send_blob(dummy_key, content_type=settings.KMZ_MIME_TYPE) self.mox.ReplayAll() server.GetResource(dummy_id) self.assertEqual(server.response.headers, {}) mock_resource.type = 'image' server.GetResource(dummy_id) self.assertEqual(server.response.headers, cache_headers) mock_resource.type = 'model' server.GetResource(dummy_id) self.assertEqual(server.response.headers, cache_headers) mock_resource.type = 'model_in_kmz' server.GetResource(dummy_id) self.assertEqual(server.response.headers, cache_headers)
def get(self, audio_key): if not blobstore.get(photo_key): self.error(404) else: resource = str(urllib.unquote(audio_key)) blob_info = blobstore.BlobInfo.get(resource) self.send_blob(blob_info, save_as=True) self.response.write(str(key))
def get_qr_code_url(self): try: if self.qr_code and blobstore.get(self.qr_code): return images.get_serving_url(self.qr_code) else: return "" except: return "http://check-me-in.biz/blobstore/images/" + str(self.qr_code)
def get(self, key, filename): if not blobstore.get(key): self.error(404) else: # Cache for the expiration time: self.response.headers['Cache-Control'] =\ 'public,max-age=%d' % EXPIRATION_TIME self.send_blob(key, save_as=filename)
def get(self, file_id): file_id = self.request.get('photoID') file = File.get_by_id(long(file_id)) if not blobstore.get(file.blob): self.error(404) else: self.send_blob(file.blob)
def get_blob(self, image_key): blob_info = blobstore.get(image_key) if blob_info: logging.info("fetching image for {}".format(image_key)) return blobstore.fetch_data(image_key, 0, blob_info.size) else: raise cloudstorage.NotFoundError
def img_in_cache(self): """ Returns True if the thumbnail image is in the cache """ return blobstore.get( blobstore.create_gs_key( "/gs/greenday-project-v02-local.appspot.com/gd-yt-thumbs/{yt_id}/ytthumb-{yt_id}-{ms}" .format(yt_id=self.yt_id, ms=self.at_milliseconds)))
def thumbnailer(self, blob_key): blob_info = blobstore.get(blob_key) if blob_info: img = images.Image(blob_key=blob_key) img.resize(width=300, height=300) thumbnail = img.execute_transforms(output_encoding=images.PNG) return thumbnail
def get(self, file_key, file_name): self.response.headers['Content-Type'] = 'application/x-gzip' self.response.headers[ 'Content-Disposition'] = 'attachment; filename=' + str(file_name) if not blobstore.get(file_key): self.error(404) else: self.send_blob(file_key)
def get(self, file_key): email = get_user_email() if email: if not blobstore.get(file_key): self.error(404) else: self.send_blob(blobstore.BlobInfo.get(file_key), save_as=True) else: self.redirect('/')
def get(self, project_id): project_id = int(project_id) project = model.show_project(project_id) project_feed_key = project.feed project_feed_info = blobstore.BlobInfo(project.feed) if not blobstore.get(project_feed_key): self.error(404) else: self.send_blob(project_feed_info, save_as=True)
def exists(self, name): logging.debug("GCSStorage.exists() was called.") blob_key = self._blobkey(name) if blobstore.get(blob_key): logging.info("blobstore key %s exists" % str(blob_key)) return True else: logging.info("blobstore key %s does not exist" % str(blob_key)) return False
def deleteImages(self, request): # images = ImageUpload.query(); id = int(request.id) imageKey = ImageUpload.get_by_id(id).key logging.debug('Deleting Image with ID: ' + request.id) blob = blobstore.get(imageKey.get().blob_key) blob.delete() imageKey.delete() return request