def post(self):
user = users.get_current_user()
if user:
request = self.request.get("button")
if (request == "delete_clicked"):
check_list = self.request.get_all("delete")
for value in check_list:
streamKey = ndb.Key(urlsafe=value)
stream_obj = streamKey.get()
images_query = Image.query(ancestor=streamKey)
image_list = images_query.fetch()
for imagez in image_list:
blobstore.delete(imagez.blob_key)
imagez.key.delete()
stream_obj.key.delete()
elif (request == "unsub_clicked"):
check_list = self.request.get_all("unsubscribe")
for value in check_list:
streamKey = ndb.Key(urlsafe=value)
stream_obj = streamKey.get()
stream_obj.subscribers.remove(user.email())
stream_obj.put()
self.redirect('/manage')
else:
self.redirect('/')
def get(self, student, filename):
session = get_current_session()
if (not loggedInAsAdmin(self)):
return
netid = session.get('netID')
logging.debug("Checked for login")
logging.debug("NetID: %s" % netid)
logging.debug("Filename: %s" % filename)
q = db.GqlQuery(
"SELECT * FROM MyBlobFile WHERE netID = :1 AND fileName =:2",
student, urllib.unquote(filename))
results = q.get()
logging.debug("Past the query. Result: %s" % str(results))
# if it exists, delete it
if (results != None):
resource = results.blobstoreKey
blobstore.delete(resource.key())
db.delete(results)
self.redirect("/adminview/%s" % student)
else:
errorMsg(
self,
"Sorry, this file does not seem to exist or you don't have permission to delete it"
)
return
def fail():
try:
blobstore.delete(blob_info.key())
except:
pass
self._json({'message': 'Failed to write the image to datastore.'},
code=502)
def post(self):
uploads = self.get_uploads()
for file in uploads:
filename = blobstore.BlobInfo(file.key()).filename
user = users.get_current_user()
my_user_key = ndb.Key(MyUser, user.user_id())
my_user = my_user_key.get()
currDirObj = my_user.currDir.get()
path = ''
if functions.isRootDirectory(my_user):
path = currDirObj.dirPath + filename
else:
path = currDirObj.dirPath + '/' + filename
file_id = my_user.key.id() + path
file_key = ndb.Key(File, file_id)
logging.info(file_id)
if functions.exists(file_key, currDirObj.files):
file_object = File(id=file_id)
file_object.fileName = filename
file_object.data = file.key()
file_object.put()
currDirObj.files.append(file_key)
currDirObj.put()
else:
# Delete uploaded file from the blobstore
blobstore.delete(file.key())
logging.debug("File with the same name already exists!")
self.redirect('/')
def get(self, id):
user = users.get_current_user()
if user is None:
# go to login page
print("View Stream Handler: Not logged in")
self.redirect(users.create_login_page(self.request.uri))
return
current_stream = stream.get_by_id(int(id))
if not current_stream:
self.redirect("/error/" + 'Wrong stream or page number')
return
if current_stream:
# delete all the imgs, because they are huge
for i in current_stream.figures:
if(not i.external):
blobstore.delete(i.blob_key)
queried_user_profile = user_profile.query(user_profile.user_id == user.user_id()).get()
if queried_user_profile:
if current_stream.name in queried_user_profile.own_streams:
queried_user_profile.own_streams.remove(str(current_stream.name))
if (not queried_user_profile.own_streams) and (not queried_user_profile.subscribed_streams):
# no own_streams nor subscribed_streams
queried_user_profile.key.delete()
else:
queried_user_profile.put()
current_stream.key.delete()
time_sleep(NDB_UPDATE_SLEEP_TIME)
self.redirect('/management')
return
def _delete_model_blobs(self, model):
"""Deletes all blobs associated with the model (finds all BlobKeyProperty)"""
for (name, prop) in model._properties.iteritems():
if isinstance(prop, ndb.BlobKeyProperty):
if getattr(model, name):
blobstore.delete(getattr(model, name))
def get(self):
user = users.get_current_user()
if user:
# Make sure we've cleared the datastore of a users old stuff, or we get blobstore errors
collectionQuery = UserCollection.query(
UserCollection.user == user.user_id())
collectionResults = collectionQuery.fetch(1, keys_only=True)
if collectionResults:
screenshotQuery = UserScreenshot.query(
UserScreenshot.user == user.user_id())
ssResults = screenshotQuery.fetch(None)
for entry in ssResults:
#print "Deleting old data"
blobstore.delete(entry.blob_key)
entry.key.delete()
else:
userCollection = UserCollection(user=user.user_id(),
parent=ndb.Key(
'UserCollection',
user.user_id()))
userCollection.put()
# There's less than 800 cards, 1600 incl. golden, 8 per page, + 10 for half full pages
# 200 is above what we need.
html = "<!DOCTYPE html>\n<html>\n <meta charset=\"UTF-8\"/>\n"
for i in range(200):
upload_url = blobstore.create_upload_url("/upload")
html += " <meta class=\"uploadLink\" upload=\"" + upload_url + "\">\n"
self.response.out.write(html + MAIN_PAGE_HTML)
else:
self.redirect(users.create_login_url(self.request.uri))
return
def post(self):
csvfile = self.get_uploads('label-upload')
key = cgi.escape(self.request.get('label-type'))
if key and csvfile:
t = Template.get_by_id(key) or Alias.get_by_id(key)
if t.__class__ == Alias:
t = Template.query(Template.aliases == t.key).fetch()[0]
blob = csvfile[0]
iterator = BlobIterator(blobstore.BlobReader(blob.key()))
labels = list()
for row in csv.reader(iterator):
if row: labels.append(row)
blobstore.delete(blob.key())
template = JINJA_ENVIRONMENT.get_template('labels.html')
self.response.write(template.render({'key': t.key.string_id(),
'labels': labels,
'labels_per_page': int(t.layout.get().nx * t.layout.get().ny),
'label_barcode': cgi.escape(self.request.get('label-barcode')),
'label_orientation': cgi.escape(self.request.get('label-orientation')),
'label_font_size': cgi.escape(self.request.get('label-font-size')),
}))
else:
self.redirect('/') #TODO
def generate_all():
q = MyFile.all()
mfiles = q.fetch(100)
# delete all old files and data
for mf in mfiles:
bk = mf.blob_key
blobstore.delete(bk)
# delete data entity
mf.delete()
# dict of zipfiles being generated and their relevant generators
generators = {
'openvpn.zip': generate_ovpn,
'windows.zip': generate_win,
'linux.zip': generate_linux,
'mac.zip': generate_mac,
'android.zip': generate_android
}
ip_data = fetch_ip_data()
for fn, g in generators.iteritems():
data = g(ip_data)
z = zipit(data) #compress the data
blob_file = files.blobstore.create('application/zip',
_blobinfo_uploaded_filename=fn)
with files.open(blob_file, 'a') as f:
f.write(z)
files.finalize(blob_file)
blob_key = files.blobstore.get_blob_key(blob_file)
mf = MyFile(name=fn, blob_key=str(blob_key))
mf.update_date = datetime.datetime.now().date()
mf.put()
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 get(self, key=None):
try: listing = db.get(db.Key(key))
except:
pass
user = users.get_current_user()
if not user:
self.redirect(users.create_login_url('/logincheck'))
return
editing = True
if key == None:
listing = None
editing = False
if editing and not listing.owner == user:
self.redirect('/')
return
if self.request.get('action') == 'delete-suite':
suite = db.get(db.Key(self.request.get('suitekey')))
blobstore.delete(suite.floorplan.key())
suite.delete()
values = {'user': user,
'is_admin': users.is_current_user_admin(),
'account': Account.all().filter("user =", user).get(),
'login_url': users.create_login_url('/logincheck'),
'logout_url': users.create_logout_url('/'),
'upload_url': blobstore.create_upload_url('/panel/listing/upload'),
'listing': listing,
'editing': editing,
'type': listing.sale_type,
}
path = os.path.join(os.path.dirname(__file__), '_templates/panel_listing_edit.html')
self.response.out.write(template.render(path, values))
def get(self, key):
photo_key = ndb.Key(urlsafe=key)
url = self.request.url
parsed = urlparse.urlparse(url)
query = urlparse.parse_qs(parsed.query)
if 'id_token' in query:
id_token = query['id_token'][0]
if User.auth_photo_user(key, id_token):
self.response.set_cookie('id_token',
id_token,
max_age=3600,
path='/')
# Delete from storage
blobstore.delete(photo_key.get().b_key)
# Remove record from the corresponding user entity
User.delete_photo(photo_key, id_token)
# Delete the corresponding photo entity
photo_key.delete()
self.response.out.write("Successfully deleted. \r\n")
else:
self.response.out.write("401 No Authorization \r\n")
self.response.set_status(401)
else:
self.response.out.write("401 No Authorization \r\n")
self.response.set_status(401)
def post(self, resource):
accessAllowed = self.verifyAdminStatus(userInfo.poster, 'Delete Photo')
if not accessAllowed:
return
try:
# Get the photo object and key for the given photo
photo, key = self.getPhotoAndKey(resource)
# If either the photo or the key could not be found, raise and exception (to be caught by the
# proceeding except).
if photo == None or key == None:
raise Exception()
# Delete both the blobstore photo (the actual file) and the datastore object (the photo title,
# description, etc.
ImageInfo.delete(photo)
blobstore.delete(key)
time.sleep(0.2)
self.redirect('/photos')
return
except:
error = 'Error: no photo found with the given id. Cannot delete photo.'
self.renderPage(error=error)
def post(self, secret, key):
hacker = hacker_page.getHacker(secret)
if hacker is None:
logging.error("Attempted to change hacker's uploaded" + key + " but no hacker with key: " + secret)
return self.redirect('/')
newFiles = map(lambda f: f.key(), self.get_uploads(key))
multipleFileUpload = self.request.get('multiple') == "true"
if multipleFileUpload:
existingFiles = getattr(hacker, key, [])
value = existingFiles + newFiles
elif len(newFiles) > 0:
existingFile = getattr(hacker, key, None)
if existingFile:
blobstore.delete(existingFile)
value = newFiles[0]
else:
value = None
setattr(hacker, key, value)
hacker_page.putHacker(hacker)
downloadLinks = map(getDownloadLink, newFiles)
fileNames = getFileNames(newFiles)
self.response.write(json.dumps({"downloadLinks": downloadLinks, "fileNames" : fileNames}))
def post(self):
enforce_login(self)
upload_files = self.get_uploads('file') # 'file' is file upload field in the form
blob_info = upload_files[0]
epub = model.ePubFile(blob = blob_info, blob_key = blob_info.key())
epub.put()
entry = model.LibraryEntry(epub = epub, user = get_current_session().get("account"))
entry.put()
unpacker = unpack.Unpacker()
existing, error = unpacker.unpack(epub)
if error is None:
epub_key = epub.key() if existing is None else existing.key()
logging.info("Indexing epub with key %s" % epub_key)
taskqueue.add(queue_name = 'index', url='/index', countdown=2, params={
'key':epub_key,
'user':get_current_session().get("account")
})
epub.get_cover()
self.redirect("/book/"+str(epub.key().id()))
else:
db.delete(entry)
blobstore.delete(epub.blob.key())
db.delete(epub)
error = "Invalid EPUB file" if error.find("File is not a zip")>0 else error
respondWithMessage(self, "Upload error: "+error)
def post(self):
upload_files = self.get_uploads('file')
blob_info = upload_files[0]
# Resize the image
image = images.Image(blob_key=blob_info.key())
image.resize(width=WOOF_FEED_ITEM_IMAGE_MAX_WIDTH, height=WOOF_FEED_ITEM_IMAGE_MAX_HEIGHT)
thumbnail = image.execute_transforms(output_encoding=images.JPEG)
# Save Resized Image back to blobstore
file_name = files.blobstore.create(mime_type='image/jpeg')
with files.open(file_name, 'a') as f:
f.write(thumbnail)
files.finalize(file_name)
# Remove the original image
blobstore.delete(blob_info.key())
blob_key = files.blobstore.get_blob_key(file_name)
# New FeedImage
feed_image = FeedImage()
feed_image.data = BlobInfo.get(blob_key)
feed_image.width = image.width
feed_image.height = image.height
feed_image.put()
# Create new FeedItem
feed_item = FeedItem()
feed_item.text = self.request.get("text")
feed_item.image = feed_image
feed_item.put()
self.redirect('/')
def get(self, student, filename):
session = get_current_session()
if(not loggedInAsAdmin(self)):
return
netid = session.get('netID')
logging.debug("Checked for login")
logging.debug("NetID: %s" % netid)
logging.debug("Filename: %s" % filename)
q = db.GqlQuery("SELECT * FROM MyBlobFile WHERE netID = :1 AND fileName =:2", student, urllib.unquote(filename))
results = q.get()
logging.debug("Past the query. Result: %s" % str(results))
# if it exists, delete it
if(results != None):
resource = results.blobstoreKey
blobstore.delete(resource.key())
db.delete(results)
self.redirect("/adminview/%s" % student)
else:
errorMsg(self, "Sorry, this file does not seem to exist or you don't have permission to delete it")
return
def post(self):
user_ = self.request.get('user')
user_query = ndb.Key(Webusers, str(user_)).get()
if not user_query:
user_query = Webusers(id=str(user_))
user_query.google_calendar = False
user_query.nickname = self.request.get('nick')
user_query.gender = self.request.get('gender')
birthday_ = self.request.get('birthday')
if birthday_:
user_query.birthday = datetime(int(birthday_[0:4]),int(birthday_[5:7]),int(birthday_[8:10]))
user_query.introduce = self.request.get('introduce')
#interest
if user_query.interest:
user_query.interest = []
for item in self.request.get_all('interest'):
user_query.interest.append(str(item))
photo = self.get_uploads('photo')
if photo:
if user_query.photo:
blobstore.delete(urllib.unquote(user_query.photo))
blob_info = photo[0]
user_query.photo = str(blob_info.key())
user_query.put()
self.redirect('/my_city')
def post(self, resource):
accessAllowed = self.verifyAdminStatus(userInfo.poster, 'Delete File')
if not accessAllowed:
return
try:
# Get the FileInfo object to edit
file, blobInfo = self.getFileAndBlobInfo(resource)
if file == None:
error = 'Could not find FileInfo object with provided id. Cannot delete file.'
self.renderPage(error=error)
return
if blobInfo == None:
error = 'Could not find BlobInfo object with provided id. Cannot delete file.'
self.renderPage(error=error)
return
FileInfo.delete(file)
blobstore.delete(blobInfo.key())
time.sleep(0.2)
self.redirect('/files')
return
except:
error = 'Error: no file found with the given id. Cannot delete file.'
self.renderPage(error=error)
def get(self):
deletion_cutoff = datetime.datetime.now() - datetime.timedelta(days=14)
for document in Document.query(
ndb.AND(Document.deletion_time < deletion_cutoff,
Document.deletion_time != None)):
blobstore.delete(document.blob_key)
document.key.delete()
def handleAndRelogin(self):
if self.getUploadIsValid():
blob_key = self.get_uploads()[0].key()
blobstore.delete(blob_key)
url = "/view_single?stream_key=" + self.request.get("stream_key")
self.redirect(users.create_login_url(url))
def generate_all():
q=MyFile.all()
mfiles=q.fetch(100)
# delete all old files and data
for mf in mfiles:
bk=mf.blob_key
blobstore.delete(bk)
# delete data entity
mf.delete()
# dict of zipfiles being generated and their relevant generators
generators={'openvpn.zip':generate_ovpn,
'windows.zip':generate_win,
'linux.zip':generate_linux,
'mac.zip':generate_mac,
'android.zip':generate_android
}
ip_data = fetch_ip_data()
for fn,g in generators.iteritems():
data=g(ip_data)
z=zipit(data) #compress the data
blob_file=files.blobstore.create('application/zip',
_blobinfo_uploaded_filename=fn)
with files.open(blob_file,'a') as f:
f.write(z)
files.finalize(blob_file)
blob_key = files.blobstore.get_blob_key(blob_file)
mf=MyFile(name=fn,blob_key=str(blob_key))
mf.update_date=datetime.datetime.now().date()
mf.put()
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 get(self):
# Get the default Cloud Storage Bucket name and create a file name for
# the object in Cloud Storage.
bucket = app_identity.get_default_gcs_bucket_name()
# Cloud Storage file names are in the format /bucket/object.
filename = '/{}/blobstore_demo'.format(bucket)
# Create a file in Google Cloud Storage and write something to it.
with cloudstorage.open(filename, 'w') as filehandle:
filehandle.write('abcde\n')
# In order to read the contents of the file using the Blobstore API,
# you must create a blob_key from the Cloud Storage file name.
# Blobstore expects the filename to be in the format of:
# /gs/bucket/object
blobstore_filename = '/gs{}'.format(filename)
blob_key = blobstore.create_gs_key(blobstore_filename)
# Read the file's contents using the Blobstore API.
# The last two parameters specify the start and end index of bytes we
# want to read.
data = blobstore.fetch_data(blob_key, 0, 6)
# Write the contents to the response.
self.response.headers['Content-Type'] = 'text/plain'
self.response.write(data)
# Delete the file from Google Cloud Storage using the blob_key.
blobstore.delete(blob_key)
def get(self, id, fig_key):
user = users.get_current_user()
if user is None:
# go to login page
print("View Stream Handler: Not logged in")
self.redirect(users.create_login_page(self.request.uri))
return
current_stream = stream.get_by_id(int(id))
if(not current_stream):
self.redirect("/error/" + 'Wrong stream or page number')
return
flag = False
if current_stream:
#delete all the imgs, because they are huge
for i in current_stream.figures:
if str(i.blob_key) == fig_key:
blobstore.delete(i.blob_key)
current_stream.figures.remove(i)
flag = True
break
if(not flag):
self.redirect("/error/" + 'Designated fig does not exist')
return
current_stream.num_of_pics -= 1
current_stream.put()
time_sleep(NDB_UPDATE_SLEEP_TIME)
return
def handleAndRelogin(self):
if self.getUploadIsValid():
blob_key = self.get_uploads()[0].key()
blobstore.delete(blob_key)
url = "/view_single?stream_key=" + self.request.get("stream_key")
self.redirect(users.create_login_url(url))
def post(self):
""" Get fields from POST dict """
manuscript_id = self.request.POST.get('manuscript_id')
manuscript = bmodels.Manuscript.get_by_id(long(manuscript_id))
upload_full_manuscript = self.get_uploads()
if upload_full_manuscript:
try:
blobstore.delete(manuscript.full_manuscript_key)
except:
pass
full_manuscript_key = upload_full_manuscript[0].key()
full_manuscript_filename = upload_full_manuscript[0].filename
full_manuscript_uploaded_on = datetime.now()
else:
full_manuscript_key = None
pprint(upload_full_manuscript[0].__dict__)
print upload_full_manuscript[0].filename
print full_manuscript_key
try:
message = ''
manuscript.full_manuscript_key = full_manuscript_key
manuscript.full_manuscript_filename = full_manuscript_filename
manuscript.full_manuscript_uploaded_on = full_manuscript_uploaded_on
manuscript.put()
message += " " + _('Full manuscript successfully uploaded.')
self.add_message(message, 'success')
except (AttributeError, KeyError, ValueError), e:
logging.error('Error creating/updating manuscript: ' + e)
message = _('Unable to create/update manuscript. Please try again later.')
self.add_message(message, 'error')
def post(self):
upload = self.get_uploads()[0]
# Path
root = self.session.get('root')
path = self.request.POST.get('path')
if path != '':
fpath = root + '/' + path
else:
fpath = root
fname = upload.filename
fsize = round(blobstore.BlobInfo(upload.key()).size / 1000, 2)
if fsize < 1:
fsize = 1
fdate = blobstore.BlobInfo(upload.key()).creation
qry = File.query(File.path == fpath, File.name == fname)
result = qry.fetch()
if len(result) > 0:
result[0].key.delete()
blobstore.delete(result[0].blob_key)
# Get file info from blobinfo
file = File(name=fname,
path=fpath,
blob_key=upload.key(),
size=str(fsize),
cdate=str(fdate.strftime("%m/%d/%Y %H:%M:%S")))
file.put()
# self.response.write(upload.filename)
self.redirect('/?path=' + path)
def post(self):
upload_files = self.get_uploads('file') # 'file' is file upload field in the form
blob_info = upload_files[0]
self.process_csv(blob_info)
blobstore.delete(blob_info.key()) # optional: delete file after import
self.redirect("/admin/loaddata")
def post(self):
user = users.get_current_user()
if not user:
return self.redirect('/error')
my_name = self.request.get('name').strip()
if not my_name:
return self.redirect('/error')
my_image = self.request.get('image').strip()
if not my_image:
return self.redirect('/error')
my_gallery_key = ndb.Key('MyGallery', user.user_id() + "-" + my_name)
my_gallery = my_gallery_key.get()
if not my_gallery:
return self.redirect('/error')
for i, image in enumerate(my_gallery.images[:]):
if my_image != image.name:
continue
my_image = my_gallery.images.pop(i)
blobstore.delete(my_image.blob)
break
my_gallery.put()
self.redirect('/gallery?name=' + my_name)
def delete(self, slash, item_id):
item_key = ndb.Key(urlsafe=item_id)
item = item_key.get()
images = item.images
for image in images:
blobstore.delete(image['blob_key'])
item_key.delete()
def post(self):
upload_files = self.get_uploads('file')
blob_info = upload_files[0]
# Resize the image
image = images.Image(blob_key=blob_info.key())
image.resize(width=WOOF_FEED_ITEM_IMAGE_MAX_WIDTH,
height=WOOF_FEED_ITEM_IMAGE_MAX_HEIGHT)
thumbnail = image.execute_transforms(output_encoding=images.JPEG)
# Save Resized Image back to blobstore
file_name = files.blobstore.create(mime_type='image/jpeg')
with files.open(file_name, 'a') as f:
f.write(thumbnail)
files.finalize(file_name)
# Remove the original image
blobstore.delete(blob_info.key())
blob_key = files.blobstore.get_blob_key(file_name)
# New FeedImage
feed_image = FeedImage()
feed_image.data = BlobInfo.get(blob_key)
feed_image.width = image.width
feed_image.height = image.height
feed_image.put()
# Create new FeedItem
feed_item = FeedItem()
feed_item.text = self.request.get("text")
feed_item.image = feed_image
feed_item.put()
self.redirect('/')
def post(self):
"""Do upload post."""
error_messages = []
blob_info_dict = {}
for key, value in self.request.params.items():
if isinstance(value, cgi.FieldStorage):
if 'blob-key' in value.type_options:
blob_info = blobstore.parse_blob_info(value)
blob_info_dict[value.name] = blob_info
logging.info("got blob: %s" % value.name)
self.store_blob(value.name, blob_info, error_messages)
if error_messages:
logging.error('Upload errors: %r', error_messages)
blobstore.delete(blob_info_dict.values())
self.response.set_status(303)
# TODO: fix up this format
self.response.headers.add_header(
"Location",
'/error?%s' % '&'.join('error_message=%s' % urllib.quote(m)
for m in error_messages))
else:
query = ['/nonstandard/upload_complete?camliversion=1']
query.extend('blob%d=%s' % (i + 1, k)
for i, k in enumerate(blob_info_dict.iterkeys()))
self.response.set_status(303)
self.response.headers.add_header("Location", str('&'.join(query)))
def post(self):
workbook = self.request.get("workbook")
token = self.request.get("token")
secret = self.request.get("secret")
username = self.request.get("username")
uuid = self.request.get("uuid")
blobkey = self.request.get("content")
try:
service = springpad.SpringRpcService()
service.fetcher = springpad.OAuthFetcher(APPLICATION_KEY, APPLICATION_SECRET,access_token=oauth.OAuthToken(token,secret))
service.set_user_context(username, uuid)
mutator = service.get_mutator()
blob_reader = blobstore.BlobReader(blobkey)
parser = evernotebookparser.NotebookParser2(blob_reader)
parser.get_items(lambda x: createItem(mutator,workbook,x))
logging.info("Serviced a customer")
blob_reader.close()
blobstore.delete(blobkey)
except Exception,e:
logging.exception("-------%s"%e.message)
try:
blobstore.delete(blobkey)
except :
pass
def post(self):
upload_files = self.get_uploads('file') # 'file' is file upload field in the form
blob_info = upload_files[0]
session = get_current_session()
if(not session.is_active()):
blob_info.delete()
self.redirect("/login")
mynetid = self.request.get("netid")
myfilename = str(blob_info.filename)
# let's check if the file reference already exists in datastore
q = db.GqlQuery("SELECT * FROM MyBlobFile WHERE netID =:1 AND fileName =:2", mynetid, myfilename)
results = q.get()
# if it exists, delete the blob and then delete the datastore entry
if(results != None):
resource = results.blobstoreKey
blobstore.delete(resource.key())
db.delete(results)
# now upload the new file
f = MyBlobFile()
f.netID= mynetid
f.fileName= myfilename
f.blobstoreKey = blob_info.key()
f.put()
#self.redirect('/pub/%s' % (mynetid+"/"+myfilename))
self.redirect('/list')
def post(self):
blobimages = self.get_uploads("images")
try:
event = Event()
event.name = self.request.get("name")
event.tags = self.request.get_all("tags")
event.description = self.request.get("description")
event.date = datetime.datetime.now()
event.location = db.GeoPt(self.request.get("lat"), self.request.get("lon"))
event.links = self.request.get_all("links")
event.event_type = self.request.get("event_type")
event.gravity = float(self.request.get("gravity"))
event.gravity_unit = self.request.get("gravity_unit")
event.gravity_universal = float(self.request.get("gravity_universal"))
# images uploading
event.images = []
for blobimage in blobimages:
event.images.append(blobimage.key())
event.put()
except:
# if something on save went wrong, clean the uploaded blobs
for blobimage in blobimages:
blobstore.delete(blobimage.key())
raise
# send redirect after posting, return to main page
self.redirect("/")
def delete(self):
'''Delete the photograph.
To delete a photograph, need to delete the following:
all comments
all scores
the UserComp if it exists
the blob
Also, if an extra photo, reduce the extra photo count by one
'''
all_keys = []
if self.competition:
user_comp = UserComp.query(
UserComp.user == self.user,
UserComp.comp == self.competition
).get()
all_keys.append(user_comp.key)
else:
user = self.user.get()
user.extra_photo_count -= 1
user.put()
for comment_key in Comment.query(
Comment.photo == self.key).fetch(keys_only=True):
all_keys.append(comment_key)
for score_key in Scores.query(
Scores.photo == self.key).fetch(keys_only=True):
all_keys.append(score_key)
all_keys.append(self.key)
blobstore.delete(self.blob)
ndb.delete_multi(all_keys)
def post(self):
"""Do upload post."""
error_messages = []
blob_info_dict = {}
for key, value in self.request.params.items():
if isinstance(value, cgi.FieldStorage):
if 'blob-key' in value.type_options:
blob_info = blobstore.parse_blob_info(value)
blob_info_dict[value.name] = blob_info
logging.info("got blob: %s" % value.name)
self.store_blob(value.name, blob_info, error_messages)
if error_messages:
logging.error('Upload errors: %r', error_messages)
blobstore.delete(blob_info_dict.values())
self.response.set_status(303)
# TODO: fix up this format
self.response.headers.add_header("Location", '/error?%s' % '&'.join(
'error_message=%s' % urllib.quote(m) for m in error_messages))
else:
query = ['/nonstandard/upload_complete?camliversion=1']
query.extend('blob%d=%s' % (i + 1, k)
for i, k in enumerate(blob_info_dict.iterkeys()))
self.response.set_status(303)
self.response.headers.add_header("Location", str('&'.join(query)))
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 delete(self, **kwargs):
#Check that photo exists
if 'pid' in kwargs:
photo = ndb.Key(db_defs.Photos, int(kwargs['pid'])).get()
if not photo:
self.response.set_status(404)
self.response.write('Photo not found\n')
return
#removes all references to photo from any Day object
q = db_defs.Day.query().fetch()
for d in db_defs.Day.query().fetch():
for p in d.photos:
if photo.key == p:
d.photos.remove(p)
d.put()
#delete blobstore blob
blobstore.delete(photo.photo)
#delete comments associated with photo
ndb.delete_multi(ndb.Query(ancestor=photo.key).iter(keys_only=True))
#delete photo
photo.key.delete()
#gather photos to show deletion
q = db_defs.Photos.query()
keys = q.fetch(keys_only=True)
results = {'keys': [x.id() for x in keys]}
self.response.headers['Content=Type'] = 'application/json'
self.response.write(json.dumps(results))
return
def get(self):
#get specific trip
trip_key = self.request.get('trip_id')
tripk = ndb.Key(urlsafe=trip_key)
trip = tripk.get()
#get tracks for trip
track_query = Track.query(ancestor=tripk)
tracks = track_query.fetch()
for track in tracks:
#delete .gpx files from blobstore
bolob = track.blob_key
blobstore.delete(bolob)
#delete statistic
for item in TrackStatistic.query(ancestor=track.key):
item.key.delete()
#delete track
track.key.delete()
#redirect to mytrips because showing all tips will only be consistent in scope of user
# and only eventually consistent for whole datastore
trip.key.delete()
self.redirect('/tripmanager')
def post(self):
keys = self.request.POST['keys']
if not keys:
return
keys = [k.strip() for k in keys.split(',')]
blobstore.delete(keys)
self.emit_json({})
def delete(self):
key = self.request.get('key') or ''
blobstore.delete(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)
def _delete_model_blobs(self, model):
"""Deletes all blobs associated with the model (finds all BlobKeyProperty)"""
for (name, prop) in model._properties.iteritems():
if isinstance(prop, ndb.BlobKeyProperty):
if getattr(model, name):
blobstore.delete(getattr(model, name))
def _pre_delete_hook(c, k):
self = k.get()
blobstore.delete([self.smallfile, self.largefile])
ndb.delete_multi(
c.query(
ndb.OR(c.kusr == self.key, c.kart == self.key,
c.kitm == self.key)).fetch(keys_only=True))
def get(self):
# Get the default Cloud Storage Bucket name and create a file name for
# the object in Cloud Storage.
bucket = app_identity.get_default_gcs_bucket_name()
# Cloud Storage file names are in the format /bucket/object.
filename = '/{}/blobstore_demo'.format(bucket)
# Create a file in Google Cloud Storage and write something to it.
with cloudstorage.open(filename, 'w') as filehandle:
filehandle.write('abcde\n')
# In order to read the contents of the file using the Blobstore API,
# you must create a blob_key from the Cloud Storage file name.
# Blobstore expects the filename to be in the format of:
# /gs/bucket/object
blobstore_filename = '/gs{}'.format(filename)
blob_key = blobstore.create_gs_key(blobstore_filename)
# Read the file's contents using the Blobstore API.
# The last two parameters specify the start and end index of bytes we
# want to read.
data = blobstore.fetch_data(blob_key, 0, 6)
# Write the contents to the response.
self.response.headers['Content-Type'] = 'text/plain'
self.response.write(data)
# Delete the file from Google Cloud Storage using the blob_key.
blobstore.delete(blob_key)
def doCleanupDeletedFiles(cursor = None):
maxIterCount = 2 # How often a file will be checked for deletion
gotAtLeastOne = False
query = db.Query("viur-deleted-files").cursor( cursor )
for file in query.run(100):
gotAtLeastOne = True
if not "dlkey" in file.keys():
db.Delete(file.key())
elif db.Query("viur-blob-locks").filter("active_blob_references =", file["dlkey"]).get():
logging.info("is referenced, %s" % file["dlkey"])
db.Delete(file.key())
else:
if file["itercount"] > maxIterCount:
logging.info("Finally deleting, %s" % file["dlkey"])
blobstore.delete(file["dlkey"])
db.Delete(file.key())
# There should be exactly 1 or 0 of these
for f in db.Query("file").filter("dlkey =", file["dlkey"]).iter(keysOnly=True):
db.Delete(f)
else:
logging.error("Increasing count, %s" % file["dlkey"])
file["itercount"] += 1
db.Put(file)
newCursor = query.getCursor()
if gotAtLeastOne and newCursor and newCursor.urlsafe() != cursor:
doCleanupDeletedFiles(newCursor.urlsafe())
def deleteUser(self):
# We first have to remove the user's image from the blobstore, the Moodstocks DB and his reference in the Datastore
image = self.user.imageRef
if(image):
imageID = str(image.key().id())
# We delete the image from Moodstocks DB
moodstocksHandler = Moodstocks()
moodstocksHandler.deleteObject(imageID)
# We delete the image in the blobstore
blobInfo = image.blobKey
blobKey = blobInfo.key()
blobstore.delete(blobKey)
# We can now remove the image reference
image.delete()
# We first remove the vcard
vcard = self.user.vcardRef
if(vcard):
vcard.delete()
self.user.delete()
logging.info("User has been removed from Captur.io")
path = os.path.join(os.path.dirname(__file__), 'templates/delete/information_removed.html')
self.response.out.write(template.render(path, None))
def delete_user(user_id, anonymous=False):
"""Delete the User and associated pic, UserQuestions and UserSeasons."""
cls = models.AnonymousUser if anonymous else models.User
user = cls.get_by_id(user_id)
if not user:
return
user_key = user.key
to_delete = [user_key]
# Delete UserQuestion.
user_question_query = models.UserQuestion.query(
models.UserQuestion.user == user_key)
for user_question_key in user_question_query.iter(keys_only=True):
to_delete.append(user_question_key)
# Delete UserSeason.
if not anonymous:
user_season_query = models.UserSeason.query(
models.UserSeason.user == user_key)
for user_season_key in user_season_query.iter(keys_only=True):
to_delete.append(user_season_key)
ndb.delete_multi(to_delete)
# Delete the user pic.
if user.pic:
blobstore.delete(user.pic)
def attachments_delete(self, request):
"""Remove metainfo for a single attachments for a timeline card"""
current_user = endpoints.get_current_user()
if current_user is None:
raise endpoints.UnauthorizedException("Authentication required.")
card = ndb.Key("TimelineItem", request.itemId).get()
if card is None or card.user != current_user:
raise endpoints.NotFoundException("Attachment not found.")
if card.attachments is not None:
for att in card.attachments:
if att.id == request.attachmentId:
# Delete attachment from blobstore
blobkey = blobstore.BlobKey(request.attachmentId)
blobstore.delete(blobkey)
# Remove attachment from timeline card
card.attachments.remove(att)
card.put()
return AttachmentResponse(id=att.id)
raise endpoints.NotFoundException("Attachment not found.")
def delete_bucket_file(bucket_key):
try:
blobstore.delete(bucket_key)
return True
except Exception, e:
logging.error(e)
return False
def paper_upload_view():
# big thanks to Stack Overflow user Koffee for explaining how this works
# http://stackoverflow.com/a/18073466/2752467
f = request.files['file']
header = f.headers['Content-Type']
parsed_header = parse_options_header(header)
blob_key = blobstore.BlobKey(parsed_header[1]['blob-key'])
paper_key = request.args.get("id")
paper = ndb.Key(urlsafe=paper_key).get()
blob_stream = blobstore.BlobReader(blob_key)
if not is_pdf(blob_stream):
blob_stream.close()
blobstore.delete(blob_key)
return redirect(url_rule["paper"] + "?id=" + paper_key
+ "&ispdf=false")
blob_stream.close()
# sanity check: file is associated with a paper owned by the current user
if paper and paper.author == \
lookup_user(users.get_current_user().user_id()).key:
if paper.file != None:
# prevent old versions of file from being orphaned
blobstore.delete(paper.file)
paper.file = blob_key
paper.put()
# paper_view_get() will handle most error scenarios
return redirect(url_rule["paper"] + "?id=" + paper_key
+ "&update=success")
def get(self):
confirm = self.request.get('confirm')
if confirm != "true":
return
epub_key = self.request.get('key')
epub = db.get(epub_key)
account = get_current_session().get("account")
entry = model.LibraryEntry.all().filter("epub = ", epub).filter(
"user ="******"private", "public"]:
index = search.Index(indexName)
opts = search.QueryOptions(limit=1000, ids_only=True)
query = search.Query(query_string="book:%s" % epub_key,
options=opts)
docs = index.search(query)
for doc in docs:
index.remove(doc.doc_id)
blobstore.delete(epub.blob.key())
db.delete(epub)
self.redirect('/list')
else:
self.response.out.write("Not permitted")
def post(self):
enforce_login(self)
upload_files = self.get_uploads(
'file') # 'file' is file upload field in the form
blob_info = upload_files[0]
epub = model.ePubFile(blob=blob_info, blob_key=blob_info.key())
epub.put()
entry = model.LibraryEntry(epub=epub,
user=get_current_session().get("account"))
entry.put()
unpacker = unpack.Unpacker()
existing, error = unpacker.unpack(epub)
if error is None:
epub_key = epub.key() if existing is None else existing.key()
logging.info("Indexing epub with key %s" % epub_key)
taskqueue.add(queue_name='index',
url='/index',
countdown=2,
params={
'key': epub_key,
'user': get_current_session().get("account")
})
epub.get_cover()
self.redirect("/book/" + str(epub.key().id()))
else:
db.delete(entry)
blobstore.delete(epub.blob.key())
db.delete(epub)
error = "Invalid EPUB file" if error.find(
"File is not a zip") > 0 else error
respondWithMessage(self, "Upload error: " + error)
def post(self):
upload_files = self.get_uploads('file') # 'file' is file upload field in the form
blob_info = upload_files[0]
Process_CSV(blob_info)
blobstore.delete(blob_info.key()) # optional: delete file after import
self.redirect('/')
def POST(self, request):
request = web.ctx.path
data = web.data()
s = data.find('blob-key=')
if s < 0:
raise web.BadRequest()
s += 10
e = data.find('"', s)
if e < 0:
raise web.BadRequest()
data = data[s:e]
if not data:
raise web.BadRequest()
if not blobstore.BlobInfo.get(data):
# The blobKey does not exist
raise web.NotFound()
meta = _StoreMeta.get_by_key_name(request)
if meta:
# Delete the existing blob
blobstore.delete(meta.blobKey)
meta = _StoreMeta(key_name=request)
meta.blobKey = data
logging.warning('BlobKey: %s' % meta.blobKey)
meta.put()
# This redirection is empty and useless,
# required from the appengine SDK...
raise web.HTTPError(status='302 Found')
def admin_delete(self, key):
try:
item = self.util.decode_key(key).get()
file_key = item.file
blobstore.delete(file_key)
except:
pass
return scaffold.delete(self, key)