def site_edit(request):
form = SettingForm()
if request.method == "POST" and (request.form.has_key("delete") and request.form["delete"] == "on"):
if request.form["edit"]:
site = Sites.get(request.form["site"])
if site.user != request.user:
redirect(url_for("admin/settings")) # FIXME error
site.delete()
return redirect(url_for("admin/settings"))
if request.method == "POST" and form.validate(request.form):
if form.data["edit"]:
site = Sites.get(form.data["site"])
if site.user != request.user:
redirect(url_for("admin/settings")) # FIXME error
else:
site = Sites(activate_code=_activate_code(), user=request.user)
site.url = db.Link(form["url"])
site.put()
return redirect(url_for("admin/settings"))
if request.method == "GET":
if request.args.has_key("site") and request.args["site"]:
site = Sites.get(request.args["site"])
if site.user == request.user:
form.data["url"] = site.url
form.data["edit"] = "1"
form.data["site"] = request.args["site"]
form.data["activate_code"] = site.activate_code
form.delete.widget.value = u"False"
return render_to_response("admin/site_edit.html", {"form": form.as_widget()})
def test_login(self):
response = self.client.get(url_for('gaema_testapp/index'))
self.assertEqual(response.status_code, 200)
response = self.client.get(url_for('gaema_testapp/secret',
domain_name='shehas.net'))
self.assertEqual(response.status_code, 302)
self.assert_(response.headers.get('Location').endswith(
'/_ah/gaema/marketplace_login/a/shehas.net'))
self.client.test_login(service='shehas.net',
user_data={'claimed_id': 'http://shehas.net/123',
'email': '*****@*****.**'})
response = self.client.get(url_for('gaema_testapp/secret',
domain_name='shehas.net'))
self.assertEqual(response.status_code, 200)
response = self.client.get(url_for('gaema_testapp/secret',
domain_name='example.com'))
self.assertEqual(response.status_code, 302)
self.assert_(response.headers.get('Location').endswith(
'/_ah/gaema/marketplace_login/a/example.com'))
self.client.test_logout(service='shehas.net')
response = self.client.get(url_for('gaema_testapp/secret',
domain_name='shehas.net'))
self.assertEqual(response.status_code, 302)
def test_login(self):
response = self.client.get(url_for('gaema_testapp/index'))
self.assertEqual(response.status_code, 200)
response = self.client.get(
url_for('gaema_testapp/secret', domain_name='shehas.net'))
self.assertEqual(response.status_code, 302)
self.assert_(
response.headers.get('Location').endswith(
'/_ah/gaema/marketplace_login/a/shehas.net'))
self.client.test_login(service='shehas.net',
user_data={
'claimed_id': 'http://shehas.net/123',
'email': '*****@*****.**'
})
response = self.client.get(
url_for('gaema_testapp/secret', domain_name='shehas.net'))
self.assertEqual(response.status_code, 200)
response = self.client.get(
url_for('gaema_testapp/secret', domain_name='example.com'))
self.assertEqual(response.status_code, 302)
self.assert_(
response.headers.get('Location').endswith(
'/_ah/gaema/marketplace_login/a/example.com'))
self.client.test_logout(service='shehas.net')
response = self.client.get(
url_for('gaema_testapp/secret', domain_name='shehas.net'))
self.assertEqual(response.status_code, 302)
def site_edit(request):
form = SettingForm()
if request.method == "POST" and (request.form.has_key('delete')
and request.form['delete'] == 'on'):
if request.form['edit']:
site = Sites.get(request.form['site'])
if site.user != request.user:
redirect(url_for('admin/settings')) #FIXME error
site.delete()
return redirect(url_for('admin/settings'))
if request.method == "POST" and form.validate(request.form):
if form.data['edit']:
site = Sites.get(form.data['site'])
if site.user != request.user:
redirect(url_for('admin/settings')) #FIXME error
else:
site = Sites(activate_code=_activate_code(), user=request.user)
site.url = db.Link(form['url'])
site.put()
return redirect(url_for('admin/settings'))
if request.method == "GET":
if request.args.has_key('site') and request.args['site']:
site = Sites.get(request.args['site'])
if site.user == request.user:
form.data['url'] = site.url
form.data['edit'] = '1'
form.data['site'] = request.args['site']
form.data['activate_code'] = site.activate_code
form.delete.widget.value = u'False'
return render_to_response('admin/site_edit.html',
{'form': form.as_widget()})
def r_info_edit(request, uid):
r_info = RetailInfo.get_by_id(uid)
if not r_info:
return redirect(url_for('page/admins/r_info/index'))
form = NewsForm(initial={
'title':r_info.title,
'is_display':r_info.is_display,
'short_text':r_info.short_text,
'text':r_info.text
})
if request.method == 'POST':
if form.validate(request.form):
r_info.title = form['title']
r_info.is_display = form['is_display']
r_info.short_text = form['short_text']
r_info.text = form['text']
r_info.put()
return redirect(url_for('page/admins/r_info/index'))
else:
return render_to_response(
'page/admins/r_info/edit.html', {
'form': form.as_widget(),
'r_info': r_info
})
return render_to_response(
'page/admins/r_info/edit.html', {
'form': form.as_widget(),
'r_info': r_info
})
def admin_edit(request, uid):
news = News.get_by_id(uid)
if not news:
return redirect(url_for('news/admin'))
form = NewsForm(initial={
'title':news.title,
'is_display':news.is_display,
'short_text':news.short_text,
'text':news.text
})
if request.method == 'POST':
if form.validate(request.form):
news.title = form['title']
news.is_display = form['is_display']
news.short_text = form['short_text']
news.text = form['text']
news.put()
return redirect(url_for('news/admin'))
else:
return render_to_response(
'news/admin/edit.html', {
'form': form.as_widget(),
'news': news
})
return render_to_response(
'news/admin/edit.html', {
'form': form.as_widget(),
'news': news
})
def txn():
key_name = cls.get_key_name(user_name)
user = cls.get_by_key_name(key_name)
if user:
from kay.auth import DuplicateKeyError
raise DuplicateKeyError(_(u"This user name is already taken."
" Please choose another user name."))
salt = crypto.gen_salt()
activation_key = crypto.sha1(salt+user_name).hexdigest()
profile_key = db.Key.from_path(cls.kind(), key_name,
RegistrationProfile.kind(),
activation_key)
expiration_date = datetime.datetime.now() + \
datetime.timedelta(seconds=settings.ACCOUNT_ACTIVATION_DURATION)
taskqueue.add(url=url_for('_internal/expire_registration',
registration_key=str(profile_key)),
eta=expiration_date, transactional=True)
taskqueue.add(url=url_for('_internal/send_registration_confirm',
registration_key=str(profile_key)),
transactional=True)
user = cls(key_name=key_name, activated=False, user_name=user_name,
password=crypto.gen_pwhash(password), email=email)
profile = RegistrationProfile(user=user, parent=user,
key_name=activation_key)
db.put([profile, user])
return user
def txn():
key_name = cls.get_key_name(user_name)
user = cls.get_by_key_name(key_name)
if user:
from kay.auth import DuplicateKeyError
raise DuplicateKeyError(
_(u"This user name is already taken."
" Please choose another user name."))
salt = crypto.gen_salt()
activation_key = crypto.sha1(salt + user_name).hexdigest()
profile_key = db.Key.from_path(cls.kind(), key_name,
RegistrationProfile.kind(),
activation_key)
expiration_date = datetime.datetime.now() + \
datetime.timedelta(seconds=settings.ACCOUNT_ACTIVATION_DURATION)
taskqueue.add(url=url_for('_internal/expire_registration',
registration_key=str(profile_key)),
eta=expiration_date,
transactional=True)
taskqueue.add(url=url_for('_internal/send_registration_confirm',
registration_key=str(profile_key)),
transactional=True)
user = cls(key_name=key_name,
activated=False,
user_name=user_name,
password=crypto.gen_pwhash(password),
email=email)
profile = RegistrationProfile(user=user,
parent=user,
key_name=activation_key)
db.put([profile, user])
return user
def create_search_document(key):
entity = db.get(key)
timestamp = int(time.mktime((entity.update).timetuple()))
title = entity.title
content = entity.content
lang = entity.lang
display_page_flg = str(entity.display_page_flg)
model_name = entity.kind()
try:
parent = str(entity.parent().key())
except:
parent = ''
url = entity.external_url
if url is None or url == '':
try:
key_name = entity.parent().key().name()
except:
key_name = entity.key().name()
if model_name == 'AdminPage':
url = url_for('mainapp/show_each_page',key_name=key_name)
else:
url = url_for('mainapp/show_each_article',key_name=key_name)
return search.Document(doc_id=entity.kind()+'_'+entity.key().name(),
fields=[search.TextField(name='title', value=title, language=lang),
search.TextField(name='content', value=content, language=lang),
search.TextField(name='key', value=str(key), language='en'),
search.TextField(name='model_name', value=model_name, language=lang),
search.TextField(name='display_page_flg', value=display_page_flg, language='en'),
search.TextField(name='lang', value=lang, language=lang),
search.TextField(name='images', value=entity.images, language=lang),
search.TextField(name='url', value=url, language='en'),
search.TextField(name='parent', value=parent, language='en'),
search.NumberField(name='timestamp', value=timestamp)])
def facebook_authorize(request):
local_redirect = request.values.get("redirect_url", None)
if not local_redirect:
return BadRequest()
request.session["local_redirect"] = local_redirect
facebook = Facebook(
settings.FACEBOOK_APP_ID,
settings.FACEBOOK_APP_SECRET,
url_for("backup_bridge/facebook_oauth_callback", _external=True),
)
print url_for("backup_bridge/facebook_oauth_callback", _external=True)
scope = [
"offline_access",
"user_events",
"friends_events",
"user_notes",
"friends_notes",
"user_photos",
"friends_photos",
"user_status",
"friends_status",
"user_photo_video_tags",
"friends_photo_video_tags",
"user_groups",
"friends_groups",
"user_videos",
"friends_videos",
"user_about_me",
"friends_about_me",
"user_activities",
"friends_activities",
"user_birthday",
"friends_birthday",
"user_education_history",
"friends_education_history",
"user_groups",
"friends_groups",
"user_hometown",
"friends_hometown",
"user_interests",
"friends_interests",
"user_likes",
"friends_likes",
"user_location",
"friends_location",
"user_relationships",
"friends_relationships",
"user_relationship_details",
"friends_relationship_details",
"user_website",
"friends_website",
"user_work_history",
"friends_work_history",
"user_checkins",
"friends_checkins",
]
scope = ",".join(scope)
url = facebook.get_authorization_url(scope)
return redirect(url)
def generate_schedules(request):
if request.method == 'POST':
# task queueに追加
params = {}
taskqueue.add(url=url_for('index/task_generate_schedules'), params=params)
return redirect(url_for('index/index'))
def url(self, save_as=False, save_name=''):
if not save_name:
save_name = self.get_name
if not save_name:
save_name = 'untitled'
if save_as:
return url_for('file/save_as', f_key=self.id, f_name=save_name)
return url_for('file/view', f_key=self.id, f_name=save_name)
def add(request):
if request.method == 'POST':
upload_files = get_uploads(request, 'file')
blob_info = upload_files[0]
im = Image.create(blob_info.key())
headers = {'Location': url_for('image/admin/upload', img_key=im.key())}
else:
headers = {'Location': url_for('image/admin/upload')}
return Response(None, headers=headers, status=302)
def generate_users(request):
if request.method == 'POST':
# 量
quantity = request.values.get('quantity', 100)
# task queueに追加
params = {'quantity': quantity}
taskqueue.add(url=url_for('index/task_generate_users'), params=params)
return redirect(url_for('index/index'))
def search_post(request):
form=SearchForm(action=url_for('core/search_post'))
words=None
if request.method=='POST' and form.validate(request.form):
words=form['words'].strip()
words=words.replace('/',' ')
if words is None:
return redirect(url_for('core/index'))
else:
return redirect(url_for('core/search',words=words,list_per_page=24,page_index=0))
def test_login(self):
response = self.client.get(url_for('auth_testapp/index'))
self.assertEqual(response.status_code, 200)
response = self.client.get(url_for('auth_testapp/secret'))
self.assertEqual(response.status_code, 302)
self.client.test_login(email="*****@*****.**", is_admin="1")
response = self.client.get(url_for('auth_testapp/secret'))
self.assertEqual(response.status_code, 200)
self.client.test_logout()
response = self.client.get(url_for('auth_testapp/secret'))
self.assertEqual(response.status_code, 302)
def summary_daily_schedules(request):
if request.method == 'POST':
# 対象日付取得
date = request.values.get('date')
if not date:
raise BadRequest
name = 'summary_daily_schedules'
params = {'date':date, 'name':name}
taskqueue.add(url=url_for('index/task_summary_daily_schedules'), params=params)
return redirect(url_for('index/index'))
def test_login(self):
response = self.client.get(url_for('auth_testapp/index'))
self.assertEqual(response.status_code, 200)
response = self.client.get(url_for('auth_testapp/secret'))
self.assertEqual(response.status_code, 302)
self.client.test_login(email="*****@*****.**", is_admin="1")
response = self.client.get(url_for('auth_testapp/secret'))
self.assertEqual(response.status_code, 200)
self.client.test_logout()
response = self.client.get(url_for('auth_testapp/secret'))
self.assertEqual(response.status_code, 302)
def price_uplader(request):
upload_files = get_uploads(request, 'file')
if not len(upload_files):
return redirect(url_for('admin/add_price'))
blob_info = upload_files[0]
bl = BlobInfo.get(blob_info.key())
filename = os.path.basename(bl.filename.replace('\\','/'))
price = Price(name=filename,
file_key=str(blob_info.key()), length=blob_info.size)
price.put()
return redirect(url_for('admin/prices'))
def post(self):
if self.form.validate(self.request.form):
try:
self.form.save()
cache_set(self.request.user, 'gfcu', self.request.user.key().name())
self.request.notifications.success('Zmiany zapisane!')
return redirect(url_for('gfcaccount/index'))
except Exception, e:
logging.exception('Account edit save failed: ' + str(e))
self.request.notifications.error('Zmian nie zapisano! Błąd zapisu, spróbuj później...')
return redirect(url_for('gfcaccount/index'))
def send_newsletter2(request, key_id):
letter = Newsletter2.get_by_id(key_id)
if not letter:
return redirect(url_for("postman/admin/newsletters2"))
for email in set(letter.emails):
def txn():
taskqueue.add(
url=url_for("postman/send_newsletter_task2", email=email, newsletter_key_id=key_id), transactional=True
)
db.run_in_transaction(txn)
return redirect(url_for("postman/admin/newsletters2"))
def test_cache_middleware(self):
# make sure that CACHE_MIDDLEWARE_ANONYMOUSE_ONLY works
self.client.test_login(email='*****@*****.**')
response = self.client.get(url_for('cache_testapp/index'))
self.assertEqual(response.status_code, 200)
c = memcache.get('http://localhost/?lang=en', namespace='CACHE_MIDDLEWARE')
self.assertEqual(c, None)
self.client.test_logout()
# user logout, so the cache works
response = self.client.get(url_for('cache_testapp/index'))
self.assertEqual(response.status_code, 200)
c = memcache.get('http://localhost/?lang=en', namespace='CACHE_MIDDLEWARE')
self.assertEqual(c.data, response.data)
def test_login(self):
response = self.client.get(url_for('auth_testapp/index'))
self.assertEqual(response.status_code, 200)
response = self.client.get(url_for('auth_testapp/secret'))
self.assertEqual(response.status_code, 302)
self.assert_(response.headers.get('Location').endswith(
'/auth/login?next=http%253A%252F%252Flocalhost%252Fsecret'))
self.client.test_login(username='******')
response = self.client.get(url_for('auth_testapp/secret'))
self.assertEqual(response.status_code, 200)
self.client.test_logout()
response = self.client.get(url_for('auth_testapp/secret'))
self.assertEqual(response.status_code, 302)
def set_properties(request, key):
product_ = Product.get_by_id(key)
if not product_:
return redirect(url_for('shop/admin/product'))
if request.method == 'POST':
selected_values = request.form.getlist('values')
product_.properties_ = []
for value in selected_values:
val_obj = ProductPropertyValue.get_by_id(value)
if val_obj:
product_.properties_.append(val_obj.key())
product_.put()
return redirect(url_for('shop/admin/product/edit', key=key))
def test_cache_decorator_with_class_view(self):
# make sure that CACHE_MIDDLEWARE_ANONYMOUSE_ONLY works
self.client.test_login(email='*****@*****.**')
response = self.client.get(url_for('cache_testapp/decorator_class'))
self.assertEqual(response.status_code, 200)
c = memcache.get('http://localhost/decorator_class?lang=en',
namespace='CACHE_DECORATOR')
self.assertEqual(c, None)
self.client.test_logout()
# user logout, so the cache works
response = self.client.get(url_for('cache_testapp/decorator_class'))
self.assertEqual(response.status_code, 200)
c = memcache.get('http://localhost/decorator_class?lang=en',
namespace='CACHE_DECORATOR')
self.assertEqual(c.data, response.data)
def test_cache_middleware(self):
# make sure that CACHE_MIDDLEWARE_ANONYMOUSE_ONLY works
self.client.test_login(email='*****@*****.**')
response = self.client.get(url_for('cache_testapp/index'))
self.assertEqual(response.status_code, 200)
c = memcache.get('http://localhost/?lang=en',
namespace='CACHE_MIDDLEWARE')
self.assertEqual(c, None)
self.client.test_logout()
# user logout, so the cache works
response = self.client.get(url_for('cache_testapp/index'))
self.assertEqual(response.status_code, 200)
c = memcache.get('http://localhost/?lang=en',
namespace='CACHE_MIDDLEWARE')
self.assertEqual(c.data, response.data)
def test_ereporter(self):
from kay.ext.ereporter.models import ExceptionRecord
self.assertEqual(ExceptionRecord.all().count(), 0, "ExceptionRecord objects already exist!")
response = self.client.get(url_for('ereporter_testapp/index'))
self.assertEqual(response.status_code, 500, "Expected 500 error code.")
self.assertEqual(ExceptionRecord.all().count(), 1)
# Simulate the key expiring.
memcache.flush_all();
response = self.client.get(url_for('ereporter_testapp/index'))
self.assertEqual(response.status_code, 500, "Expected 500 error code.")
self.assertEqual(ExceptionRecord.all().count(), 1, "More than one ExceptionRecord object was created!")
self.assertEqual(ExceptionRecord.all()[0].count, 2, "ExceptionRecord count not incremented!")
def edit_job(request, key_id):
job = Job.get_by_id(key_id)
if not job:
return redirect(url_for('job/admin/index'))
form = JobForm(instance=job)
if request.method == 'POST' and form.validate(request.form):
job = form.save(commit=False)
job.put()
return redirect(url_for('job/admin/index'))
return render_to_response(
'job/admin/edit.html', {
'form': form.as_widget(),
'key_id': key_id
}
)
def test_cache_decorator_with_class_view(self):
# make sure that CACHE_MIDDLEWARE_ANONYMOUSE_ONLY works
self.client.test_login(email='*****@*****.**')
response = self.client.get(url_for('cache_testapp/decorator_class'))
self.assertEqual(response.status_code, 200)
c = memcache.get('http://localhost/decorator_class?lang=en',
namespace='CACHE_DECORATOR')
self.assertEqual(c, None)
self.client.test_logout()
# user logout, so the cache works
response = self.client.get(url_for('cache_testapp/decorator_class'))
self.assertEqual(response.status_code, 200)
c = memcache.get('http://localhost/decorator_class?lang=en',
namespace='CACHE_DECORATOR')
self.assertEqual(c.data, response.data)
def test_fetch_oauth_request_token(self):
osg_auth = OSGOAuth(self.consumer_key, self.consumer_secret)
logging.debug("testing fetch request token")
token = osg_auth.get_request_token("http://localhost:8080%s" % url_for('core/oauth/request_token'))
#response = self.client.get(url)
logging.debug("token.key: %r", token.key)
logging.debug("token.secret: %r", token.secret)
osg_auth = OSGOAuth(self.consumer_key,
self.consumer_secret,
token.key,
token.secret)
auth_url = osg_auth.get_authorization_url(token=token,
authorization_url=("http://localhost:8080%s" % url_for('core/oauth/authorize')))
logging.debug(auth_url)
self.assertTrue(True)
def test_login(self):
response = self.client.get(url_for('auth_testapp/index'))
self.assertEqual(response.status_code, 200)
response = self.client.get(url_for('auth_testapp/secret'))
self.assertEqual(response.status_code, 302)
self.assert_(
response.headers.get('Location').endswith(
'/auth/login?next=http%253A%252F%252Flocalhost%252Fsecret'))
self.client.test_login(username='******')
response = self.client.get(url_for('auth_testapp/secret'))
self.assertEqual(response.status_code, 200)
self.client.test_logout()
response = self.client.get(url_for('auth_testapp/secret'))
self.assertEqual(response.status_code, 302)
def accept(request, request_id):
if request.method == 'POST':
reguest = RegistrationRequest.get_by_id(request_id)
if reguest:
reguest.status = REQUEST_STATUS['accepted']
reguest.put()
password = passgen()
try:
new_user = create_new_user(
user_name = reguest.email,
password = password,
is_admin = False,
first_name = reguest.name,
telephone = reguest.telephone,
organization = reguest.organization,
address = reguest.address,
email = reguest.email
)
def txn():
taskqueue.add(url=url_for('reguest/admins/send_accept_to_user',
request_id=reguest.key.id(),
password = password),
transactional=True)
db.run_in_transaction(txn)
except DuplicateKeyError:
pass
return redirect(url_for('reguest/admins/index'))
def create_release(request):
form = ReleaseForm()
if form.validate(request.form):
form.save()
return redirect(url_for('vault/list_releases'))
return render_to_response('vault/new_release.html',
{'form': form.as_widget()})
def txn_sync():
task_id = str(uuid.uuid4())
memcache.add(task_id, id, TASK_LIVE_TIMEOUT)
taskqueue.add(
url=url_for('sync/sync_gift_task', task_id=task_id),
transactional=True
)
def enable(request, key):
if request.method != 'POST':
return MethodNotAllowed()
if request.user.is_anonymous() or not request.user.is_admin:
return Unauthorized()
recipe = models.Recipe.get(key)
if not recipe:
return NotFound()
# Zmień status na włączony
recipe.disabled = False
recipe.put()
if recipe.rec_vis == VISIBILITY[2]:
def utx():
user = PMMUser.get(recipe.parent_key())
user.rec_pub += 1
user.put()
cache_delete('gfcu', recipe.parent_key().name())
db.run_in_transaction(utx)
# na później odłóż indeksację, uaktualnienie tagów i licznika kategorii
deferred_lib.defer(deferred.recipe_update, recipe.key(), 'enable')
request.notifications.success('Przepis włączony!')
return render_json_response({'redirectUrl': url_for('przepisy/disabled_list')})
def skill_edit(request):
u"""スキルを登録・編集する管理画面
"""
# skill = Skill.all().filter('key =', request.form['key']).fetch(1)
logging.debug(inspect.currentframe().f_lineno)
logging.debug(request.form)
form = SkillForm()
if request.method == "POST":
logging.debug(inspect.currentframe().f_lineno)
logging.debug(request.form)
if request.form['name']:
logging.debug(inspect.currentframe().f_lineno)
logging.debug(request.form)
skill = Skill.get_skill(request.form['name'])
if not skill:
skill = Skill.add_skill( request.form['name'],
int(request.form['timing']),
int(request.form['typ']),
request.form['param'],
int(request.form['value']))
logging.debug(inspect.currentframe().f_lineno)
logging.debug(request.form['timing'])
skill.timing = int(request.form['timing'])
skill.typ = int(request.form['typ'])
skill.param = request.form['param']
skill.value = int(request.form['value'])
# skill.job = request.form['job']
skill.put()
return redirect(url_for('htbrpg2kay/index'))
return render_to_response('htbrpg2kay/skill_edit.html',
{'form': form.as_widget()})
def result(request):
"""速度の測定値結果を表示するページ
Args:
request:
リクエストオブジェクト
Return:
レンダリングされたテンプレートデータ
まだ仕様未決の為適当実装
"""
form = MeasuredResultForm()
if request.method == "POST":
if form.validate(request.form):
# 仕様未決の為実装は適当
result = form.save()
return redirect(url_for('kokodoya/index'))
render_params = {}
render_params['form'] = form.as_widget()
current = datetime.datetime.now()
render_params['measured_time'] = current.strftime("%Y/%m/%d %H:%M")
# todo : ちゃんとした奴に直す
import random
render_params['speed'] = random.randrange(5, 50) / 10.0
render_params['address'] = u"福井県鯖江市新横江"
return render_to_response('kokodoya/result.html', render_params)
def login_box(request):
from kay.auth import login
next = unquote_plus(request.values.get("next"))
owned_domain_hack = request.values.get("owned_domain_hack")
message = ""
form = LoginBoxForm()
if request.method == "POST":
if form.validate(request.form):
result = login(request,
user_name=form.data['user_name'],
password=form.data['password'])
if result:
if owned_domain_hack == 'True':
original_host_url = unquote_plus(
request.values.get("original_host_url"))
url = original_host_url[:-1] + url_for("auth/post_session")
url += '?' + url_encode({
'session_id': result.key().name(),
'next': next
})
return redirect(url)
else:
return redirect(next)
else:
message = _("Failed to login.")
return render_to_response("auth/loginform.html", {
"form": form.as_widget(),
"message": message
})
def test_login(self):
from kay.auth import create_new_user
create_new_user("foobar", "password", is_admin=False)
response = self.client.get(url_for('auth_testapp/index'))
self.assertEqual(response.status_code, 200)
response = self.client.get(url_for('auth_testapp/secret'))
self.assertEqual(response.status_code, 302)
self.assert_(
response.headers.get('Location').endswith(
'/auth/login?next=http%253A%252F%252Flocalhost%252Fsecret'))
self.client.test_login(username='******')
response = self.client.get(url_for('auth_testapp/secret'))
self.assertEqual(response.status_code, 200)
self.client.test_logout()
response = self.client.get(url_for('auth_testapp/secret'))
self.assertEqual(response.status_code, 302)
def site_view(request):
if _invalid_configuration(request): return _redirect_configuration(request)
url = request.args['url'] if request.args.has_key('url') else None
if not url: return redirect(url_for('admin/'))
from xml.sax.saxutils import *
html = urllib2.urlopen(url).read()
html = unicode(html, 'utf8', 'ignore')
return render_to_response('admin/site_view.html', {"html": html})
def wrapped(request, *args, **kwargs):
datastore_write = CapabilitySet('datastore_v3', capabilities=['write'])
datastore_writable = datastore_write.will_remain_enabled_for(60)
if not datastore_writable:
logging.warn('Datastore is not writable. %s' %
datastore_write.admin_message())
if not request.is_xhr:
return redirect(url_for(endpoint))
return view(request, *args, **kwargs)
def create_login_url(self, next_url='/'):
if hasattr(local.request, settings.MARKETPLACE_DOMAIN_NAME_KEY):
# marketplace
domain = getattr(local.request,
settings.MARKETPLACE_DOMAIN_NAME_KEY)
return create_marketplace_login_url(domain, next_url)
return url_for('gaema/select_service',
targets='|'.join(self.valid_services),
next_url=url_quote_plus(next_url))
def __init__(self,
next_url=None,
form_cls=None,
template_name='registration/registration_form.html',
extra_context=None):
self.next_url = next_url or url_for(
'registration/registration_complete')
self.form_cls = form_cls or RegistrationForm
self.template_name = template_name
self.extra_context = extra_context or {}
self.form = self.form_cls()
def create_login_url(self, url):
import os
hostname = get_appid() + '.appspot.com'
url = url_for("auth/login",
next=url_quote_plus(url),
original_host_url=url_quote_plus(local.request.host_url),
owned_domain_hack=True)
if 'SERVER_SOFTWARE' in os.environ and \
os.environ['SERVER_SOFTWARE'].startswith('Dev'):
return url
else:
return "https://%s%s" % (hostname, url)
def txn(id):
key_name = cls.get_key_name(id)
if additional_tq_url is not None:
tq_kwargs.update(
{'session_key': db.Key.from_path(cls.kind(), key_name)})
taskqueue.add(url=url_for(additional_tq_url, **tq_kwargs),
transactional=True)
taskqueue.add(url=url_for("_internal/expire_temporary_session",
session_key=db.Key.from_path(
cls.kind(), key_name)),
countdown=countdown,
transactional=True)
session = cls.get_by_key_name(key_name)
if session is None:
if data:
session = cls(key_name=key_name, user=user, data=data)
else:
session = cls(key_name=key_name, user=user)
session.put()
return session
else:
raise db.Rollback("The specified id already exists.")
def edit_group(request):
error_message = None
if request.method == "GET":
key_name = request.values.get("key_name", None)
group = Group.get_by_key_name(key_name)
if not group.is_owned_by(request.user):
raise Forbidden()
form = get_edit_form(group)
elif request.method == "POST":
key_name = request.form.get("hidden_key_name", None)
group = Group.get_by_key_name(key_name)
if not group.is_owned_by(request.user):
raise Forbidden()
form = get_edit_form(group)
if form.validate(request.form):
if str(group.updated) == form["hidden_updated"]:
group.language = form["language"]
group.description = form["description"]
group.members = form["members"]
group.applications = form["applications"]
group.banned_addresses = form["banned_addresses"]
group.put()
return redirect(
url_for('groupy/group_detail',
key_name=group.key().name()))
else:
# re-init because of race condition
form = get_edit_form(group)
error_message = _("Sorry, It can not be saved because "
"a race condition happened. "
"Please try again from the start.")
else:
pass
return render_to_response(
"groupy/edit_group.html", {
"message": _("Editing a group"),
"form": form.as_widget(),
"error_message": error_message,
"group": group
})
def add_group(request):
form = AddGroupForm()
if request.method == "POST":
if form.validate(request.form):
form['name']
group = Group.get_or_insert(
key_name=Group.get_key_name(form['name']),
name=form['name'],
language=form['language'],
description=unicode(form['description']),
owner=request.user,
members=form['members'])
if group.owner.key() != request.user.key():
form.errors.append("Group creation failed.")
else:
return redirect(
url_for('groupy/group_detail',
key_name=group.key().name()))
else:
pass
return render_to_response('groupy/edit_group.html', {
'form': form.as_widget(),
'message': _("Adding a new group")
})
def admin(request):
nsform = None
namespace = ''
if 'namespace' in request.args:
nsform = KayNamespaceForm()
if nsform.validate(request.args):
namespace = nsform['namespace'] or ''
nsform = nsform.as_widget()
object_list = list(KayLiveSetting.all(namespace=namespace))
forms = dict(
map(
lambda s: (s.key().name(),
KayLiveSettingForm(instance=s,
initial={
"key_name": s.key().name(),
"namespace": namespace,
})), object_list))
if (request.method == "POST"):
key_name = request.form.get('key_name')
if key_name:
form = forms.get(key_name, None)
if not form:
form = KayLiveSettingForm()
if form.validate(request.form):
if 'delete' in request.form:
_set_flash_msg(
request,
_("Deleted the setting '%(key)s'" % {
'key': key_name,
}))
live_settings.delete(form['key_name'], namespace=namespace)
if key_name in forms:
del forms[key_name]
else:
_set_flash_msg(
request,
_("Updated the setting '%(key)s'" % {
'key': key_name,
}))
forms[key_name] = form
form.instance = live_settings.set(
form['key_name'],
form['value'],
namespace=namespace,
)
return redirect(
"%s?%s" % (
url_for('live_settings/admin'),
url_encode(request.args),
), )
new_form = KayLiveSettingForm()
return render_to_response(
'live_settings/admin.html',
{
'flash_msg': _get_flash_msg(request),
'to_local_timezone':
to_local_timezone, # ensure we have this function
'nsform': nsform,
'namespace': namespace,
'form_list': map(lambda f:
(f.instance, f.as_widget()), forms.values()),
'new_form': new_form.as_widget(),
})
def create_gaema_logout_url(service, nexturl="/"):
next_url_key = NEXT_URL_KEY_FORMAT % service
set_cookie(next_url_key, nexturl)
return url_for("gaema/logout", service=service)
def url_for(self, *args, **kwargs):
kwargs['domain_name'] = self.domain
return url_for(*args, **kwargs)
def create_marketplace_logout_url(domain, nexturl="/"):
next_url_key = NEXT_URL_KEY_FORMAT % domain
set_cookie(next_url_key, nexturl)
return url_for("gaema/marketplace_logout", domain=domain)
def create_logout_url(self, url):
return url_for("auth/logout", next=url_quote_plus(url))
def url_for(self, *args, **kwargs):
return url_for(*args, **kwargs)
def test_login(self):
response = self.client.get(url_for('server_error_testapp/index'))
self.assertEqual(response.status_code, 500)
self.assertTrue(isinstance(response, BaseResponse))
def create_lang_url(lang=None, url=None):
from werkzeug.urls import url_quote_plus
from kay.utils import url_for
if not url:
url = local.request.url
return url_for("i18n/set_language", lang=lang, next=url_quote_plus(url))
def _redirect_configuration(request):
return redirect(url_for('admin/settings'))
def post(self):
if self.form.validate(self.request.form):
self.request.user.set_password(self.form['new_password'])
flash.set_flash(gettext("Password changed successfully."))
return redirect(url_for('auth/change_password'))
return self.get()
