def get(self): if self.request.get("id1") and self.request.get("id2"): img1=ImgData.get_by_id(long(self.request.get("id1"))) img2=ImgData.get_by_id(long(self.request.get("id2"))) if img1 and img2: url1=images.get_serving_url(img1.blob_key) url2=images.get_serving_url(img2.blob_key) print "##############" print url1 filePointer = urllib2.urlopen(url1) data1 = filePointer.read() filePointer.close() filePointer = urllib2.urlopen(url2) data2 = filePointer.read() filePointer.close() layer1= Image.open(StringIO(data1)) layer2= Image.open(StringIO(data2)) images.delete_serving_url(img1.blob_key) images.delete_serving_url(img2.blob_key) c=Image.new('RGBA',layer1.size,(255,255,255,0)) c.paste(layer2,(0,0),layer2) #newimg=Image.alpha_composite(layer1,c) layer1.paste(layer2,(0,0),layer2) #newimg.im_feeling_lucky() output= StringIO() layer1.save(output,format='png') imageLayer =output.getvalue() output.close() self.response.headers['Content-Type']='image/png' self.response.out.write(imageLayer) else: self.error(404) else: self.error(404)
def get(self): user = users.get_current_user() name = self.request.get('name') if not user: self.redirect(users.create_login_url()) else: ancestor_key = ndb.Key('PhotoCategory', user.user_id()) category_key = PhotoCategory.query(ancestor=ancestor_key).filter( PhotoCategory.category == name).get().key photos = UserPhoto.query(ancestor=category_key) for photo in photos: if user != photo.author: self.redirect('/') return blob_key = photo.blob_key images.delete_serving_url(blob_key) blob_info = blobstore.BlobInfo.get(blob_key) blob_info.delete() photo.key.delete() category_key.delete() self.redirect('/AlbumHome')
def post(self): deleteStreamList = [] deleteStreamList = self.request.get_all('deleteCheckbox') stream_query = Stream.query() keywordObject = Keywords.query() for stream in stream_query: if str(stream.key.id()) in deleteStreamList: print stream.streamName try: for q in keywordObject: q.globalKeywordsArray.remove(stream.streamName) q.put() for tag in stream.tags.split(' '): for q in keywordObject: q.globalKeywordsArray.remove(tag) q.put() except: pass for pic in stream.photos: images.delete_serving_url(pic.blob_key) blobstore.delete(pic.blob_key, rpc=None) stream.key.delete() self.redirect('/manage')
def delete(self): """Delete the original file and dynamic serving url if it exists """ filepath = request.args.get('filepath') if not filepath: return make_response_validation_error('filepath', message='Parameter filepath is required') try: cloudstorage.delete(filename) except cloudstorage.AuthorizationError: abort_json(401, "Unauthorized request has been received by GCS.") except cloudstorage.ForbiddenError: abort_json(403, "Cloud Storage Forbidden Error. GCS replies with a 403 error for many reasons, the most common one is due to bucket permission not correctly setup for your app to access.") except cloudstorage.NotFoundError: abort_json(404, filepath + " not found on GCS in bucket " + self.bucket) except cloudstorage.TimeoutError: abort_json(408, 'Remote timed out') # TODO get the query string and delete file if asked to blobstore_filename = u'/gs/{}/{}'.format(bucket_name, filepath) blob_key = blobstore.create_gs_key(blobstore_filename) try: images.delete_serving_url(blob_key) except images.AccessDeniedError: abort_json(403, "App Engine Images API Access Denied Error. Files has already been deleted from Cloud Storage") except images.ObjectNotFoundError: pass return '', 204
def get(self): auth = authenticate(self) if auth[0]: current_user = User.query( User.username == auth[0]._User__email).get() form_data = cgi.FieldStorage() requests = form_data.getlist("chkDeleteStream") index = search.Index(INDEX_NAME) for key_str in requests: key = ndb.Key(urlsafe=key_str) stream = key.get() for pic_key in stream.pictures: picture = pic_key.get() picture_name = picture.name filename = '/{}/Pictures'.format( BUCKET_NAME) + "/" + picture_name cloudstorage.delete(filename) blob_key = picture.image images.delete_serving_url(blob_key) blobstore.delete(blob_key) pic_key.delete() key.delete() index.delete(key_str) current_user.streams_owned.remove(key) current_user.put() time.sleep(.1) self.redirect('/ManageStream')
def RequestJobDelete(jsonRequest): ticketToDelete = jsonRequest['ticket'] query = Delivery.query(ancestor=GetHydroidUnitKey(HYDROID_UNIT_ID)) \ .filter(Delivery.finished == True) \ .filter(Delivery.ticket == ticketToDelete) deleteTarget = None for delivery in query: deleteTarget = delivery if deleteTarget: if deleteTarget.imageBlobURL: images.delete_serving_url(deleteTarget.imageBlobKey) # images.delete_serving_url_async(deleteTarget.imageBlobKey) if deleteTarget.imageBlobKey: blobstore.delete(deleteTarget.imageBlobKey) # blobstore.delete_async(deleteTarget.imageBlobKey) # k = deleteTarget.put() # k.delete() key = ndb.Key(Delivery, ticketToDelete, parent=GetHydroidUnitKey(HYDROID_UNIT_ID)) key.delete() # key.delete_async() # delete the measure list if any - we can query for runs > 1, but will do it uniform way measureQuery = Measure.query(ancestor=GetHydroidUnitKey(HYDROID_UNIT_ID)) \ .filter(Measure.ticket == ticketToDelete) for m in measureQuery: if m.imageBlobURL: images.delete_serving_url(m.imageBlobKey) if m.imageBlobKey: blobstore.delete(m.imageBlobKey) key = ndb.Key(Measure, m.runid, parent=GetHydroidUnitKey(HYDROID_UNIT_ID)) key.delete() DirtyHistoryList()
def delete_file_endpoint(self, name): f = CorusFile.get_by_id(name) b = blobstore.BlobInfo(f.blob_key) if f.serving_url: delete_serving_url(b.key()) b.delete() f.key.delete() return str('/cor/console/files/?del=' + name)
def borrarImg_cloud(img): if img.blobkeygs: filenom='/'+BUCKET +'/'+str(img.key.parent().id())+"/"+img.nombre #try: gcs.delete(filenom) images.delete_serving_url(img.blobkeygs) #except: # pass img.key.delete()
def delete_thumbnail(thumbnail_key): filename = '/gs/' + THUMBNAIL_BUCKET + '/' + thumbnail_key blob_key = blobstore.create_gs_key(filename) images.delete_serving_url(blob_key) thumbnail_reference = ThumbnailReference.query( ThumbnailReference.thumbnail_key == thumbnail_key).get() thumbnail_reference.key.delete() filename = '/' + THUMBNAIL_BUCKET + '/' + thumbnail_key gcs.delete(filename)
def delete_thumbnail(thumbnail_key): filename = '/gs/{}/{}'.format(OUTPUT_BUCKET, thumbnail_key) blob_key = blobstore.create_gs_key(filename) images.delete_serving_url(blob_key) audio_reference = AudioReference.query( AudioReference.thumbnail_key == thumbnail_key).get() audio_reference.key.delete() filename = '/{}/{}'.format(OUTPUT_BUCKET, thumbnail_key) cloudstorage.delete(filename)
def delete_thumbnail(thumbnail_key): filename = '/gs/{}/{}'.format(THUMBNAIL_BUCKET, thumbnail_key) blob_key = blobstore.create_gs_key(filename) images.delete_serving_url(blob_key) thumbnail_reference = ThumbnailReference.query( ThumbnailReference.thumbnail_key == thumbnail_key).get() thumbnail_reference.key.delete() filename = '/{}/{}'.format(THUMBNAIL_BUCKET, thumbnail_key) cloudstorage.delete(filename)
def upload_image(entity_id, old_key, image_type): try: # check if the post request has the file part if 'photo' not in request.files: raise ValueError('No photo part') image_file = request.files['photo'] # if user does not select file, browser also submit a empty part without filename if image_file and image_file.filename == '': raise ValueError('No file selected') ext = allowed_file(image_file.filename) # if allowed extension if ext: # img = Image.open(image_file) # # # Resize image # img.thumbnail((560, 560), Image.ANTIALIAS) # # # Convert Image to FileStorage type # sio = StringIO() # sio.name = image_file.filename # img.save(sio) # sio.seek(0) # f = FileStorage(sio) timestamp = int(time.mktime(datetime.utcnow().timetuple())) if image_type == USER_PROFILE: filename = 'user_profile/{}_{}.{}'.format( entity_id, timestamp, ext) elif image_type == CIRCLE_PROFILE: filename = 'circle_profile/{}_{}.{}'.format( entity_id, timestamp, ext) else: filename = '{}_{}.{}'.format(entity_id, timestamp, ext) res = upload_object(image_file, filename) # Delete old Serving URL and old Blob if old_key: images.delete_serving_url(old_key) blobstore.delete(old_key) # Create blob_key blob_key = blobstore.create_gs_key('/gs/{}/{}'.format( BUCKET, filename)) return blob_key raise ValueError('Only .jpg, .jpeg, .png files are allowed') except RequestEntityTooLarge: raise ValueError('File is too large')
def post(self): deletePostlist =[] deletePostlist=self.request.get_all('deleteCheckbox') post_query = Post.query() for p in post_query: if p.id in deletePostlist: for i in range(0,len(p.giftList)): images.delete_serving_url(p.giftList[i].image) blobstore.delete(p.giftList[i].image,rpc=None) p.key.delete() self.redirect('/manage')
def delete(self, key): current_user(required=True) key = blobstore.BlobKey(str(urllib.unquote(key))) blob_info = blobstore.BlobInfo.get(key) if blob_info: blob_info.delete() if re_image.match(blob_info.content_type): delete_serving_url(key) return {} else: self.error(404) return {"error": "File not found with key " + key}
def delete(self): if self.request.get('imgPath'): try: blobKey = blobstore.create_gs_key(self.request.get('imgPath')) print(blobKey) images.delete_serving_url(blobKey) except images.Error as e: self.response.set_status(404, e) except image.InvalidBlobKeyError as e: self.response.set_status(404, e) except blobstore.Error as e: self.response.set_status(404, e)
def remove_user_image(self): """Removes existing user's image completely""" self.image_url = '' # Find associated UserImage user_image = UserImage.query(user_id=self.uid) # Remove permenant link for image images.delete_serving_url(user_image.blob_key) user_image.deleted = True user_image.put()
def get(self): if not self.user: return self.redirect('/') ## CLEAR DATASTORE datastore_keys = [] datastore_keys.extend(User.query().fetch(keys_only=True)) datastore_keys.extend(Group.query().fetch(keys_only=True)) datastore_keys.extend(GroupPost.query().fetch(keys_only=True)) datastore_keys.extend(PrivateRequest.query().fetch(keys_only=True)) if len(datastore_keys) > 0: ndb.delete_multi(datastore_keys) ## CLEAR BLOBSTORE blobinfo_objects_query = blobstore.BlobInfo.all() blobinfo_objects = blobinfo_objects_query.fetch(400) if len(blobinfo_objects) > 0: for blobinfo_obj in blobinfo_objects: blob_key = blobinfo_obj.key() #remove image serving url images.delete_serving_url(blob_key) #remove blob blobstore.delete([blob_key]) ## CLEAR DOCUMENTS IN SEARCH INDEX(groups) ## from delete_all_in_index function at https://cloud.google.com/appengine/docs/python/search/ group_index = search.Index(name='groups') # index.get_range by returns up to 100 documents at a time, so we must # loop until we've deleted all items. while True: # Use ids_only to get the list of document IDs in the index without # the overhead of getting the entire document. document_ids = [ document.doc_id for document in group_index.get_range(ids_only=True) ] # If no IDs were returned, we've deleted everything. if not document_ids: break # Delete the documents for the given IDs group_index.delete(document_ids) ## CLEAR MEMCACHE memcache.flush_all() return self.render_json("Hard Reset Success")
def post(self): deletePostlist = [] deletePostlist = self.request.get_all('deleteCheckbox') post_query = Post.query() for p in post_query: if p.id in deletePostlist: for i in range(0, len(p.giftList)): images.delete_serving_url(p.giftList[i].image) blobstore.delete(p.giftList[i].image, rpc=None) p.key.delete() self.redirect('/manage')
def delete(self, key): if not users.is_current_user_admin(): raise AppError("User must be administrator.") key = blobstore.BlobKey(str(urllib.unquote(key))) blob_info = BlobInfo.get(key) if blob_info: blob_info.delete() if re_image.match(blob_info.content_type): delete_serving_url(key) return {} else: self.error(404) return {"error": "File not found with key " + key}
def delete(self, key): if not config.is_current_user_admin(): raise AppError("User must be administrator.") key = blobstore.BlobKey(str(urllib.unquote(key))) blob_info = BlobInfo.get(key) if blob_info: blob_info.delete() if HAS_PIL and re_image.match(blob_info.content_type): delete_serving_url(key) return {} else: self.error(404) return {"error": "File not found with key " + key}
def delete_image(image_type, user_key, group_key): user = user_key.get() if image_type == 'user': blob_key = user.image_blob if blob_key: # delete the the blob key, serving urls from datastore user.image_blob = None user.image_url = None # stor serving the image and delete the orphan blob images.delete_serving_url(blob_key) blobstore.delete([blob_key]) user.put() return True else: # user tried to delete non existing image return None if image_type == 'group': group = group_key.get() # check if user is allowed to edit the group allowed = check_group_edit_allowed(group, user_key) if not allowed: # delete the uploaded blob blobstore.delete([blob_info.key()]) return None cover_image_blob_key = group.cover_image_blob_key if cover_image_blob_key: #remove cover image fields if image uploaded group.cover_image_blob_key = None group.cover_image_url = None # stop serving the image and delete the orphan blob images.delete_serving_url(cover_image_blob_key) blobstore.delete([cover_image_blob_key]) group.put() # update the search index document # we don't pass the group image which set to None by default add_to_index(group_key.id(), group.name, group.description) return True else: # user tried to delete non existing image return None
def delete_media(gcs_filename): images.delete_serving_url(blobstore.create_gs_key(gcs_filename)) gcs.delete(gcs_filename[3:]) return True
def post(self): if self.request.get('delete'): # this is called directly so we can manually check the CSRF here if not self.checkCSRF(): return self.renderError(412) if self.user.pic_gcs: path = self.user.pic_gcs if path.startswith('/gs/'): path = path[3:] gcs.delete(path) if self.user.pic_url: images.delete_serving_url(self.user.pic_blob) if self.user.pic_blob: blobstore.delete(self.user.pic_blob) self.user.pic_gcs = None self.user.pic_blob = None self.user.pic_url = None else: errors = {} uploads = self.get_uploads() for upload in uploads: # enforce file type based on extension name, ext = upload.filename.rsplit(".", 1) ext = ext.lower() if ext not in IMAGE_TYPES: upload.delete() errors = {'type': True} continue try: # note that this serving URL supports size and crop query params self.user.pic_url = images.get_serving_url(upload, secure_url=True) except images.TransformationError: upload.delete() errors = {'corrupt': True} continue self.user.pic_gcs = upload.gs_object_name self.user.pic_blob = upload.key() if errors: return self.redisplay({}, errors) self.user.put() self.uncache(self.user.slug) self.redisplay()
def store_picture_from_content(cls, blob_key): """ Resize picture and upload to Cloud Storage bucket. Return the GCS key """ data = blobstore.BlobReader(blob_key).read() img = Image(data) img.resize(width=800, height=600) # img.im_feeling_lucky() img = img.execute_transforms(output_encoding=JPEG) new_gcs_key = cls.upload_blob_to_gcs(img, content_type='img/jpeg') # delete original blob delete_serving_url(blob_key) blobstore.delete(blob_key) return new_gcs_key
def unserveurl(): config = ConfigParser.RawConfigParser(allow_no_value=True) config.read('config.ini') expectedKey = config.get("auth", "key") receivedKey = request.form['key'] if expectedKey == receivedKey: image = request.form['image'] bucket = request.form['bucket'] logging.info('Remove Serving URL for ' + image) filename = (bucket + "/" + image) logging.info('Filename is ' + filename) gskey = blobstore.create_gs_key("/gs/" + filename) logging.info('gskey is ' + gskey) removal = images.delete_serving_url(gskey) logging.info('URL is removed') return ("OK") else: return json.dumps({'error': 'No valid key provided'}), 401, { 'ContentType': 'application/json' }
def post(self, album_key): user_ = users.get_current_user() user_id = user_.user_id() query = User.query(User.user == user_id) user = query.get() for album in user.albums: _album = album.get() try: if (_album.name == album_key): for photo in _album.photos: blob = photo.get().blob_key images.delete_serving_url(blob) break except: logging.critical("Album link is broken") self.redirect('/view_albums')
def upload_image(image_type, blob_info, user_key, group_key): user = user_key.get() if image_type == 'user': # delete the older image if it exists if user.image_blob: images.delete_serving_url(user.image_blob) blobstore.delete([user.image_blob]) # set new image properties user.image_blob = blob_info.key() user.image_url = images.get_serving_url(user.image_blob) user.put() return user.image_url if image_type == 'group': group = group_key.get() # check if user is allowed to edit the group allowed = check_group_edit_allowed(group, user_key) if not allowed: # delete the uploaded blob blobstore.delete([blob_info.key()]) return None # delete older image if exists if group.cover_image_blob_key: # stop serving the blob via image service images.delete_serving_url(group.cover_image_blob_key) # delete the blob from blobstore blobstore.delete([group.cover_image_blob_key]) # update to newly uploaded image group.cover_image_blob_key = blob_info.key() group.cover_image_url = images.get_serving_url( group.cover_image_blob_key) group.put() # update the search index document to contain latest image url or description add_to_index(group_key.id(), group.name, group.description, group.cover_image_url) return group.cover_image_url
def delete_image_url(): blob_key = request.args.get('blob_key') try: images.delete_serving_url(blob_key) except images.BlobKeyRequiredError: error = json.dumps({'error': 'Blob key not found.'}) return json_response(error, 400) except images.InvalidBlobKeyError: error = json.dumps({'error': 'Blob key invalid.'}) return json_response(error, 400) except images.Error: error = json.dumps( {'error': 'Some error occured when deleting serving url.'}) return json_response(error, 400) return json_response(json.dumps({'message': 'success delete serving url!'}))
def get(self): # QUERY user user_id = users.get_current_user().user_id() query = User.query(User.user == user_id) user = query.get() for album in user.albums: _album = album.get() try: for photo in _album.photos: # Get first image in each album blob = photo.get().blob_key images.delete_serving_url(blob) break except: logging.critical("Album link is broken") #view_hide_form should reset I think logging.critical('HidePhotoHandler') self.redirect('/create.html')
def post(self): ticketNo = int(self.request.headers['ticket']) runs = int(self.request.headers['runs']) blobInfo = self.get_uploads()[0] if ticketNo == 0: # transient status image measure = GetSingletonMeasure() if measure.imageBlobURL: images.delete_serving_url(measure.imageBlobKey) if measure.imageBlobKey: blobstore.delete(measure.imageBlobKey) measure.imageBlobKey = blobInfo.key() measure.imageBlobURL = images.get_serving_url(measure.imageBlobKey) measure.put() return # store the blob key if runs == 1: # single instance data is stored in the delivery data itself delivered = GetDeliveryItemForTicket(ticketNo, HYDROID_UNIT_ID) if delivered: delivered.imageBlobKey = blobInfo.key() delivered.imageBlobURL = images.get_serving_url(delivered.imageBlobKey) delivered.put() DirtyHistoryList() else: blobInfo.delete() else: # multi data instance runid = int(self.request.headers['runid']) measureQuery = Measure.query(ancestor=GetHydroidUnitKey(HYDROID_UNIT_ID))\ .filter(Measure.ticket == ticketNo).filter(Measure.runid == runid) # todo: a better way of getting the single result? # todo: like this: measure = measureQuery.fetch(1)[0]? but did not work?!! measure = None for m in measureQuery: measure = m if measure: measure.imageBlobKey = blobInfo.key() measure.imageBlobURL = images.get_serving_url(measure.imageBlobKey) measure.put() else: blobInfo.delete()
def delete(cls, key): activity = key.get() if type(key) is ndb.Key else cls.get_by_id(key) if activity: # Delete the related images for m in activity.media: try: # recreate the filename filename = "/%s/%s/%s%s" % (get_application_id(), activity.service_code, m.id, '.jpg') # delete blob serving url delete_serving_url(blobstore.create_gs_key('/gs' + filename)) # delete the binary gcs.delete(filename) except gcs.NotFoundError: pass # Now delete the real activity activity.key.delete()
def post(self): original_url=self.request.headers['Referer'] stream_name=re.findall('=(.*)%3D%3D',original_url)[0] stream=Stream.query(Stream.name==stream_name, Stream.author==users.get_current_user()).fetch()[0] dellsts=self.request.get_all("status") print dellsts pictures=db.GqlQuery("SELECT * FROM Picture " +"WHERE ANCESTOR IS :1 AND imgkey IN :2",db.Key.from_path('Stream',stream_name),dellsts) for picture in pictures: blobstore.delete(picture.imgkey) images.delete_serving_url(picture.imgkey) db.delete(pictures) pic_count= Count_pic.query(ancestor=ndb.Key('Stream',stream_name)).fetch()[0] # print(pic_counts) # for pic_count in pic_counts: pic_count.numbers=pic_count.numbers - len(dellsts) pic_count.put() stream.numberofpictures=pic_count.numbers stream.put() self.redirect(original_url)
def post(self): te_id = self.request.get("te_id") teacher = ndb.Key(teachme_db.teacher, int(te_id), parent=self.user.key).get() profile_pic = self.get_uploads("profile_pic") if profile_pic: blob_info = profile_pic[0] if teacher.profile_pic: if teacher.profile_pic_r: images.delete_serving_url(teacher.profile_pic) blobstore.delete(teacher.profile_pic) teacher.profile_pic = blob_info.key() teacher.profile_pic_r = images.get_serving_url(teacher.profile_pic, size=200, secure_url=True) self.user.profile_pic = blob_info.key() self.user.profile_pic_r = teacher.profile_pic_r teacher.put() self.user.put() self.redirect("/profile/teacher/%s" % str(teacher.key.id()))
def _delete_blob(self): """Delete blob images and resources.""" blob_info = blobstore.BlobInfo.get(self.blobkey) if blob_info: delete_serving_url(blob_info.key()) blobstore.delete(blob_info.key()) blob_info.delete() if self.resource: try: gcs.delete(self.resource) except gcs.NotFoundError: pass if self.original: try: gcs.delete(self.original) except gcs.NotFoundError: pass self.blobkey = None self.url = None self.width = None self.height = None
def userprofilephotoconfirm(): member = MemberInfo() #this will cause an ugly key error if we don't handle it properly try: inputUploadedPictureFile = request.files['inputProfilepicture'] if inputUploadedPictureFile: header = inputUploadedPictureFile.headers['Content-Type'] parsed_header = parse_options_header(header) blob_key = parsed_header[1]['blob-key'] except: #no need to log this error output dummyvariable = "" #a user is uploading a picture, either new if they did not have one prior, or uploaded a new one which would delete the old one if inputUploadedPictureFile: if member.pictureblobstorekey: blobstore.delete(member.pictureblobstorekey) images.delete_serving_url(member.pictureblobstorekey) member.pictureservingurl = images.get_serving_url(blob_key) member.pictureblobstorekey = blob_key member.put() return render_template('userprofilephotosaved.html', member=member) except: try: #If you couldn't complete the user save, be sure to delete the photo from the blobstore or re-use it later (to avoid a lost child hanging around) inputUploadedPictureFile = request.files['inputProfilepicture'] if inputUploadedPictureFile: header = inputUploadedPictureFile.headers['Content-Type'] parsed_header = parse_options_header(header) blob_key = parsed_header[1]['blob-key'] blobstore.delete(blob_key) except: #no need to log this error output dummyvariable = "" #Create a new form POST URL for the blobstore userprofilephoto_form_url = blobstore.create_upload_url('/userprofilephotoconfirm') return render_template('userprofilephoto.html', member=member, userprofilephoto_form_url=userprofilephoto_form_url, user_profilepicturesrc=user_profilepicturesrc, alertmessage='Oops!', userprofilephoto_form_url=userprofilephoto_form_url, user_profilepicturesrc=user_profilepicturesrc)
def get(self): user = users.get_current_user() #current_url = urlparse(self.request.url) #querys = cgi.parse_qs(current_url.query) #pid_num = querys.get('pid') photo = ndb.Key(urlsafe=self.request.get('pid')).get() if not user: self.redirect(users.create_login_url()) elif user != photo.author: self.redirect('/Album') else: blob_key = photo.blob_key images.delete_serving_url(blob_key) blob_info = blobstore.BlobInfo.get(blob_key) blob_info.delete() photo.key.delete() self.redirect('/Album')
def delete(self): key = self.request.get('key') or '' key = str(urllib.unquote(key)) s = json.dumps({key: True}, separators=(',', ':')) if 'application/json' in self.request.headers.get('Accept'): self.response.headers['Content-Type'] = 'application/json' self.response.write(s) # delete images in blobstore images.delete_serving_url(key) blobstore.delete(key, rpc=None) # delete keys in ndb stream_query = Stream.query() for stream in stream_query: if str(stream.key.id()) == self.request.get('stream'): for pic in stream.photos: if pic.blob_key == key: index = stream.photos.index(pic) del stream.photos[index] stream.put()
def get(self): user = users.get_current_user() #current_url = urlparse(self.request.url) #querys = cgi.parse_qs(current_url.query) #pid_num = querys.get('pid') photo = ndb.Key(urlsafe = self.request.get('pid')).get() if not user: self.redirect(users.create_login_url()) elif user != photo.author: self.redirect('/Album') else: blob_key = photo.blob_key images.delete_serving_url(blob_key) blob_info = blobstore.BlobInfo.get(blob_key) blob_info.delete() photo.key.delete() self.redirect('/Album')
def _check_and_create(self, thumb_url, img_path, size, crop, bg, quality): """ makes async calls to create this thumbnails """ sidecar_url = thumb_url.split("=s")[0] thumb_url = thumb_url.split(".bsurl")[0] thumb_pic = self._get_original_img(img_path) # dont have to transform image, gcs does that for use, so just simply store it gs_filepath = self._store_thumb(thumb_url, thumb_pic) # store in GCS # gs_serving_url: create once (slow), use forever (fast) blob_key = blobstore.create_gs_key("/gs" + gs_filepath) # get serving url and removes default size & crop modifiers serving_url = gimages.get_serving_url(blob_key) try: # delete old serving_url with gcs.open(gs_filepath+".bsurl", 'r') as sidecar: sidecar.readline() # throw away, is old serving url old_blob_key = sidecar.readline().rstrip("\n") gimages.delete_serving_url(old_blob_key) except gcs.errors.NotFoundError: #wasnt there pass # save serving_url in sidecare file /path/thumb.ext.bsurl with gcs.open(gs_filepath+".bsurl", 'w') as sidecar: sidecar.write(serving_url+"\n") sidecar.write(blob_key+"\n") return
def post(self): original_url = self.request.headers['Referer'] stream_name = re.findall('=(.*)%3D%3D', original_url)[0] stream = Stream.query( Stream.name == stream_name, Stream.author == users.get_current_user()).fetch()[0] dellsts = self.request.get_all("status") print dellsts pictures = db.GqlQuery( "SELECT * FROM Picture " + "WHERE ANCESTOR IS :1 AND imgkey IN :2", db.Key.from_path('Stream', stream_name), dellsts) for picture in pictures: blobstore.delete(picture.imgkey) images.delete_serving_url(picture.imgkey) db.delete(pictures) pic_count = Count_pic.query( ancestor=ndb.Key('Stream', stream_name)).fetch()[0] # print(pic_counts) # for pic_count in pic_counts: pic_count.numbers = pic_count.numbers - len(dellsts) pic_count.put() stream.numberofpictures = pic_count.numbers stream.put() self.redirect(original_url)
def post(self): try: if 'photo_id' not in self.context['request_args'] or self.context['request_args']['photo_id'] == '': raise Exception('No photo_id provided') photo_id = self.context['request_args']['photo_id'] user_photo = photo_module.Photo.get_by_id(long(photo_id)) logging.info(user_photo.serving_url) if user_photo is not None and user_photo.blob is not None: blob_key = user_photo.blob.key() user_photo.blob = None user_photo.active = False user_photo.save() if blob_key is not None: deleted_url = images.delete_serving_url(blob_key) logging.info('deleted_url') logging.info(deleted_url) deleted_blob = blobstore.delete(blob_key) logging.info('deleted_blob') logging.info(deleted_blob) #db.delete(user_photo) url = urls.adminPhotos self.redirect(url) except images.BlobKeyRequiredError, bkr: self.set_response_error(bkr, 500) logging.exception(bkr) raise bkr
def get(self, action): email_admin = users.get_current_user().email() url_logout = users.create_logout_url("/admin") text_exit = {"email": email_admin, "url": url_logout} userID = users.get_current_user().user_id() apps = get_apps() if action == "new": nav_actual = "pages" template_values = {"exit": text_exit, "nav_actual": nav_actual, "apps": apps} template_name = "/manager/view/pages_new.html" self.renderTemplate(template_name, template_values) if action == "view": viewpages = cgi.escape(self.request.get("view")) if not viewpages: categories_array = [] category = ( PageCategory.query(ancestor=site_key()) .filter(PageCategory.category_parent == None) .order(PageCategory.name) ) for c in category: if c.name_short != "empty": categories_array.append( { "name": c.name, "key": c.key.urlsafe(), "idcategory": c.idcategory, "date_publication": c.date_publication, } ) nav_actual = "pages" cat_empty = PageCategory.query(PageCategory.name_short == "empty").get() pages_in_catgegory = ( PagesinCategory.query(ancestor=site_key()) .filter(PagesinCategory.category == cat_empty.key) .order(-PagesinCategory.date_publication) ) pages = [] for p in pages_in_catgegory: page = p.page.get() pages.append( { "title": page.title, "key": page.key.urlsafe(), "idpage": page.idpage, "date_publication": page.date_publication, } ) token = urllib.quote(CreateXsrfToken("delete")) template_values = { "category": categories_array, "exit": text_exit, "nav_actual": nav_actual, "view": "home", "catactual": "Inicio", "pages": pages, "token": token, "apps": apps, } template_name = "manager/view/pages_view.html" self.renderTemplate(template_name, template_values) return if viewpages == "category": keycategory = cgi.escape(self.request.get("key")) key = ndb.Key(urlsafe=keycategory) viewcategory = key.get() categories_array = [] category = ( PageCategory.query(ancestor=site_key()) .filter(PageCategory.category_parent == viewcategory.key) .order(PageCategory.name) ) for c in category: if c.name_short != "empty": categories_array.append( { "name": c.name, "key": c.key.urlsafe(), "idcategory": c.idcategory, "date_publication": c.date_publication, } ) pages_in_catgegory = ( PagesinCategory.query(ancestor=site_key()) .filter(PagesinCategory.category == viewcategory.key) .order(-PagesinCategory.date_publication) ) pages = [] for p in pages_in_catgegory: page = p.page.get() pages.append( { "title": page.title, "key": page.key.urlsafe(), "idpage": page.idpage, "date_publication": page.date_publication, } ) nav_actual = "pages" try: parentcategory = viewcategory.category_parent catactual = ( '<a href="/admin/page/view">Inicio</a> > <a href="/admin/page/view?key=%s&view=category">%s</a> > %s ' % (parentcategory.key(), parentcategory.name, viewcategory.name) ) except: catactual = '<a href="/admin/page/view">Inicio</a> > ' + viewcategory.name token = urllib.quote(CreateXsrfToken("delete")) template_values = { "category": categories_array, "pages": pages, "exit": text_exit, "nav_actual": nav_actual, "view": "category", "catactual": viewcategory.name, "token": token, "apps": apps, } template_name = "manager/view/pages_view.html" self.renderTemplate(template_name, template_values) return if action == "edit": token = self.request.get("token") nav_actual = "pages" html = "" page_key = cgi.escape(self.request.get("key")) page = ndb.Key(urlsafe=page_key) page = page.get() categories = ( PagesinCategory.query(ancestor=site_key()) .filter(PagesinCategory.page == page.key) .order(-PagesinCategory.date_publication) ) htmlcategories = "" responsegroups = {} categoiresnames = [] for c in categories: category = c.category.get() if category.name_short != "empty": htmlcategories += '<a href="#%s" class="categorybtn">%s</a>' % (category.key.id(), category.name) categoiresnames.append({"catid": category.key.id(), "catname": category.name}) responsegroups.update({"groups": categoiresnames}) categoryarray = simplejson.dumps(responsegroups) template_values = { "categories": htmlcategories, "categoriesnames": categoryarray, "exit": text_exit, "nav_actual": nav_actual, "page": page, "key": page_key, "token": urllib.quote(token), "apps": apps, } template_name = "manager/view/pages_edit.html" self.renderTemplate(template_name, template_values) if action == "delete": page_key = cgi.escape(self.request.get("page")) token = self.request.get("token") if ValidateXsrfToken(token, "delete"): page_key = ndb.Key(urlsafe=page_key) page = page_key.get() page_in_category = PagesinCategory.query(PagesinCategory.page == page.key).get() if page.gs_key and page.gs_filename: # blobstore.delete(page.gs_key) images.delete_serving_url(page.gs_key) gcs.delete(page.gs_filename) doc_index = search.Index(name=INDEX_PAGES) doc_index.delete(page.idpage) page.key.delete() page_in_category.key.delete() self.redirect("/admin/page/new") else: self.redirect("/admin/page/view")
def remove_screenshot_blob(cls, blob_key): """Removes screenshot from blobstore and removes serving url associated with it """ images.delete_serving_url(blob_key) blobstore.delete(blob_key)
def get(self, action): email_admin = users.get_current_user().email() url_logout = users.create_logout_url("/admin") text_exit = {'email': email_admin, 'url': url_logout} userID = users.get_current_user().user_id() apps = get_apps() if action == 'new': nav_actual = 'pages' template_values = { 'exit': text_exit, 'nav_actual': nav_actual, 'apps': apps } template_name = '/manager/view/pages_new.html' self.renderTemplate(template_name, template_values) if action == 'view': viewpages = cgi.escape(self.request.get('view')) if not viewpages: categories_array = [] category = PageCategory.query(ancestor=site_key()).filter( PageCategory.category_parent == None).order( PageCategory.name) for c in category: if c.name_short != 'empty': categories_array.append({ 'name': c.name, 'key': c.key.urlsafe(), 'idcategory': c.idcategory, 'date_publication': c.date_publication }) nav_actual = 'pages' cat_empty = PageCategory.query( PageCategory.name_short == 'empty').get() pages_in_catgegory = PagesinCategory.query( ancestor=site_key()).filter( PagesinCategory.category == cat_empty.key).order( -PagesinCategory.date_publication) pages = [] for p in pages_in_catgegory: page = p.page.get() pages.append({ 'title': page.title, 'key': page.key.urlsafe(), 'idpage': page.idpage, 'date_publication': page.date_publication }) token = urllib.quote(CreateXsrfToken('delete')) template_values = { 'category': categories_array, 'exit': text_exit, 'nav_actual': nav_actual, 'view': 'home', 'catactual': 'Inicio', 'pages': pages, 'token': token, 'apps': apps } template_name = 'manager/view/pages_view.html' self.renderTemplate(template_name, template_values) return if viewpages == 'category': keycategory = cgi.escape(self.request.get('key')) key = ndb.Key(urlsafe=keycategory) viewcategory = key.get() categories_array = [] category = PageCategory.query(ancestor=site_key()).filter( PageCategory.category_parent == viewcategory.key).order( PageCategory.name) for c in category: if c.name_short != 'empty': categories_array.append({ 'name': c.name, 'key': c.key.urlsafe(), 'idcategory': c.idcategory, 'date_publication': c.date_publication }) pages_in_catgegory = PagesinCategory.query( ancestor=site_key()).filter( PagesinCategory.category == viewcategory.key).order( -PagesinCategory.date_publication) pages = [] for p in pages_in_catgegory: page = p.page.get() pages.append({ 'title': page.title, 'key': page.key.urlsafe(), 'idpage': page.idpage, 'date_publication': page.date_publication }) nav_actual = 'pages' try: parentcategory = viewcategory.category_parent catactual = '<a href="/admin/page/view">Inicio</a> > <a href="/admin/page/view?key=%s&view=category">%s</a> > %s ' % ( parentcategory.key(), parentcategory.name, viewcategory.name) except: catactual = '<a href="/admin/page/view">Inicio</a> > ' + viewcategory.name token = urllib.quote(CreateXsrfToken('delete')) template_values = { 'category': categories_array, 'pages': pages, 'exit': text_exit, 'nav_actual': nav_actual, 'view': 'category', 'catactual': viewcategory.name, 'token': token, 'apps': apps } template_name = 'manager/view/pages_view.html' self.renderTemplate(template_name, template_values) return if action == 'edit': token = self.request.get('token') nav_actual = 'pages' html = '' page_key = cgi.escape(self.request.get('key')) page = ndb.Key(urlsafe=page_key) page = page.get() categories = PagesinCategory.query(ancestor=site_key()).filter( PagesinCategory.page == page.key).order( -PagesinCategory.date_publication) htmlcategories = '' responsegroups = {} categoiresnames = [] for c in categories: category = c.category.get() if category.name_short != 'empty': htmlcategories += '<a href="#%s" class="categorybtn">%s</a>' % ( category.key.id(), category.name) categoiresnames.append({ 'catid': category.key.id(), 'catname': category.name }) responsegroups.update({'groups': categoiresnames}) categoryarray = simplejson.dumps(responsegroups) template_values = { 'categories': htmlcategories, 'categoriesnames': categoryarray, 'exit': text_exit, 'nav_actual': nav_actual, 'page': page, 'key': page_key, 'token': urllib.quote(token), 'apps': apps } template_name = 'manager/view/pages_edit.html' self.renderTemplate(template_name, template_values) if action == 'delete': page_key = cgi.escape(self.request.get('page')) token = self.request.get('token') if ValidateXsrfToken(token, 'delete'): page_key = ndb.Key(urlsafe=page_key) page = page_key.get() page_in_category = PagesinCategory.query( PagesinCategory.page == page.key).get() if page.gs_key and page.gs_filename: # blobstore.delete(page.gs_key) images.delete_serving_url(page.gs_key) gcs.delete(page.gs_filename) doc_index = search.Index(name=INDEX_PAGES) doc_index.delete(page.idpage) page.key.delete() page_in_category.key.delete() self.redirect('/admin/page/new') else: self.redirect('/admin/page/view')
def remove_from_gcs(blob_key): blobstore.delete(blob_key) images.delete_serving_url(blob_key)
def get(self): print("test!!") dellsts = self.request.get_all("status") if (len(dellsts) > 0): streams = Stream.query( Stream.name.IN(dellsts), Stream.author == users.get_current_user()).fetch() counts = CountViews.query( CountViews.name.IN(dellsts), ancestor=ndb.Key('User', users.get_current_user().nickname())).fetch() for stream in streams: pictures = db.GqlQuery( "SELECT * FROM Picture " + "WHERE ANCESTOR IS :1", db.Key.from_path('Stream', stream.name)) for pic in pictures: images.delete_serving_url(pic.imgkey) blobstore.delete(pic.imgkey) db.delete(pictures) pic_count = Count_pic.query( ancestor=ndb.Key('Stream', stream.name)) ndb.delete_multi(ndb.put_multi(pic_count)) #print pic_count ndb.delete_multi(ndb.put_multi(streams)) ndb.delete_multi(ndb.put_multi(counts)) dellsts = self.request.get_all("status1") #self.response.write(len(dellsts)) if (len(dellsts) > 0): streams = Stream.query(Stream.name.IN(dellsts)).fetch() for stream in streams: if (users.get_current_user() and users.get_current_user().nickname() in stream.subscribers): stream.subscribers.remove( users.get_current_user().nickname()) stream.put() picNum_list = [] streams_1 = Stream.query(Stream.author == users.get_current_user() ).order(-Stream.creattime).fetch() for stream in streams_1: pic_count = Count_pic.query( ancestor=ndb.Key('Stream', stream.name)).fetch()[0] pictures = db.GqlQuery( "SELECT * FROM Picture " + "WHERE ANCESTOR IS :1 " + "ORDER BY uploaddate DESC", db.Key.from_path('Stream', stream.name)) # print (stream.name, pic_count.numbers) # picNum_list.append(pic_count.numbers) picNum_list.append(pictures.count()) streams = Stream.query().fetch() streams_2 = [] count_list = [] user_name = users.get_current_user().nickname() # url =users.create_login_url('/') # if(users.get_current_user()): #user_name = users.get_current_user().nickname() url = users.create_logout_url('/') for stream in streams: if (users.get_current_user().email() in stream.subscribers): count = CountViews.query(CountViews.name == stream.name, ancestor=ndb.Key( 'User', stream.author_name)).fetch()[0] pictures = db.GqlQuery( "SELECT * FROM Picture " + "WHERE ANCESTOR IS :1 " + "ORDER BY uploaddate DESC", db.Key.from_path('Stream', stream.name)) stream.numberofpictures = pictures.count() streams_2.append(stream) count_list.append(count.numbers) #else: # self.redirect(url,permanent=False) template_values = { 'user_name': user_name, 'streams_1': streams_1, 'streams_2': streams_2, 'count_list': count_list, 'url': url, "picNum_list": picNum_list } template = JINJA_ENVIRONMENT.get_template('management_index.html') self.response.write(template.render(template_values))
def delete_blob(blob_key): images.delete_serving_url(blob_key)#delete serving url blb = blobstore.BlobInfo.get(blob_key)#delete blob info which deletes blob if blb: blb.delete()#delete blob info which deletes blob
def _remove_portrait(self): images.delete_serving_url(self.portrait) blobstore.delete(self.portrait) self.portrait = None
def delete(self, stored_image): images.delete_serving_url(stored_image.image_blob.key()) stored_image.image_blob.delete() stored_image.delete() self._json('OK')
def get(self): print("test!!") dellsts=self.request.get_all("status") if (len(dellsts) > 0): streams=Stream.query(Stream.name.IN(dellsts), Stream.author==users.get_current_user()).fetch() counts=CountViews.query(CountViews.name.IN(dellsts), ancestor=ndb.Key('User', users.get_current_user().nickname())).fetch() for stream in streams: pictures=db.GqlQuery("SELECT * FROM Picture " +"WHERE ANCESTOR IS :1",db.Key.from_path('Stream',stream.name)) for pic in pictures: images.delete_serving_url(pic.imgkey) blobstore.delete(pic.imgkey) db.delete(pictures) pic_count= Count_pic.query(ancestor=ndb.Key('Stream',stream.name)) ndb.delete_multi(ndb.put_multi(pic_count)) #print pic_count ndb.delete_multi(ndb.put_multi(streams)) ndb.delete_multi(ndb.put_multi(counts)) dellsts=self.request.get_all("status1") #self.response.write(len(dellsts)) if (len(dellsts) > 0): streams=Stream.query(Stream.name.IN(dellsts)).fetch() for stream in streams: if(users.get_current_user() and users.get_current_user().nickname() in stream.subscribers): stream.subscribers.remove(users.get_current_user().nickname()) stream.put() picNum_list = [] streams_1=Stream.query(Stream.author==users.get_current_user()).order(-Stream.creattime).fetch() for stream in streams_1: pic_count= Count_pic.query(ancestor=ndb.Key('Stream',stream.name)).fetch()[0] pictures=db.GqlQuery("SELECT * FROM Picture " +"WHERE ANCESTOR IS :1 "+"ORDER BY uploaddate DESC",db.Key.from_path('Stream',stream.name)) # print (stream.name, pic_count.numbers) # picNum_list.append(pic_count.numbers) picNum_list.append(pictures.count()) streams = Stream.query().fetch() streams_2 = [] count_list = [] user_name = users.get_current_user().nickname() # url =users.create_login_url('/') # if(users.get_current_user()): #user_name = users.get_current_user().nickname() url = users.create_logout_url('/') for stream in streams: if(users.get_current_user().email().lower() in stream.subscribers): count=CountViews.query(CountViews.name==stream.name,ancestor=ndb.Key('User',stream.author_name)).fetch()[0] pictures=db.GqlQuery("SELECT * FROM Picture " +"WHERE ANCESTOR IS :1 "+"ORDER BY uploaddate DESC",db.Key.from_path('Stream',stream.name)) stream.numberofpictures = pictures.count() streams_2.append(stream) count_list.append(count.numbers) #else: # self.redirect(url,permanent=False) template_values = { 'user_name':user_name, 'streams_1': streams_1, 'streams_2': streams_2, 'count_list': count_list, 'url': url, "picNum_list":picNum_list } template = JINJA_ENVIRONMENT.get_template('management_index.html') self.response.write(template.render(template_values))
def delete_image(blob_key): if blob_key: images.delete_serving_url(blob_key) blobstore.delete(blob_key)
def delete_from_gcs(gcs_filename): if gcs_filename: images.delete_serving_url(blobstore.create_gs_key(gcs_filename)) gcs.delete(gcs_filename[3:])