def get(self): keyword = self.request.get('q') if keyword: print keyword self.redirect('/search?keyword=%s'%keyword) user = users.get_current_user() if not user: self.redirect(users.create_login_url('/profile_create')) else: user_query = ndb.Key(Webusers, str(user.email())).get() if not user_query: profile_url = blobstore.create_upload_url('/api/profile') template_value = { 'profile_url': profile_url, 'user': user.email() } template = JINJA_ENVIRONMENT.get_template('profile_create.html') self.response.write(template.render(template_value)) elif not user_query.nickname: profile_url = blobstore.create_upload_url('/api/profile') template_value = { 'profile_url': profile_url, 'user': user.email() } template = JINJA_ENVIRONMENT.get_template('profile_create.html') self.response.write(template.render(template_value)) else: self.redirect('/my_city')
def get(self): """ Display a random meme to get rated """ # Get all the memes in the datastore. # WARNING: This technicque is slow and will fail eventually, but its simple and works for small numbers of entries. meme_list = MemeModel.query().fetch(keys_only=True) # Choose a random index to get a key for random_meme = meme_list[random.randint(0, len(meme_list)-1)] try: meme = random_meme.get() #Set the template values template_values = { 'meme': meme.key.urlsafe(), 'title': "Rate this meme!", 'image': images.get_serving_url(meme.image, size=400), 'rating': meme.rating, 'upload_url': blobstore.create_upload_url('/add') } except Exception: template_values = { 'title': "No memes found!", 'upload_url': blobstore.create_upload_url('/add') } # Get the template for the page template = JINJA_ENVIRONMENT.get_template('page.htm') # Output the data to the browser/client self.response.out.write(template.render(template_values))
def get(self): questionID = self.request.get('id') id = get_user_id() review = models.getQuestionFromURL(questionID) is_admin = 0 if users.is_current_user_admin(): is_admin = 1 if id is not None: q = models.check_if_user_exists(id) if q == None: page_params = { 'upload_url': blobstore.create_upload_url('/profile'), 'user_email': get_user_email(), 'login_url': users.create_login_url(), 'logout_url': users.create_logout_url('/'), 'user_id': get_user_id(), 'profile': models.getUser(id), 'admin': is_admin } render_template(self, 'createProfile.html' ,page_params) return page_params = { 'upload_urlQE': blobstore.create_upload_url('/ReviewQuestion?id=' + questionID), 'user_email': get_user_email(), 'login_url': users.create_login_url(), 'logout_url': users.create_logout_url('/'), 'user_id': id, 'review': review, 'admin' : is_admin } render_template(self, 'questionReview.html', page_params)
def get(self): id = get_user_id() is_admin = 0 if users.is_current_user_admin(): is_admin = 1 if id is not None: q = models.check_if_user_exists(id) if q == None: page_params = { 'upload_url': blobstore.create_upload_url('/profile'), 'user_email': get_user_email(), 'login_url': users.create_login_url(), 'logout_url': users.create_logout_url('/'), 'user_id': get_user_id(), 'profile': models.getUser(id), 'admin': is_admin } render_template(self, 'createProfile.html' ,page_params) return newList = models.getCategoryList() page_params = { 'catList': newList, 'upload_urlQ': blobstore.create_upload_url('/NewQuestion'), 'user_email': get_user_email(), 'login_url': users.create_login_url(), 'logout_url': users.create_logout_url('/'), 'user_id': id, 'admin' : is_admin } render_template(self, 'newQuestionSubmit.html', page_params)
def get(self,*args,**kwargs): #@UnusedVariable ''' @keyword actor: @keyword action: if the deal will be a new deal or if it will be edited @return: url @rtype: string ''' user = kwargs.get('actor') action = kwargs.get('action') try: if action == 'add': upload_url = blobstore.create_upload_url(NEW_DEAL_UPLOAD_URL) elif action == 'edit': upload_url = blobstore.create_upload_url(EDIT_DEAL_UPLOAD_URL) else: raise KeyError('Action not recognized: '+str(action)) response = { 'uploadURL' : upload_url } api_utils.send_response(self,response,user) except KeyError,e: self.send_error(e)
def get(self,fid): matches=False if "iPhone" in self.request.headers["User-Agent"] or "Android" in self.request.headers["User-Agent"]: matches=True if matches: print "Mobile" mobile=True else: print "Desktop" mobile=False prefetchFilelist=apriori1.fileList filelist=FileInfo.all() filelist.filter('user ='******'User-Agent'] if fid: new_file=FileInfo.get_by_id(long(fid)) if not new_file: self.error(404) return self.render_template("upload.html",{'post_url':blobstore.create_upload_url('/uploaded'),'mobile':mobile,'new_file':new_file,'filelist':filelist,'ua':ua,'logout_url':users.create_logout_url('/'), }) else: self.render_template("upload.html",{'post_url':blobstore.create_upload_url('/uploaded'),'mobile':mobile,'filelist':filelist,'ua':ua,'logout_url':users.create_logout_url('/'), })
def get(self): #template_values={'upload_url':upload_url} template_values ={} fileName = self.request.get('fileName') if fileName: h = Helper() #check file name exists or not file_info = h.isFileExists(fileName) if file_info: val= self.request.get('overwrite') if val == 'overwrite': #delete existing blob and create new blob to upload if overwrite is checked h.deleteBlob(file_info.blog_key) #redirect to upload upload_url = blobstore.create_upload_url('/upload') template_values={'upload_url':upload_url} path = os.path.join(os.path.dirname(__file__), 'create.html') self.response.out.write(template.render(path, template_values)) else: template_values['message'] = 'file name already exists !' path = os.path.join(os.path.dirname(__file__), 'create_pre.html') self.response.out.write(template.render(path, template_values)) else: upload_url = blobstore.create_upload_url('/upload') template_values={'upload_url':upload_url} path = os.path.join(os.path.dirname(__file__), 'create.html') self.response.out.write(template.render(path, template_values)) else: path = os.path.join(os.path.dirname(__file__), 'create_pre.html') self.response.out.write(template.render(path, template_values))
def post(self): contests = Contest.all().order('-created') today = datetime.datetime.now() c = self.request.get('c') if c: upload_url = blobstore.create_upload_url('/administration/contest?c='+c) try: ct = Contest.get(c) form = ContestForm(self.request.POST, instance=ct) except: form = ContestForm(self.request.POST) else: upload_url = blobstore.create_upload_url('/administration/contest') form = ContestForm(self.request.POST) if form.is_valid(): contest = form.save(commit=False) upload_files = self.get_uploads('file') if upload_files: contest.banner = upload_files[0] contest.put() self.redirect(self.uri_for('admin_contest')+'?success=1') return self.render_response(self.template, locals())
def get(self): user = Session(self).get_current_user() if not user: nextPath = '='.join(('/login?continue',self.request.url)) self.redirect(nextPath) else: targetUser = None #if the page was passed a userId look at that profile instead #Todo #If user.Id == ID (user looks at self) or user.isAdmin if self.request.get('userId'): targetUserId = long(self.request.get('userId')) targetUser = Account.get_by_id(targetUserId) #else the logged in user else: targetUser = user userUploadURL = blobstore.create_upload_url('/myProfilePhotoUpload') targetUserUploadURL = blobstore.create_upload_url('/changeUserDetails') template_values = { 'user' : user, 'targetUser': targetUser, 'userUploadURL':userUploadURL, 'targetUserUploadURL':targetUserUploadURL } template = JINJA_ENVIRONMENT.get_template('profile.html') self.response.write(template.render(template_values))
def get(self, class_id): cls = Class.get_by_id(int(class_id)) if not cls: self.abort(404) upload_to = blobstore.create_upload_url('/addmaterial') upload_video_to = blobstore.create_upload_url(uri_for('upload_video')) return self.render('app/class_detail.html', cls=cls, upload_to=upload_to, upload_video_to=upload_video_to)
def get(self, username): """display profile of user with username, if None, display logged in user """ mode = self.request.get('mode') upload_url = "" if mode == 'add_project': template = 'profile/add_project.html' upload_url = blobstore.create_upload_url('/' + username, max_bytes_per_blob=self.MAX_IMG_SIZE) elif mode == 'edit_project': template = 'profile/edit_project.html' upload_url = blobstore.create_upload_url('/' + username, max_bytes_per_blob=self.MAX_IMG_SIZE) elif mode == 'edit': template = 'profile/edit.html' else: template = 'profile/profile.html' user = User.get_user(username) if not user: user = User.save(username, '{}@someplace.com'.format(username), 'some long password') gravatar = user.avatar_url friends = [] if user: all, ic, cc = self.organize_courses_for(user) if user.dob: dob = user.dob.strftime('%m/%d/%Y') else: dob = None projects = Project.get_projects_by_ids(user.projects) context = {'user': user, 'dob': dob, 'username': username, 'gravatar': gravatar, 'friends': friends, 'friend_btn': False, 'courses_all': Course.courses_to_dict(), 'courses_completed': cc, 'courses_incomplete': ic, 'projects': projects, 'upload_url': upload_url, 'errors': {}} self.render(template, context) else: self.redirect('/logout')
def get(self): filelist=FileInfo.all() if not filelist: self.render_template("upload.html",{ 'post_url':blobstore.create_upload_url('/uploaded'),'logout_url':users.create_logout_url('/'), }) else: self.render_template("upload.html",{ 'post_url':blobstore.create_upload_url('/uploaded'),'filelist':filelist,'logout_url':users.create_logout_url('/'), })
def get(self): #Recuperamos el ID de URL if self.session.get('usuario'): idP = int(self.request.get('idPension')) #Obtenemos ID de URL editarPens = models.Lugar.get_by_id(idP) #Buscamos la ID en la BD try: editarPens.key().id() except: print "Pension no encontrada" self.redirect("/adminIndex") else: print "Pension encontrada: "+str(editarPens.key().id()) carrete = db.Query(models.CarreteFotos).filter("str_LugarID", str(idP)) #Cargamos carrete restFotos = 5 #Fotos maximas en el carrete #Paso 1-> Eliminamos una foto? if self.request.get('deletePhoto'): deleteKey = self.request.get('deletePhoto') for foto in carrete: if foto.str_urlFoto == deleteKey: foto.delete() restFotos = restFotos+1 else: pass #Paso 2-> Comprobamos si existen fotos en el carrete if not carrete.get(): hayFotosCarrete = 0 #print "No hay fotos en carrete" else: hayFotosCarrete = 1 #print "Hay fotos en carrete" for p in carrete: restFotos = restFotos - 1 #print restFotos #Paso 3-> Cargamos las direcciones de template y url's de carga template_env = jinja2.Environment(loader = jinja2.FileSystemLoader(os.getcwd())) template = template_env.get_template('admin/editarPension.html') upload_url = blobstore.create_upload_url('/cargarArchivo?file=fotoperfil&idPens='+str(idP)) uploadCarrete = blobstore.create_upload_url('/cargarArchivo?file=fotoCarrete&idPens='+str(idP)) #Paso 4-> Mandamos los datos al HTML context = { 'editarPens': editarPens, 'upload_url': upload_url, 'uploadCarrete': uploadCarrete, 'hayFotosCarrete': hayFotosCarrete, 'carrete': carrete, 'resFotos': restFotos } self.response.out.write(template.render(context)) else: self.redirect("/")
def testShowForm(self): self.mox.StubOutWithMock(blobstore, 'create_upload_url') layer = model.Layer(name='a', world='earth') layer_id = layer.put().id() handler = resource.ResourceHandler() dummy_url = object() blobstore.create_upload_url('/resource-create/%d' % layer_id).AndReturn( dummy_url) self.mox.ReplayAll() self.assertEqual(handler.ShowForm(layer), {'upload_url': dummy_url})
def get(self): upload_url = blobstore.create_upload_url('/upload') self.response.out.write("""<html><link rel="stylesheet" href="/stylesheets/common.css" type="text/css" media="screen"> <script src="/stylesheets/min.js"></script> <script> function displayInline(contentUrl) { var iframe = '<iframe src="' + contentUrl + '" class="inlined-content"></iframe>'; $('#inlined_content').html(iframe); } $(document).ready(function() { $('[data-action=delete]').click(function() { return confirm('Are you sure?'); }); $('#display_inline').click(function() { var url = $(this).data('content-uri'); var fileName = $('#file_search').find(":selected").val(); uri=url+fileName; displayInline(uri); }); });</script><body><div class='main'><h2> Cloud Music Box</h2></div>""") self.response.out.write('<center><form action="%s" method="POST" enctype="multipart/form-data">' % upload_url) self.response.out.write("""Upload File:<input type="file" name="file"><input type="submit" name="submit" class="myButton" value="Submit"> </form>""") load_url = blobstore.create_upload_url('/list') #self.response.out.write('<form action="%s" method="POST" enctype="multipart/form-data">' % load_url) #self.response.out.write("""Load File:<input type="submit" #name="submit" class="myButton" value="Submit"> </form>""") #blob_obj = blobstore.BlobInfo.all() qry = EachUser.query(EachUser.author == users.get_current_user()) self.response.out.write('<br/><br/><table><tr><th>File Name</th><th>Play</th></tr>') for q in qry: blob_obj = blobstore.BlobInfo.get(q.blobkey) self.response.write('<tr><td>%s :</td>' %blob_obj.filename) self.response.write("""<td><audio controls><source src="/serve/%s" type="audio/mpeg"></audio></td></tr>""" %q.blobkey) self.response.out.write('</table>') #self.response.out.write('<input type="button" id="try" value="list" onclick=/>') self.response.out.write(""" <div id="inlined_content"> </div><div id="alert"><!--<img src="/images/dogs-listening.jpg"/>--></center>""") self.response.out.write('</body></html>')
def get(self, resource, extension=".SC2Replay"): if resource[-10:] in (".SC2Replay", ".sc2replay"): resource = resource[0:-10] query = Replay.all() query.filter('replayid =', resource) results = query.fetch(1) if results: result = results[0] blob_info = blobstore.BlobInfo.get(result.blobinfo) if blob_info: upload_url = blobstore.create_upload_url('/upload') path = os.path.join(os.path.dirname(__file__), 'download.html') self.response.headers['Cache-Control'] = 'no-cache' self.response.headers['Pragma'] = 'no-cache' baseurl = urlparse(self.request.url).netloc; if "sc2share.com" in baseurl: baseurl = "sc2share.com" template_values = { 'download_filename': blob_info.filename.encode("utf-8"), 'download_url': 'd/%s/%s' % (resource, quote(blob_info.filename.encode("utf-8"))), 'baseurl': baseurl, } self.response.out.write(template.render(path, template_values)) return else: reason = 'nosuchfile' else: reason = 'nosuchfile' upload_url = blobstore.create_upload_url('/upload') path = os.path.join(os.path.dirname(__file__), 'nofetch.html') self.response.headers['Cache-Control'] = 'no-cache' self.response.headers['Pragma'] = 'no-cache' failure_reasons = {} failure_reasons['pt'] = { 'nosuchfile': 'O arquivo pedido não existe. Pode ser que ele nunca tenha existido, pode ser que ele tenha sido apagado, e pode ser que algo catastrófico tenha acontecido. Difícil dizer o que foi.' } failure_reasons['en'] = { 'nosuchfile': 'The requested file does not exist. Maybe it never existed, maybe it has been deleted, maybe something catastrophic happened. In any case, we apologize.' } template_values = { 'upload_url': upload_url, 'errormsg': failure_reasons['en'][reason] } self.response.out.write(template.render(path, template_values))
def post(self): if self.session.get('user'): album = self.request.get('album') upload_files = self.get_uploads() blobstore.create_upload_url('/upload') access = self.request.get("access") blob_info = upload_files[0] image = Image(album=album, access=access, blob_key=blob_info.key()) image.put() self.write(render_str('album.html')) else: self.redirect('/')
def testShowRaw(self): self.mox.StubOutWithMock(blobstore, 'create_upload_url') layer = model.Layer(name='a', world='earth') layer_id = layer.put().id() handler = resource.ResourceHandler() handler.response = self.mox.CreateMockAnything() blobstore.create_upload_url('/resource-create/%d' % layer_id).AndReturn( 'Escape <me>!') blobstore.create_upload_url('/resource-bulk/%d' % layer_id).AndReturn( 'abc') handler.response.set_status(httplib.BAD_REQUEST) blobstore.create_upload_url('/resource-create/%d' % layer_id).AndReturn('q') blobstore.create_upload_url('/resource-bulk/%d' % layer_id).AndReturn('w') handler.response.set_status(httplib.OK) self.mox.ReplayAll() # Error specified. handler.request = {'error': 'abc'} handler.response.out = StringIO.StringIO() handler.ShowRaw(layer) self.assertEqual(handler.response.out.getvalue(), '%d\n\nabc\nEscape <me>!\nabc' % httplib.BAD_REQUEST) # Result specified. handler.request = {'result': 'def'} handler.response.out = StringIO.StringIO() handler.ShowRaw(layer) self.assertEqual(handler.response.out.getvalue(), '%d\ndef\n\nq\nw' % httplib.OK)
def get(self): user = users.get_current_user() if user: greeting = 'Welcome, %s! (<a href="%s">sign out</a>)' % (user.nickname(), users.create_logout_url("/")) else: greeting = '<a href="%s">Sign in or register</a>.' % users.create_login_url("/") self.response.out.write("<html><body>%s</body></html>" % greeting) # login_url = users.create_login_url(self.request.path) # logout_url = users.create_logout_url(self.request.path) uploads = None if user: q = UserUpload.all() q.filter("user ="******"UserUploadGroup", user.email())) uploads = q.fetch(100) try: if env and env.startswith("Google App Engine/"): # Connecting from App Engine self.response.out.write( """<h1 style="text-align:center"> Assignment 7 <br> Environment is Google App Engine</h1>""" ) upload_url = blobstore.create_upload_url("/upload", gs_bucket_name=bucket_name) else: upload_url = blobstore.create_upload_url("/upload") self.response.out.write( """<h1 style="text-align:center"> Assignment 7 <br> Environment is Local DEV</h1>""" ) self.response.out.write("""<h2 style="text-align:center"> Uploads images</h2>""") template = template_env.get_template("home.html") context = { "user": user, "login_url": login_url, "logout_url": logout_url, "uploads": uploads, "upload_url": upload_url, } self.response.write(template.render(context)) except Exception as e: self.response.write("Exception Occurred!!<br>") self.response.write(e.message) self.response.write(str(e.args))
def get(self): logging.info('hello'+'\xe9') refresh = self.request.get('refresh',False) if refresh: self.response.out.write('<b>THIS WILL RESET THE DB. SET REFRESH=FALSE</b><br/>') upload_url = blobstore.create_upload_url('/new/upload?refresh=True') else: upload_url = blobstore.create_upload_url('/new/upload') logging.info('!!!') logging.info(upload_url) # The method must be "POST" and enctype must be set to "multipart/form-data". self.response.out.write('<html><body>') self.response.out.write('<form action="%s" method="POST" enctype="multipart/form-data">' % upload_url) self.response.out.write('''Upload File: <input type="file" name="img"><br> <input type="submit" name="submit" value="Create!"> </form></body></html>''')
def ShowRaw(self, layer): """Displays the result of Create(), as passed to it in the query string. The results are written in 5 lines: 1. Status: BAD_REQUEST (400) if the "error" query argument is set. Otherwise OK (200). 2. Result ID: The contents of the "result" query argument. This should be the ID(s) of the created resource(s) if any were created successfully. May be empty if creation failed. 3. Error Message: The contents of the "error" query argument. May be empty if creation succeeded. 4. Single Upload URL: A new upload URL that a user can use to upload another resource. 5. Bulk Upload URL: A new upload URL that a user can use to bulk upload multiple resources. The status code is written out because on the client side, upload forms have to be submitted into an iframe and as a result the normal status code cannot be accessed through JS. GET Args: result: The ID of the created resource. error: An error message. Ignored if result is set. Args: layer: The layer to which the created resource belongs. """ error = self.request.get('error') result = self.request.get('result') layer_id = layer.key().id() single_url = blobstore.create_upload_url('/resource-create/%d' % layer_id) bulk_url = blobstore.create_upload_url('/resource-bulk/%d' % layer_id) if error: status = httplib.BAD_REQUEST else: status = httplib.OK self.response.set_status(status) self.response.out.write(status) self.response.out.write('\n') self.response.out.write(cgi.escape(result or '')) self.response.out.write('\n') self.response.out.write(cgi.escape(error or '')) self.response.out.write('\n') self.response.out.write(cgi.escape(single_url)) self.response.out.write('\n') self.response.out.write(cgi.escape(bulk_url))
def get(self): upload_url = blobstore.create_upload_url('/processupload') self.response.headers['Content-Type'] = 'text/html' self.response.write('<html><body>') self.response.write('<form action="%s" method="POST" enctype="multipart/form-data">' % upload_url) self.response.write("""Upload File: <input type="file" name="photo"><br>Temp Photo Key<input type="text" name="tempPhotoKey"><br> <input type="submit" name="submit" value="Submit"> </form></body></html>""")
def get(self): status = (0,0) stream_name=re.findall('%3D(.*)',self.request.url)[0] #Change!# stream=Stream.query(Stream.name==stream_name, Stream.author==users.get_current_user()).fetch()[0] stream=Stream.query(Stream.name==stream_name).fetch()[0] if(stream.author==users.get_current_user()): status = (1,1) elif(users.get_current_user()): status = (1,0) else: self.redirect(users.create_login_url(self.request.url)) pictures=db.GqlQuery("SELECT *FROM Picture " + "WHERE ANCESTOR IS :1 " +"ORDER BY uploaddate DESC LIMIT 3" , db.Key.from_path('Stream',stream_name)) uploadurl = blobstore.create_upload_url('/upload') showmoreurl=urllib.urlencode({'showmore': stream.name+"=="+users.get_current_user().nickname()}) geoviewurl=urllib.urlencode({'geoview': stream.name+"=="+users.get_current_user().nickname()}) template_values = { 'user_name':users.get_current_user().nickname(), 'showmoreurl': showmoreurl, 'stream_name': stream_name, 'pictures':pictures, 'status':status, 'uploadurl':uploadurl, 'geoviewurl': geoviewurl } template = JINJA_ENVIRONMENT.get_template('viewsinglestream_index.html') self.response.write(template.render(template_values))
def show(self): user = users.get_current_user() if user: parent_key = ndb.Key('Persons', users.get_current_user().email()) query = ndb.gql("SELECT * " "FROM Images " "WHERE ANCESTOR IS :1 " "ORDER BY date DESC", parent_key) upload_url = blobstore.create_upload_url('/submit') template_values = { 'user_mail' : users.get_current_user().email(), 'user_name' : users.get_current_user().email().split("@")[0], 'logout' : users.create_logout_url(self.request.host_url), 'items' : query, 'items_num' : query.count(), 'upload_url' : upload_url, } template = jinja_environment.get_template("upload.html") self.response.out.write(template.render(template_values)) else : self.redirect(self.request.host_url)
def get(self): if self.user: uploadUrl = blobstore.create_upload_url('/popupuploadphoto') templateVals = {'me': self.user, 'uploadUrl': uploadUrl, 'upload_done': 0} self.render('upload_popup_photo.html', **templateVals) else: self.redirect('/')
def get(self): upload_url = blobstore.create_upload_url('/upload_photo') # self.response.write('<form method="post" action="'+upload_url+'"><input type="file"/><input type="submit" /></form>') self.response.out.write('<html><body>') self.response.out.write('<form action="%s" method="POST" enctype="multipart/form-data">' % upload_url) self.response.out.write("""Upload File: <input type="file" name="file"><br> <input type="submit" name="submit" value="Submit"> </form></body></html>""")
def get(self): upload_url = blobstore.create_upload_url('/uploadFromAndroid') upload_url = str(upload_url) dictPassed = {'upload_url':upload_url} print(upload_url) jsonObj = json.dumps(dictPassed, sort_keys=True,indent=4, separators=(',', ': ')) self.response.write(jsonObj)
def get(self): upload_url = blobstore.create_upload_url('/upload/completed', gs_bucket_name="grevian-facebucket") template = JINJA_ENVIRONMENT.get_template('templates/upload.html') self.response.write(template.render({ 'upload_url': upload_url }))
def get(self, file_key=None, **kwargs): template = 'admin/files/new.html' context = { 'form': self.form, 'upload_url': blobstore.create_upload_url(url_for('blobstore/upload')) } return self.render_response(template, **context)
def get(self): user = users.get_current_user() #if login already upload_url = blobstore.create_upload_url('/submit') if user: parent_key = ndb.Key('Persons', users.get_current_user().email()) query = ndb.gql("SELECT * " "FROM Images " "ORDER BY date DESC " ) query2 = ndb.gql("SELECT *" "from Liked_photos " "WHERE ANCESTOR IS :1 " "ORDER BY date DESC", parent_key ) template_values = { 'user_mail' : users.get_current_user().email(), 'user_name' : users.get_current_user().email().split("@")[0], 'logout' : users.create_logout_url(self.request.host_url), 'items' : query, 'upload_url' :upload_url, 'liked_photos' : query2, 'liked_photos_count' : query2.count(), } template = jinja_env.get_template('home.html') self.response.out.write(template.render(template_values)) else : template = jinja_env.get_template('welcome.html') self.response.out.write(template.render())
def get(self): user = users.get_current_user() if user: nickname = user.nickname() login_url = users.create_logout_url('/') login_text = 'Sign out' else: self.redirect("/") return # retrieve request parameters stream_id = self.get_request_param(fh.stream_id_parm) # retrieve the stream from the ID try: stream = (ndb.Key('Stream', int(stream_id))).get() except: self.redirect('/') return if stream is None: self.redirect('/') return active_image = self.get_request_param(fh.active_image_parm) try: active_image = int(active_image) except (TypeError, ValueError): active_image = 0 #Increment view counter stream.viewList.append(datetime.now()) stream.numViews = stream.numViews + 1 stream.put() upload_url = blobstore.create_upload_url('/services/upload') # get the current image range ind1, ind2, status = fh.get_image_range_param(self) if ind1 is None or ind2 is None: ind1 = 1 ind2 = images_per_page # make call to viewimage service viewstream_service_url = fh.get_viewstream_service_url( stream_id, ind1, ind2) result = urllib2.urlopen(viewstream_service_url) response = json.loads("".join(result.readlines())) image_urls = response['urls'] tags = response[fh.tags_parm] tags = [{'name': tag, 'url': fh.get_viewtag_url(tag)} for tag in tags] #Values for GeoMap streamItemsLoc = response['streamItemsLoc'] # get total number of images and make links num_images = response[fh.num_images_parm] # get next 10 images link next_page_url = None if ind2 < num_images: next_page_url = fh.get_viewstream_url(stream_id, ind1 + images_per_page, ind2 + images_per_page) # get previous 10 images link prev_page_url = None if ind1 > 1: prev_page_url = fh.get_viewstream_url(stream_id, ind1 - images_per_page, ind2 - images_per_page) # see if user is subscribed to this stream # make call to subscribed service subscribed_service_url = fh.get_subscribed_service_url( user.user_id(), stream_id) result = urllib2.urlopen(subscribed_service_url) response = json.loads("".join(result.readlines())) is_subscribed = response['status'] redirect_url = urllib2.quote( fh.get_viewstream_url(stream_id, ind1, ind2)) if is_subscribed: sub_url = fh.get_unsubscribe_service_url(user.user_id(), stream_id, redirect_url) else: sub_url = fh.get_subscribe_service_url(user.user_id(), stream_id, redirect_url) item_data = [] items = stream.get_all_items() for i in range(len(items)): item = items[i] prev_ind = i - (i % 10) + 1 stream_url = fh.get_viewstream_url(stream.get_id(), prev_ind, prev_ind + 9, i - prev_ind + 1) if item.getLatLng() is not None: item_data.append({ "lat": item.latitude, "lng": item.longitude, "url": item.URL, "stream_name": stream.name, "stream_url": stream_url, "date_added": str(item.dateAdded) }) template_values = { 'html_template': 'MasterTemplate.html', 'stream': stream, 'stream_id': stream.stream_id(), 'upload_url': upload_url, 'image_urls': image_urls, 'user': user, 'login_url': login_url, 'login_text': login_text, 'is_subscribed': is_subscribed, 'sub_url': sub_url, 'tags': tags, 'tag_name_parm': fh.tag_name_parm, 'tag_url': fh.get_tagmod_url_noparm(), 'redirect_url': self.get_current_url(), 'stream_id_parm': fh.stream_id_parm, 'redirect_parm': fh.redirect_parm, 'url_parm': fh.url_parm, 'item_data': item_data, 'active_image': active_image } if next_page_url: template_values['next_page_url'] = next_page_url if prev_page_url: template_values['prev_page_url'] = prev_page_url path = os.path.join(os.path.dirname(__file__), '../../templates/ViewStream.html') self.response.write(template.render(path, template_values))
def get(self): url = '' my_user = None user = users.get_current_user() msg = "" firstname = "" lastname = "" username = "" file = "" has_error = False collection_key = ndb.Key('BlobCollection', 1) collection = collection_key.get() if collection == None: collection = BlobCollection(id=1) collection.put() try: if 'msg' in self.request.GET: has_error = True msg = self.request.get('msg') firstname = self.request.get('firstname') lastname = self.request.get('lastname') username = self.request.get('username') file = self.request.get('file') except: pass if not user: self.redirect(users.create_login_url(self.request.uri)) return else: url = users.create_logout_url(self.request.uri) my_user_key = ndb.Key('User', user.user_id()) my_user = my_user_key.get() if my_user: if my_user.lastname and my_user.lastname: firstname = str(my_user.firstname).capitalize() lastname = str(my_user.lastname).capitalize() username = str(my_user.username).lower() template_values = { "url": url, "user": user, "msg": msg, "profile_image": getImage(my_user, collection, images), "edit_profile_url": blobstore.create_upload_url('/edit-profile-uploader'), "has_error": has_error, "firstname": firstname, "lastname": lastname, "username": username, "file": file } template = JINJA_ENVIRONMENT.get_template('update_profile.html') self.response.write(template.render(template_values)) return
__author__ = 'hiranya' def serialize(blob_info): if isinstance(blob_info, BlobInfo): return { 'filename' : blob_info.filename, 'size' : blob_info.size } class MainHandler(webapp2.RequestHandler): def get(self): async = self.request.get('async') if async is not None and async == 'true': upload_url_rpc = blobstore.create_upload_url_async('/python/blobstore/upload') upload_url = upload_url_rpc.get_result() else: upload_url = blobstore.create_upload_url('/python/blobstore/upload') self.response.headers['Content-Type'] = "application/json" self.response.out.write(json.dumps({ 'url' : upload_url })) class BlobQueryHandler(webapp2.RequestHandler): def get(self): key = self.request.get('key') fetch_data= self.request.get('data') if fetch_data is not None and fetch_data == 'true': start = self.request.get('start') end = self.request.get('end') async = self.request.get('async') if async is not None and async == 'true': data_rpc = blobstore.fetch_data_async(key, int(start), int(end)) data = data_rpc.get_result()
def get(self): upload_url = blobstore.create_upload_url('/upload') q = PcapData.query().order(-PcapData.create_time).fetch(10) self.render('index.html', upload_url=upload_url, recents=q)
def get(self): upload_url = blobstore.create_upload_url("/testfile/upload") logging.info("Getting upload url: %s.", upload_url) self.response.out.write(upload_url)
def post(self): upload_url = blobstore.create_upload_url(self.getUploadURL()) resp = self.getResponse(upload_url) self.response.out.write(resp)
def getUploadURL(self, key, *args, **kwargs): if not self._checkKey(key, export=False): raise errors.Forbidden() return (blobstore.create_upload_url("/dbtransfer/upload"))
def get(self): # self.response.headers.add_header("Cache-Control", "no-cache, no-store, must-revalidate, max-age=0") # self.response.headers.add_header("Expires","0") self.response.headers[b'Content-Type'] = b'text/plain' self.response.out.write(blobstore.create_upload_url('/upload_photo'))
def getuploadurl(next, maxbytes=None): return blobstore.create_upload_url(next, max_bytes_per_blob=maxbytes)
def form(): upload_path = to_path(upload) bucket = get_default_gcs_bucket_name() url = blobstore.create_upload_url(upload_path, gs_bucket_name=bucket) ctx = {'salvar_path': url} return TemplateResponse(ctx, 'upload_form.html')
def Apply(request, cycle_id): # /apply/[cycle_id] #check that user is registered as an org try: grantee = models.Grantee.objects.get(email=request.user.username) except models.Grantee.DoesNotExist: return redirect('/org/nr') #check cycle exists try: cycle = models.GrantCycle.objects.get(pk=cycle_id) except models.GrantCycle.DoesNotExist: logging.warning('Tried to apply to nonexistent cycle, id ' + str(cycle_id)) return redirect('/org') #replace this with an error msg probably #check whether cycle is open if cycle.is_open() == False: return render_to_response('grants/closed.html', {'cycle': cycle}) #check for app already submitted subd = models.GrantApplication.objects.filter(organization=grantee, grant_cycle=cycle) if subd: return render_to_response('grants/already_applied.html', { 'grantee': grantee, 'cycle': cycle }) #get narrative text overrides if they exist try: texts = models.NarrativeText.objects.get(name="Application") except models.NarrativeText.DoesNotExist: texts = None if request.method == 'POST': form = models.GrantApplicationForm(request.POST, request.FILES) logging.info("Application POST, files:" + str(request.FILES)) #get or create autosave json, update it **UPDATE** dict = simplejson.dumps(request.POST) saved, cr = models.SavedGrantApplication.objects.get_or_create( organization=grantee, grant_cycle=cycle) saved.contents = dict saved.save() mod = saved.modified if form.is_valid(): logging.info("Application form valid") application = form.save() #save as GrantApp object application.file1_type = str(application.file1).split('.')[-1] application.file1_name = str(application.submission_time) + str( application.organization) + '.' + application.file1_type application.file1_name = application.file1_name.replace(' ', '') if application.file2: application.file2_type = str(application.file2).split('.')[-1] application.file2_name = str( application.submission_time.year) + str( application.organization ) + '2.' + application.file2_type application.file2_name = application.file2_name.replace( ' ', '') if application.file3: application.file3_type = str(application.file3).split('.')[-1] application.file3_name = str( application.submission_time.year) + str( application.organization ) + '3.' + application.file3_type application.file3_name = application.file3_name.replace( ' ', '') if application.fiscal_letter: application.fiscal_letter_type = str( application.fiscal_letter).split('.')[-1] application.fiscal_letter_name = str( application.submission_time.year) + str( application.organization ) + 'FiscalLetter.' + application.fiscal_letter_type application.fiscal_letter_name = application.fiscal_letter_name.replace( ' ', '') application.save() logging.info("Application form saved, file1: " + str(application.file1)) #update org profile form2 = models.OrgProfile(request.POST, instance=grantee) if form2.is_valid(): form2.save() logging.info('Organization profile updated') else: logging.error( 'Application error: profile not updated. User: %s, application id: %s', request.user.email, application.pk) #email confirmation subject, from_email = 'Grant application submitted', settings.APP_SEND_EMAIL to = grantee.email html_content = render_to_string('grants/email_submitted.html', { 'org': grantee, 'cycle': cycle }) text_content = strip_tags(html_content) msg = EmailMultiAlternatives(subject, text_content, from_email, [to], ['*****@*****.**']) msg.attach_alternative(html_content, "text/html") msg.send() logging.info("Application created; confirmation email sent to " + to) #delete json obj saved.delete() return redirect('/org/submitted.html') else: logging.info("Application form invalid: " + str(form.errors)) else: #GET try: saved = models.SavedGrantApplication.objects.get( organization=grantee, grant_cycle=cycle) dict = simplejson.loads(saved.contents) mod = saved.modified except models.SavedGrantApplication.DoesNotExist: dict = model_to_dict( grantee) #simplejson.loads(grantee.profile_json) mod = '' dict['organization'] = grantee dict['grant_cycle'] = cycle form = models.GrantApplicationForm(initial=dict) #file upload prep view_url = reverse('grants.views.Apply', args=(cycle_id, )) #current url #upload_url, blah = prepare_upload(request, view_url) upload_url = blobstore.create_upload_url('/apply/' + cycle_id + '/') logging.info('Upload prepped, url: ' + upload_url) return render_to_response( 'grants/org_app.html', { 'grantee': grantee, 'form': form, 'cycle': cycle, 'upload_url': upload_url, 'texts': texts, 'saved': mod, 'cycleid': cycle_id })
def get_upload_url(auth_user): from google.appengine.ext import blobstore upload_url = blobstore.create_upload_url( URL('return_upload', vars=dict(user_id=auth_user.id))) return dict(upload_url=upload_url)
def get(self): upload_url = blobstore.create_upload_url('/upload') self.response.out.write(upload_url)
def post(self, model, property_name=None): """POST endpoint - adds a new model instance""" if model and not property_name: # Invalid usage of the endpoint raise RESTException('Cannot POST to a specific model ID') if model and property_name: # POST to a BlobKeyProperty if not hasattr(model, property_name): raise RESTException('Invalid property name "%s"' % property_name) if not isinstance(model._properties[property_name], ndb.BlobKeyProperty): raise RESTException('"%s" is not a BlobKeyProperty' % property_name) # Next, get the created blob upload_files = self.get_uploads() if not upload_files: # No upload data - this happens when the user POSTS for the first time - we need to create an upload URL and redirect # the user to it (the BlobstoreUploadHandler will handle self.get_uploads() for us and we'll get to the same point). # We do it this way and not simply refer the user directly to create_upload_url, so we won't call create_upload_url # every time the user GETs to /my_model - since each create_upload_url call creates more DB garbage. upload_url = blobstore.create_upload_url(self.request.url) return self.redirect( upload_url, code=307 ) # We use a 307 redirect in order to tell the client (e.g. browser) to use the same method type (POST) and keep its POST data blob_info = upload_files[0] if getattr(model, property_name): # The property already has a previous value - delete the older blob blobstore.delete(getattr(model, property_name)) # Set the blob reference setattr(model, property_name, blob_info.key()) model.put() # Everything was OK return {'status': True} try: # Parse POST data as JSON json_data = json.loads(self.request.body) except ValueError as exc: raise RESTException('Invalid JSON POST data') if not isinstance(json_data, list): json_data = [json_data] models = [] for model_to_create in json_data: try: # Any exceptions raised due to invalid/missing input will be caught model = self._build_model_from_data( model_to_create, self.model) models.append(model) except Exception as exc: raise RESTException('Invalid JSON POST data - %s' % exc) if self.before_post_callback: models = self.before_post_callback(models, json_data) # Commit all models in a transaction created_keys = ndb.put_multi(models) if self.after_post_callback: models = self.after_post_callback(created_keys, models) # Return the newly-created model instance(s) return models
def get(self): self.render_response('index.html', upload_url=blobstore.create_upload_url('/upload'))
def get(self): url = blobstore.create_upload_url(CALLBACK_URL, gs_bucket_name=BUCKET_NAME + '/files') self.response.write(url)
def get(self): upload_url = blobstore.create_upload_url('/photo') logging.info("Upload URL is: %s" % upload_url) self.response.out.write(upload_url)
def get(self): self.response.headers['Content-Type'] = 'text/html' collection_key = [] collection = [] Caption = [] experience = [] hotel = [] flight = [] visa = [] from_location = [] to_location = [] length = 0 upload_url = blobstore.create_upload_url('/Timeline') userfollower = 0 userfollowing = 0 timeline_Post_Image_Key = [] userlogin = self.request.get('email_address') Name = self.request.get('user_name') #For LogIn Email = self.request.get('email_address') if (Email == ""): self.redirect('/') Button = self.request.get('Button') if (Button == "Login"): Password = self.request.get('Password') Check_login = ndb.Key('userData', Email).get() if Check_login != None: if (Check_login.user_password == Password): self.redirect('/Timeline?email_address=' + Email) else: self.redirect('/MainPage') # For logout Button button = "" button = self.request.get('button') if (button == "Logout"): self.redirect('/') if (Email == ""): self.redirect("/MainPage") else: Check_login = ndb.Key('userData', Email).get() if (Check_login != None): #For displaying images collection_key = ndb.Key('timelinepost', Email).get() if collection_key != None: k = len(collection_key.caption) - 1 while k > -1: collection.append(collection_key.photo_url[k]) Caption.append(collection_key.caption[k]) experience.append(collection_key.experience[k]) hotel.append(collection_key.hotel[k]) flight.append(collection_key.flight[k]) visa.append(collection_key.visa[k]) from_location.append(collection_key.from_location[k]) to_location.append(collection_key.to_location[k]) k = k - 1 length = len(collection) # for follower and Following collect = ndb.Key('followerfollowing', Email).get() if collect != None: userfollower = len(collect.follower) userfollowing = len(collect.following) else: self.redirect("/MainPage") template_values = { 'userlogin': userlogin, 'upload_url': upload_url, 'email_address': Email, 'collection': collection, 'Caption': Caption, 'experience': experience, 'hotel': hotel, 'flight': flight, 'visa': visa, 'from_location': from_location, 'to_location': to_location, 'k': length, 'userfollower': userfollower, 'userfollowing': userfollowing, 'timeline_Post_Image_Key': timeline_Post_Image_Key, } template = JINJA_ENVIRONMENT.get_template('Timeline.html') self.response.write(template.render(template_values))
def get(self): JINJA_ENVIRONMENT = jinja2.Environment(loader=jinja2.FileSystemLoader(os.path.dirname(__file__)), extensions=['jinja2.ext.autoescape'], autoescape=True) template = JINJA_ENVIRONMENT.get_template('AddImage.html') cur_url = self.request.url parsed_url = urlparse.urlparse(cur_url) page_name = "" try: pn = urlparse.parse_qs(parsed_url.query)['PageName'] page_name = int(pn[0]) except Exception: pn = "" bi = urlparse.parse_qs(parsed_url.query)['blogId'] cal = urlparse.parse_qs(parsed_url.query)['caller'] blogId = bi[0] caller = cal[0] login = 0 login_url = "" username = "" # if sessionId != 0: # login = 1 # user = UserLoggedIn.get_by_id(int(session[0])) # username = user.blogger.nickname() # else: # login = 0 # login_url = users.create_login_url('/') # logout_url = users.create_logout_url('/') user = users.get_current_user() if user: login = 1 username = user.nickname() else: login = 0 login_url = users.create_login_url(cur_url) logout_url = users.create_logout_url('/') upload_url = blobstore.create_upload_url('/AddImageToStore.py') query = "SELECT * from Images WHERE owner='"+username+"'" image_list = db.GqlQuery(query) # self.response.write(cur_url) # image_urls.append(i_url) # self.response.write(i_url) template_values = {'login' : login, 'login_url' : login_url, 'logout_url' : logout_url, 'username' : username, 'parentPageId' : page_name, 'image_list' : image_list, 'upload_url' : upload_url, 'blogId' : blogId, 'cur_url': cur_url, 'caller' : caller } self.response.write(template.render(template_values))
def _create_upload_url(self): # Creating the upload URL can't be atomic, otherwise the session # key will not be consistent when uploading the file with transaction.non_atomic(): return create_upload_url( reverse('djangae_internal_upload_handler'))
def get(self): self.response.headers["Content-Type"] = "text/html" user = Definitions().get_current_user() myuser = None tweets = None edit_tweet = None if user: url = users.create_logout_url(self.request.uri) myuser_key = ndb.Key("MyUser", Definitions().get_current_user_id()) myuser = myuser_key.get() user_name = self.request.GET.get("user_name") bio = self.request.GET.get("bio") if myuser == None: myuser = Definitions().create_user(user_id=user.user_id(), email_address=user.email()) if user_name != None and user_name != "" and bio != None and bio != "": user_query = MyUser.query( MyUser.user_name == user_name).fetch() if len(user_query) > 0: self.redirect("/") return myuser.user_name = user_name myuser.bio = bio myuser.put() tweets = Tweet.query().order(-Tweet.time) search = self.request.GET.get("query") if search == "user" or search == "post": search_text = self.request.GET.get("search_text") if len(search_text) > 0: if search == "user": tweets = Definitions().search_by_user(text=search_text) else: tweets = Definitions().search_by_tweet( text=search_text) elif search == "Delete" or search == "Edit": query = self.request.GET.get("query") tweet_id = self.request.GET.get("tweet_id") if query == "Edit": edit_tweet = Definitions().get_tweet(tweet_id=tweet_id) else: Definitions().delete_tweet(tweet_id=tweet_id) else: tweets = [] for tweet in Tweet.query().order(-Tweet.time).fetch(): if tweet.user_id in myuser.following or tweet.user_id == myuser.key.id( ): tweets.append(tweet) else: url = users.create_login_url(self.request.uri) template_values = { "url": url, "myuser": myuser, "edit_tweet": edit_tweet, "tweets": tweets, "upload_url": blobstore.create_upload_url('/upload_photo') } template = JINJA_ENVIRONMENT.get_template("main.html") self.response.write(template.render(template_values))
def get_url(user_id): upload_url = blobstore.create_upload_url(UPLOAD_IMAGE_URL) return upload_url
def post(self, uuid): futures = [] # Create an User for the primary_user on any preflight if one doesn't # already exist. primary_user = self.parsed_json.get(_PREFLIGHT.PRIMARY_USER) user = user_models.User.GetOrInsert( user_utils.UsernameToEmail(primary_user)) # Ensures the returned username is consistent with the User entity. primary_user = user.nickname # Create a SantaHost on the first preflight. first_preflight = not self.host if first_preflight: logging.info('Host %s is syncing for the first time', uuid) self.host = host_models.SantaHost(key=self.host_key) self.host.client_mode = settings.SANTA_DEFAULT_CLIENT_MODE futures.append(_CopyLocalRules(user.key, uuid)) # Update host entity on every sync. self.host.serial_num = self.parsed_json.get(_PREFLIGHT.SERIAL_NUM) self.host.hostname = self.parsed_json.get(_PREFLIGHT.HOSTNAME) self.host.primary_user = primary_user self.host.santa_version = self.parsed_json.get( _PREFLIGHT.SANTA_VERSION) self.host.os_version = self.parsed_json.get(_PREFLIGHT.OS_VERSION) self.host.os_build = self.parsed_json.get(_PREFLIGHT.OS_BUILD) self.host.last_preflight_dt = datetime.datetime.utcnow() self.host.last_preflight_ip = self.request.remote_addr reported_mode = self.parsed_json.get(_PREFLIGHT.CLIENT_MODE) if reported_mode != self.host.client_mode: message = 'Client mode mismatch (Expected: %s, Actual: %s)' % ( self.host.client_mode, reported_mode) logging.info(message) # If the client_mode doesn't correspond to a known value, report it as # UNKNOWN. if reported_mode not in constants.HOST_MODE.SET_ALL: reported_mode = constants.HOST_MODE.UNKNOWN tables.HOST.InsertRow( device_id=uuid, timestamp=datetime.datetime.utcnow(), action=constants.HOST_ACTION.COMMENT, hostname=self.host.hostname, platform=constants.PLATFORM.MACOS, users=model_utils.GetUsersAssociatedWithSantaHost(uuid), mode=reported_mode, comment=message) if self.parsed_json.get(_PREFLIGHT.REQUEST_CLEAN_SYNC): logging.info('Client requested clean sync') self.host.rule_sync_dt = None # Save host entity. futures.append(self.host.put_async()) # If the big red button is pressed, override the self.host.client_mode # set in datastore with either MONITOR or LOCKDOWN for this response only. actual_client_mode = self.host.client_mode big_red_button = big_red.BigRedButton() if big_red_button.stop_stop_stop: actual_client_mode = constants.SANTA_CLIENT_MODE.MONITOR elif big_red_button.go_go_go: actual_client_mode = constants.SANTA_CLIENT_MODE.LOCKDOWN # Prepare response. response = { _PREFLIGHT.BATCH_SIZE: (settings.SANTA_EVENT_BATCH_SIZE), _PREFLIGHT.CLIENT_MODE: actual_client_mode, _PREFLIGHT.WHITELIST_REGEX: (self.host.directory_whitelist_regex if self.host.directory_whitelist_regex is not None else settings.SANTA_DIRECTORY_WHITELIST_REGEX), _PREFLIGHT.BLACKLIST_REGEX: (self.host.directory_blacklist_regex if self.host.directory_blacklist_regex is not None else settings.SANTA_DIRECTORY_BLACKLIST_REGEX), _PREFLIGHT.CLEAN_SYNC: not self.host.rule_sync_dt, _PREFLIGHT.BUNDLES_ENABLED: (settings.SANTA_BUNDLES_ENABLED), _PREFLIGHT.TRANSITIVE_WHITELISTING_ENABLED: (self.host.transitive_whitelisting_enabled), } if self.host.should_upload_logs: response[_PREFLIGHT.UPLOAD_LOGS_URL] = ( blobstore.create_upload_url('/api/santa/logupload/%s' % uuid)) # Verify all futures resolved successfully. for future in futures: future.check_success() # If this is the first preflight, create a FIRST_SEEN HostRow. This has to # occur after the new SantaHost entity is put(), since SantaHost.recorded_dt # is an auto_now_add. if first_preflight: new_host = ndb.Key('Host', uuid).get() tables.HOST.InsertRow( device_id=uuid, timestamp=new_host.recorded_dt, action=constants.HOST_ACTION.FIRST_SEEN, hostname=new_host.hostname, platform=constants.PLATFORM.MACOS, users=model_utils.GetUsersAssociatedWithSantaHost(uuid), mode=new_host.client_mode) self.respond_json(response)
def prepare_upload(request, url, **kwargs): return create_upload_url(url), {}
def request_blob_url(self, callback_url, max_bytes): upload_url = blobstore.create_upload_url(callback_url, max_bytes) return upload_url
def dashboard(request): imported_clubs_count = Club.objects.filter( original_domain_name='leagueathletics').count() if not imported_clubs_count: imported_clubs_count = 0 upload_url = blobstore.create_upload_url('/spudderadmin/leagueathletics') error_message = None la_import = LeagueAthleticsImport.load() import_form = LeagueAthleticsImportClubsForm( initial={'action': LeagueAthleticsFormAction.IMPORT_CLUBS}) reset_form = LeagueAthleticsResetClubsForm( initial={'action': LeagueAthleticsFormAction.RESET_CLUBS}) if request.method == "POST": action = request.POST.get('action') if action == LeagueAthleticsFormAction.IMPORT_CLUBS: import_form = LeagueAthleticsImportClubsForm(request.POST) if import_form.is_valid(): upload_form = UploadForm(request.POST, request.FILES) uploaded_file = upload_form.save(False) uploaded_file.owner = request.user uploaded_file.content_type = request.FILES['file'].content_type uploaded_file.filename = request.FILES['file'].name uploaded_file.save() la_import.clear() la_import.in_progress = True la_import.zip_codes_file = uploaded_file la_import.save() trigger_backend_task( '/spudderadmin/leagueathletics/import_clubs', eta=datetime.datetime.now() + datetime.timedelta(seconds=30)) messages.success( request, "<i class='fa fa-check'></i> Clubs import in progress") return redirect('/spudderadmin/leagueathletics') if action == LeagueAthleticsFormAction.RESET_CLUBS: reset_form = LeagueAthleticsResetClubsForm(request.POST) if reset_form.is_valid(): Club.objects.filter( original_domain_name='leagueathletics').delete() messages.success( request, "<i class='fa fa-check'></i> All imported clubs have been deleted" ) return redirect('/spudderadmin/leagueathletics') return render( request, 'spudderadmin/pages/leagueathletics/dashboard.html', { 'imported_clubs_count': imported_clubs_count, 'upload_url': upload_url, 'error_message': error_message, 'la_import': la_import, 'reset_form': reset_form, 'import_form': import_form })
def _finish_upload(self, image_data, filename, content_type): image = images.Image(image_data=image_data) image.im_feeling_lucky() try: image.execute_transforms(parse_source_metadata=True, output_encoding=images.JPEG, quality=1) except images.BadRequestError as e: self._bad_request('Image probably too large') return except (images.BadImageError, images.NotImageError) as e: self._bad_request('Not an image') return image_metadata = image.get_original_metadata() image_width = image.width image_height = image.height image_format = None if image.format == images.JPEG: image_format = 'jpeg' elif image.format == images.PNG: image_format = 'png' elif image.format == images.WEBP: image_format = 'webp' elif image.format == images.GIF: image_format = 'gif' else: self._bad_request('Unsupported image format') return if self.app.debug: # # App Engine's local environment, powered by PIL, does not # automatically rotate served images like production does. # So, make it seem like it does. # orientation = image_metadata.get('Orientation', 1) degrees = 0; if (orientation == 3): degrees = 180 elif (orientation == 6): degrees = 90 elif (orientation == 8): degrees = -90 if degrees: logging.info('Applying DEBUG-only image rotation.') image.rotate(degrees) image_data = image.execute_transforms() # This .replace() stuff here is a crazy hack. App Engine apparently has a hard time # parsing LONG blocks of uninterrupted multipart form data, so instead of actually # fixing the bug, we just add some newlines into the JSON blob so hopefully no # single line goes too far over the line. This is a terrible hack, I know. # # Also, this bug only manifests itself in production. image_metadata_json = json.dumps(image_metadata).replace('":', '":\n').replace('",', '",\n') headers, payload = util.encode_multipart_formdata({ 'image_metadata_json': image_metadata_json, 'image_width': '%d' % image_width, 'image_height': '%d' % image_height, 'image_format': image_format, }, { PUBLIC_UPLOAD_FIELD_NAME: (filename, content_type, image_data,), }) if 'Content-Length' in headers: del headers['Content-Length'] headers['Referer'] = self.request.headers.get('Referer') blobstore_upload_url = blobstore.create_upload_url(PUBLIC_BLOBSTORE_UPLOAD_HANDLER_PATH) if self.app.debug: scheme, netloc, path, params, query, fragment = urlparse.urlparse(blobstore_upload_url) host, port = netloc.split(':') #host = self.request.headers.get('host', 'localhost').split(':')[0] host='192.168.0.100' netloc = '%s:%s' % (host, port) blobstore_upload_url = urlparse.urlunparse([scheme, netloc, path, params, query, fragment]) post_rpc = urlfetch.create_rpc(deadline=15) urlfetch.make_fetch_call(post_rpc, blobstore_upload_url, method='POST', payload=payload, headers=headers) try: json_result = post_rpc.get_result() except apiproxy_errors.RequestTooLargeError: self._bad_request('The image is too large', code=HTTP_CODE_TOO_LARGE) return except urlfetch.DownloadError: self._error('Error saving image to blobstore') return if json_result.status_code >= 500: self._error('Invalid response code from blobstore upload') return if json_result.status_code >= 400: self._bad_request('Invalid image data') return self.response.headers['Content-Type'] = json_result.headers['Content-Type'] self.response.write(json_result.content)
def edit_image(key): category = Category.get(key) upload_url = blobstore.create_upload_url('/saveimage/'+key) items = Item.all().ancestor(category) return render_template('edit_images.html',items=items,key=key,title=category.title,owner=category.owner.email(),upload_url=upload_url)
def __init__(self, request, response): self.initialize(request, response) self.template_values = {} self.template_values['edit_url']=blobstore.create_upload_url('/edit/channel')
def _create_upload_url(self): return create_upload_url(reverse('djangae_internal_upload_handler'), gs_bucket_name=self.bucket_name)