def context(self, data, check, mutator):
"""Handler for default HTTP GET request."""
context = {'page_name': 'Student form upload'}
form_data = {}
if data.ndb_profile.student_data.consent_form:
form_data['consent_form'] = blobstore.BlobInfo(
data.ndb_profile.student_data.consent_form)
if data.ndb_profile.student_data.enrollment_form:
form_data['enrollment_form'] = blobstore.BlobInfo(
data.ndb_profile.student_data.enrollment_form)
upload_form = UploadForm(data, initial=form_data)
if profile_logic.hasStudentFormsUploaded(data.ndb_profile):
kwargs = dicts.filter(data.kwargs, ['sponsor', 'program'])
claim_tasks_url = reverse('gci_list_tasks', kwargs=kwargs)
context['form_instructions'] = CLAIM_TASKS_NOW % claim_tasks_url
# TODO(ljvderijk): This can be removed when AppEngine supports 200 response
# in the BlobStore API.
if data.GET:
for key, error in data.GET.iteritems():
if not key.startswith('error_'):
continue
field_name = key.split('error_', 1)[1]
upload_form.errors[field_name] = upload_form.error_class(
[error])
context['form'] = upload_form
context['form_verification_awaiting'] = (
ci_profile_logic.isFormVerificationAwaiting(data.ndb_profile))
return context
def as_json(self):
attrs = {
'id': self.key.id(),
'location': {
'latitude': self.location.lat,
'longitude': self.location.lon,
},
'upvotes': self.upvotes,
'downvotes': self.downvotes,
'created_at': self.created_at.isoformat(),
'viewed_at':
self.viewed_at.isoformat() if self.viewed_at else None,
'uploader': self.uploader,
'view_count': self.view_count,
}
if self.video:
attrs['video_url'] = '/video/download/%s' % blobstore.BlobInfo(
self.video).key()
else:
attrs['video_url'] = blobstore.create_upload_url(
'/video/upload/%s' % self.key.id())
if self.thumbnail:
attrs[
'thumbnail_url'] = '/thumbnail/download/%s' % blobstore.BlobInfo(
self.thumbnail).key()
else:
attrs['thumbnail_url'] = blobstore.create_upload_url(
'/thumbnail/upload/%s' % self.key.id())
return attrs
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):
uploads = self.get_uploads()
for upload in uploads:
fileName = blobstore.BlobInfo(upload.key()).filename
fileSize = blobstore.BlobInfo(upload.key()).size
createdAt = blobstore.BlobInfo(upload.key()).creation
main.addFile(upload, fileName, fileSize, createdAt)
self.redirect('/')
def validate(self, value):
"""Validate that assigned value is BlobInfo.
Automatically converts from strings and BlobKey instances.
"""
if isinstance(value, (basestring)):
value = blobstore.BlobInfo(blobstore.BlobKey(value))
elif isinstance(value, blobstore.BlobKey):
value = blobstore.BlobInfo(value)
return super(MigratingBlobReferenceProperty, self).validate(value)
def post(self):
# getting variable that include necessary informations for uploading file.
upload = self.get_uploads()[0]
# getting path
root = self.session.get('root')
path = self.request.POST.get('path')
if path != '':
file_path = root + '/' + path
else:
file_path = root
# Get file info from blobinfo
file_name = upload.filename
# Check if it duplicates
if checkDuplicatedFile(root, file_name):
# Delete the file from blobstore
blobstore.BlobInfo(upload.key()).delete()
# Display error message
self.redirect('/?path=' + path + '&err=File already exists.')
return
file_size = int(round(blobstore.BlobInfo(upload.key()).size / 1000))
if file_size < 1:
file_size = 1
file_date = blobstore.BlobInfo(upload.key()).creation
# When uploading file, if the file with same name and path is saved in blobstore, delete earlier file and rewrite that file
query_result = File.query()
query_result = query_result.filter(File.path == file_path)
query_result = query_result.filter(File.name == file_name)
result = query_result.fetch()
if len(result) > 0:
result[0].key.delete()
blobstore.delete(result[0].blob_key)
# file update to datastore
file = File()
file.name = file_name
file.path = file_path
file.blob_key = upload.key()
file.size = file_size
file.cdate = str(file_date.strftime("%m/%d/%Y %H:%M:%S"))
file.put()
self.redirect('/?path=' + path)
def post(self):
upload = self.get_uploads()[0]
blobinfo = blobstore.BlobInfo(upload.key())
new_post = Post()
new_post.blob = upload.key()
caption = self.request.get('caption')
new_post.caption = caption
now = datetime.now()
new_post.time = str(now)
new_post.hour = str(now.hour) + ':' + str(now.minute) + ' ' + str(
now.day) + '-' + str(now.month) + '-' + str(now.year)
user = users.get_current_user()
myuser_key = ndb.Key('MyUser', user.user_id())
myuser = myuser_key.get()
new_post.user = myuser_key
post_key = new_post.put()
#post_id = post_key.id()
myuser.users_posts.append(post_key)
myuser.put()
self.redirect('/')
def upload_creative_asset(self,
asset_type,
filename,
asset_key,
advertiser_id,
retry_count=0):
try:
creative_asset = {
'assetIdentifier': {
'name': filename,
'type': asset_type
}
}
asset_file = blobstore.BlobReader(asset_key)
mimetype = blobstore.BlobInfo(asset_key).content_type
media = http.MediaIoBaseUpload(asset_file,
mimetype=mimetype,
resumable=False)
return self.service.creativeAssets().insert(
advertiserId=advertiser_id,
profileId=self.profile_id,
media_body=media,
body=creative_asset).execute()
except http.HttpError, e:
if e.resp.status in [403, 500, 503
] and retry_count < self.MAX_RETRIES:
return self.upload_creative_asset(asset_type, filename,
asset_key, advertiser_id,
retry_count + 1)
else:
raise
def post(self):
user = users.get_current_user()
presentfolder = self.request.get('presentfolder')
upload = self.get_uploads()[0]
blobinfo = blobstore.BlobInfo(upload.key())
file = blobinfo.filename
flag = 0
dir_key = ndb.Key('directory', presentfolder)
dir = dir_key.get()
if not dir:
dir = directory(id=presentfolder)
dir.file = file
dir.directoryName = presentfolder
dir.fileBool = True
dir.blobname = upload.key()
my_user_key = ndb.Key('MyUser', user.user_id())
my_user = my_user_key.get()
if my_user == None:
my_user = MyUser(id=user.user_id())
my_user.username = user.user_id()
for x in my_user.directory:
if x.file == file:
flag = 1
if flag == 0:
my_user.directory.append(dir)
my_user.put()
self.redirect('/')
def post(self):
error_message = ''
upload = self.get_uploads()[0]
blobinfo = blobstore.BlobInfo(upload.key())
filename = blobinfo.filename
directory_id = self.request.get('directory_id')
directory_key = ndb.Key(Directory, directory_id)
directory = directory_key.get()
file_exists_counter = 0
for each in directory.list_of_files:
if each == filename:
error_message = 'Sorry a file with this name exists'
file_exists_counter = file_exists_counter + 1
break
if file_exists_counter == 0:
directory.list_of_files.append(filename)
directory.blobs.append(upload.key())
directory.put()
self.redirect('/')
else:
user = users.get_current_user()
logout = users.create_logout_url('/')
template_values = {
'user': user,
'logout': logout,
'error_message': error_message,
}
template = JINJA_ENVIRONMENT.get_template('error.html')
self.response.write(template.render(template_values))
def post(self):
self.response.headers['Content-Type'] = 'text/html'
user = users.get_current_user()
myuser_key = ndb.Key(MyUser, user.user_id())
myuser = myuser_key.get()
if (self.request.get('button') == 'Add Image'):
h_caption = self.request.get('caption')
upload = self.get_uploads()[0]
blobinfo = blobstore.BlobInfo(upload.key())
#datetime_obj = datetime.now()
post_obj = Post()
post_obj.image = upload.key()
post_obj.caption = h_caption
post_obj.creator = myuser.email_address
post_obj.posting_time = datetime.now().strftime(
"%Y-%m-%d %H:%M:%S")
post_obj.key = ndb.Key('Post', str(upload.key()))
postkey = post_obj.put()
logging.info("DEBUG")
#print(postkey)
logging.info("END")
myuser.posts.append(post_obj.key)
myuser.put()
self.redirect('/')
def __save(self, con, cat, stts):
stts['csz'] = len(con)
stts['key'] = model.save_blob(con, "%(cat)s.zip" % {'cat': cat})
blob_info = blobstore.BlobInfo(blobstore.BlobKey(stts['key']))
zr = blob_info.open()
zi = zipfile.ZipFile(zr, 'r')
if len(zi.infolist()) != 1:
zi.close()
zr.close()
logging.error('No ZIP entry.')
return None
for zip_info in zi.infolist():
t = zip_info.date_time
stts['ts'] = "%(y)04d-%(m)02d-%(d)02d %(H)02d:%(M)02d:%(S)02d" % {
'y': t[0],
'm': t[1],
'd': t[2],
'H': t[3],
'M': t[4],
'S': t[5]
}
stts['dsz'] = zip_info.file_size
stts['cnt'] = 1
break
zi.close()
zr.close()
def post(self):
user = users.get_current_user()
if user == None:
self.redirect('/')
else:
current_user = MyUser.get(user.user_id())
dir_id = self.request.get('dir')
owner_user, directory, parent = check(current_user.key, dir_id)
if owner_user and directory and (
directory.is_users_dir(current_user.key)
or has_write_permission(current_user.key, parent)):
for upload in self.get_uploads():
blobinfo = blobstore.BlobInfo(upload.key())
my_file = File(name=blobinfo.filename, blob=upload.key())
if not directory.file_exists(my_file.name):
directory.files.append(my_file)
directory.put()
self.redirect(self.request.referer)
def post(self):
upload = self.get_uploads()[0]
blobinfo = blobstore.BlobInfo(upload.key())
user = users.get_current_user()
current_folder = self.request.get('current_folder')
file_name = current_folder + blobinfo.filename
file_key = ndb.Key('FileInfo', user.email() + file_name)
file = file_key.get()
if file is not None:
message = "Error: file path exists (" + file_name + ")"
else:
file = FileInfo(id=user.email() + file_name)
file.name = file_name
file.blob = blobinfo.key()
parent = ndb.Key('FolderInfo', user.email() + current_folder).get()
parent.files.append(file.key)
file.parent = parent.key
file.put()
parent.put()
message = "Success: file uploaded (" + file_name + ")"
time.sleep(1)
self.redirect("/?current_folder=" + current_folder + "&message=" +
message)
def convert(self):
"""データ変換処理を実行する。"""
stts = {}
key = self.get_stt_prev('key')
blob_info = blobstore.BlobInfo(blobstore.BlobKey(key))
zr = blob_info.open()
zi = zipfile.ZipFile(zr, 'r')
if len(zi.infolist()) < 1:
zi.close()
zr.close()
return None
zw = StringIO.StringIO()
zo = zipfile.ZipFile(zw, 'w', zipfile.ZIP_DEFLATED)
self.proc_all(zi, zo, stts)
zo.close()
zi.close()
zr.close()
con = zw.getvalue()
stts['csz'] = len(con)
sha1 = hashlib.sha1()
sha1.update(con)
stts['dig'] = sha1.hexdigest()
stts['key'] = save_blob(
con, '%(tsk)s_%(cat)s-%(ts)s.zip' % {
'cat': self.get_cat(),
'tsk': self.get_task(),
'ts': self.get_ts_short(),
})
self.set_stt(stts)
return 'ok'
def post(self, data, check, mutator):
"""Handles POST requests for the bulk create page."""
form = UploadForm(data,
data=data.POST,
files=data.request.file_uploads)
if not form.is_valid():
# we are not storing this form, remove the uploaded blobs from the cloud
for f in data.request.file_uploads.itervalues():
f.delete()
# since this is a file upload we must return a 300 response
extra_args = []
for field, error in form.errors.iteritems():
extra_args.append('error_%s=%s' % (field, error.as_text()))
return data.redirect.to('gci_student_form_upload',
extra=extra_args)
# delete existing data
cleaned_data = form.cleaned_data
for field_name in data.request.file_uploads.keys():
if field_name in cleaned_data:
existing = getattr(data.ndb_profile.student_data, field_name)
if existing:
blobstore.BlobInfo(existing).delete()
form.save()
# TODO(nathaniel): make this .program() call unnecessary.
data.redirect.program()
return data.redirect.to('gci_student_form_upload')
def get(self, data, check, mutator):
if self._tax(data):
blob_key = self._profile(data).student_data.tax_form
else:
blob_key = self._profile(data).student_data.enrollment_form
return bs_helper.sendBlob(blobstore.BlobInfo(blob_key))
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, 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 blob(self):
if self._blob is not None:
return self._blob
else:
if self.__dict__.has_key('blob_key') and self.blob_key is not None:
self._blob = blobstore.BlobInfo(blobstore.BlobKey(self.blob_key))
return self._blob
else:
return None
def make_value_from_datastore(self, value):
"""Translate datastore value to BlobInfo."""
if value is None:
return None
# The two lines of difference of MigratingBlobReferenceProperty:
if isinstance(value, basestring):
value = blobstore.BlobKey(value)
return blobstore.BlobInfo(value)
def post(self):
upload = self.get_uploads()[0]
blobinfo = blobstore.BlobInfo(upload.key())
filename = blobinfo.filename
collection_key = ndb.Key('BlobCollection', 1)
collection = collection_key.get()
collection.filenames.append(filename)
collection.blobs.append(upload.key())
collection.put()
self.redirect('/')
def get(self, urlsafe_key):
urlsafe_key = str(urllib.unquote(urlsafe_key))
key = ndb.Key(urlsafe=urlsafe_key)
if key.kind() == "Newsletter":
newsletter = key.get()
blobstore.BlobInfo(newsletter.NewsletterBlob).delete()
key.delete()
else:
self.abort(400, "Can only delete kind 'Newsletter'")
self.redirect('/manage/newsletter_archive')
def post(self):
up = self.get_uploads()
if len(up) == 0:
display.give_error(self, '/', "No File Selected")
else:
global e
for upload in up:
filename = blobstore.BlobInfo(upload.key()).filename
e = file_op.adding(upload, filename, datetime.datetime.now())
display.give_error(self, '/', e)
def post(self):
uploads = self.get_uploads()
# upload all the files that came in the request
for upload in uploads:
# Get file name from the info of the file
filename = blobstore.BlobInfo(upload.key()).filename
functions.addFile(upload, filename)
self.redirect('/')
def post(self):
self.response.headers['Content-Type'] = 'text/html'
url_string = ''
url = ''
user = users.get_current_user()
if user:
url = users.create_logout_url(self.request.uri)
url_string = 'logout'
myuser_details = ndb.Key('MyUser', user.email())
myuser = myuser_details.get()
if myuser == None:
myuser = MyUser(id=user.email())
myuser.email_address = user.email()
myuser.userId = user.nickname()
welcome = 'Welcome to the application'
myuser.put()
upload = self.get_uploads()[0]
blobinfo = blobstore.BlobInfo(upload.key())
image_url = get_serving_url(blobinfo)
caption = self.request.get('caption')
collection_key = ndb.Key('post', user.email())
collection_key = collection_key.get()
if collection_key == None:
collection_key = post(id=user.email())
collection_key.photo_url.append(image_url)
collection_key.email_address = user.email()
collection_key.caption.append(caption)
else:
collection_key.photo_url.append(image_url)
collection_key.email_address = user.email()
collection_key.caption.append(caption)
collection_key.put()
self.redirect('/')
else:
url = users.create_login_url(self.request.uri)
url_string = 'login'
self.redirect('/')
template_values = {
'url': url,
'url_string': url_string,
'user': user,
'collection_key': collection_key,
}
template = JINJA_ENVIRONMENT.get_template('photocomment.html')
self.response.write(template.render(template_values))
def asset_to_upload(self, asset_filename):
asset_key = None
for asset in self.project.assets:
if asset_filename.lower() == blobstore.BlobInfo(asset).filename.lower():
asset_key = asset
break
if not asset_key:
raise ValueError(
'Feed contains a reference to "%s" that has not yet been uploaded as an asset to this project!'
% asset_filename)
return asset_key
def get(self, data, check, mutator):
"""Allows hosts to download the student forms."""
if url_names.CONSENT_FORM_GET_PARAM in data.GET:
download = data.url_ndb_profile.student_data.consent_form
elif url_names.ENROLLMENT_FORM_GET_PARAM in data.GET:
download = data.url_ndb_profile.student_data.enrollment_form
else:
raise exception.BadRequest(message='No file requested')
# download has been requested
if download:
return bs_helper.sendBlob(blobstore.BlobInfo(download))
else:
raise exception.NotFound(message='File not found')
def post(self):
user = users.get_current_user()
my_user_key = ndb.Key('User', user.user_id())
my_user = my_user_key.get()
upload = None
msg = "Invalid form input"
if len(self.get_uploads()) >= 1:
upload = self.get_uploads()[0]
blobinfo = blobstore.BlobInfo(upload.key())
ext = blobinfo.filename.split(".")[1]
if str(ext).upper() == "JPG" or str(ext).upper() == "PNG":
filename = "post_" + str(
time.mktime(datetime.now().timetuple())) + "." + ext
lastname = self.request.get('lastname')
firstname = self.request.get('firstname')
username = self.request.get('username')
if self.request.get('lastname') == '' or self.request.get(
'firstname') == '' or self.request.get(
'username') == '':
url = '/update-profile?msg=' + msg + '&file=Please select upload image&lastname=' + lastname + '&firstname=' + firstname + '&username='******'BlobCollection', 1)
collection = collection_key.get()
collection.filenames.append(filename)
collection.blobs.append(upload.key())
collection.put()
my_user.lastname = lastname
my_user.firstname = firstname
my_user.username = username
my_user.image_label = filename
my_user.email = user.email()
my_user.put()
url = "/profile"
self.redirect(url)
return
else:
url = '/update-profile?msg=' + msg + '&file=Only JPG or PNG files is allowed'
self.redirect(url)
return
else:
url = '/update-profile?msg=' + msg + '&file=Please select upload image'
self.redirect(url)
return
def get(self, data, check, mutator):
"""Handles download of the forms otherwise resumes normal rendering."""
if 'consent_form' not in data.GET and 'enrollment_form' not in data.GET:
# no download request has been specified
return super(StudentFormUpload, self).get(data, check, mutator)
elif 'consent_form' in data.GET:
download = data.ndb_profile.student_data.consent_form
elif 'enrollment_form' in data.GET:
download = data.ndb_profile.student_data.enrollment_form
# download has been requested
if download:
return bs_helper.sendBlob(blobstore.BlobInfo(download))
else:
raise exception.NotFound(message='File not found')
