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)
