def POST(self):
post = web.input(_method='POST')
errors = {}
user = users.get_user()
mode = ''
#Get all the stuff we want from POST
if 'from_username' in post:
mode = 'from'
other_username = forms.get_or_add_error(post, '%s_username' % mode, errors, lang.NO_FIELD_SUPPLIED('username'))
else:
mode = 'to'
other_username = forms.get_or_add_error(post, '%s_username' % mode, errors, lang.NO_FIELD_SUPPLIED('username'))
value_pounds = forms.get_or_add_error(post, '%s_value_pounds' % mode, errors, lang.NO_FIELD_SUPPLIED('pounds value'))
value_pence = forms.get_or_add_error(post, '%s_value_pence' % mode, errors, lang.NO_FIELD_SUPPLIED('pence value'))
reason = forms.get_or_add_error(post, '%s_reason' % mode, errors, lang.NO_FIELD_SUPPLIED('reason'))
#Process and validate the amount
try:
if value_pounds.strip() == '':
value_pounds = 0
if value_pence.strip() == '':
value_pence = 0
value_pounds = int(value_pounds)
value_pence = int(value_pence)
if value_pounds < 0 or value_pence < 0:
raise Exception
if value_pounds != None and value_pence != None:
forms.validate(errors, '%s_value' % mode, lang.MUST_BE_GREATER_THAN_ZERO('Value'), lambda po,pe: (po+pe*100)>0, (value_pounds,value_pence))
except:
errors['%s_value' % mode] = lang.MUST_BE_POS_INTEGER('Pounds and pence')
#Validate the reason
forms.validate(errors, '%s_reason' % mode, lang.NO_FIELD_SUPPLIED('reason'), lambda r: bool(r), (reason,))
#Validate and get the other user
if other_username:
other_user = db.users.find_one({'username':other_username})
forms.validate(errors, '%s_username' % mode, lang.NO_CONTACT_FOUND, lambda u: bool(u), (other_user,))
#Now do the rendering
if not errors:
value = round((float(value_pounds)*100 + float(value_pence)) / 100.0, 2)
if mode == 'to':
from_user, to_user = user, other_user
else:
from_user, to_user = other_user, user
trans = db.transactions.save({'from_user': from_user['_id'], 'to_user': to_user['_id'], 'value':value, 'timestamp':time.time(), 'reason':reason})
return render('transfer.html', success=True, user=self._deref_contacts(), from_user=from_user, to_user=to_user, value="%.2f" % value, mode=mode)
else:
return render('transfer.html', errors=errors, user=self._deref_contacts())
def get(self):
self.response.write(render('head', {}))
self.response.write(render('header', { 'current': 'prices' }))
for work in Prices.query().fetch():
self.response.write(render('work', { 'work': work }))
for photo in WorkPhoto.query(ancestor=ndb.Key(Work, work.key.id())).order(+WorkPhoto.priority).fetch():
self.response.write(render('work-photo', { 'photo': photo }))
self.response.write(render('footer', {}))
def show_more(username, topic, offset, past_album):
results = UserProcess(username).retrieve_results_for_topic(
int(topic), int(offset), unicode(past_album.decode("utf-8")))
if is_XHR():
return render("show-more-xhr",
username=username,
topic=topic,
results=results,
nextoffset=int(offset) + len(results))
return render("show-more",
username=username,
topic=topic,
results=results,
nextoffset=int(offset) + len(results))
def graph(self,id,**kwargs):
cherrypy.log('graph: %s' % id)
character = m.Character.get(id)
if not character:
raise e.Validation('Could not find character')
src = render('/characters/graph.html',character=character).strip()
return redirect(src)
def POST(self):
post = web.input(_method='POST')
errors = {}
username = forms.get_or_add_error(post, 'username', errors,
lang.NO_FIELD_SUPPLIED('username'))
password = forms.get_or_add_error(post, 'password', errors,
lang.NO_FIELD_SUPPLIED('password'))
password_again = forms.get_or_add_error(
post, 'password_again', errors,
lang.NO_FIELD_SUPPLIED('password again'))
forms.validate(errors, 'password_again', lang.PASSWORDS_DONT_MATCH,
lambda p, p2: p == p2, (password, password_again))
if username is not None:
forms.validate(errors, 'username',
lang.FIELD_MUST_BE_LEN('Username', 3),
lambda u: len(u) >= 3, (username, ))
forms.validate(
errors, 'username', lang.USERNAME_TAKEN,
lambda u: not bool(db.users.find_one({'username': u})),
(username, ))
if password is not None:
forms.validate(errors, 'password',
lang.FIELD_MUST_BE_LEN('Password', 5),
lambda p: len(p) >= 5, (password, ))
if errors:
return render('register.html', errors=errors)
else:
users.register(username=username, password=users.pswd(password))
web.seeother('/login/')
def on_actionExport_triggered(self):
log.debug('export')
exts = ';;'.join([t[0] for t in templates])
fname = QtGui.QFileDialog.getSaveFileName(self, u"Экспорт", ".", exts)
if not fname:
return
fname = unicode(fname)
try:
#items = self.conn.root()['item'][:10] #FIXME demo
items = self.conn.root()['item'] # full
if fname.lower().endswith('.xls'):
self.export_xls(fname, items)
return
Item.BASEDIR = os.path.dirname(fname)
fout = codecs.open(fname, 'w', 'utf8')
c = 0
strm = render(fname, {'items': items})
strm.enable_buffering()
for chunk in strm:
fout.write(chunk)
self.statusBar().showMessage(u'Обработка %i' % c)
c += 1
fout.close()
self.statusBar().showMessage(u'Готово', 3000)
except IOError:
QtGui.QMessageBox.critical(self, u"Экспорт", u"Ошибка записи в файл.")
except:
log.exception('export error')
QtGui.QMessageBox.critical(self, u"Экспорт", u"Все пропало, смотри логи.")
def POST(self, username):
post = web.input(_method='POST')
errors = {}
user = users.get_user()
contact = db.users.find_one({'username':username})
forms.validate(errors, 'username', lang.NO_CONTACT_FOUND, lambda c: bool(c), (contact,))
if contact:
forms.validate(errors, 'username', lang.ALREADY_CONNECTED(contact['username']), lambda u, c: ('contacts' not in u) or (c not in u['contacts']), (user, contact))
forms.validate(errors, 'username', lang.CANT_CONNECT_TO_SELF, lambda u, c: c!=u, (user, contact))
if contact and not errors:
#Add to the user's contacts
if 'contacts' not in user or not user['contacts']:
user['contacts'] = []
user['contacts'].append(DBRef('users',contact['_id']))
#Add user to the other persons contacts
if 'contacts' not in contact or not contact['contacts']:
contact['contacts'] = []
contact['contacts'].append(DBRef('users',user['_id']))
#Save them both
db.users.save(user)
db.users.save(contact)
return render('/users/profile.html', profile=contact, errors=errors, connected=self.connected(contact))
def GET(self):
u_id = users.get_user()['_id']
print u_id
fleet = db.player_items.find({'u_id': u_id, 'item': "Ship"})
ship_id = []
name = []
health = []
type = []
ship_fleet = []
list_fleet = []
count = 0
list = 0
for x in fleet:
ship_id.append(x['_id'])
name.append(x['name'])
type.append(x['type'])
health.append(x['health'])
ship_fleet.append(x['fleet'])
if (x['fleet'] in list_fleet) == False:
list_fleet.append(x['fleet'])
list += 1
count += 1
return render('fleet.html',
name=name,
type=type,
health=health,
count=count,
list=list,
list_fleet=list_fleet,
ship_fleet=ship_fleet,
ship_id=ship_id)
def contact_view(request):
print(routes)
# Проверка метода запроса
if request['method'] == 'POST':
print(request)
data = request['data']
title = data['title']
title = core.Application.decode_value(title)
text = data['text']
text = core.Application.decode_value(text)
email = str(data['email'])
print('Нам пришло сообщение от ' + email + ' с темой ' + title +
' и текстом ' + text)
return '200 OK', render('contact.html')
else:
return '200 OK', render('contact.html')
def moderate(self, msg):
# For some reason, this import doesn't work at the file level.
from control import sign
message_id = msg['message-id']
if not message_id:
print(
'Unable to moderate incoming message due to lack of Message-ID: header.'
)
raise ValueError('Messages must contain a Message-ID: header.')
message_id = message_id.replace(
':', '_') # Make it safe for subject-command.
# Put the email message into the list's moderation holding space on S3.
response = s3.put_object(
Bucket=config.s3_bucket,
Key=self._s3_moderation_prefix + message_id,
Body=msg.as_string(),
)
# Get the moderation auto-deletion/auto-rejection interval from the S3 bucket lifecycle configuration.
lifecycle = s3.get_bucket_lifecycle_configuration(
Bucket=config.s3_bucket)
from datetime import timedelta
mod_interval = timedelta(
days=next((r['Expiration']['Days']
for r in lifecycle.get('Rules', [])
if r['Prefix'] == config.s3_moderation_prefix), 3))
# Wrap the moderated message for inclusion in the notification to mods.
forward_mime = MIMEMessage(msg)
control_address = 'lambda@{}'.format(self.host)
for moderator in self.moderator_addresses:
# Build up the notification email per-moderator so that we can include
# pre-signed moderation commands specific to that moderator.
approve_cmd = sign(
'list {} mod approve "{}"'.format(self.address, message_id),
moderator, mod_interval)
reject_cmd = sign(
'list {} mod reject "{}"'.format(self.address, message_id),
moderator, mod_interval)
message = MIMEMultipart()
message['Subject'] = 'Message to {} needs approval: {}'.format(
self.address, approve_cmd)
message['From'] = control_address
message['To'] = moderator
message.attach(
MIMEText(
templates.render('notify_moderators.jinja2',
list_name=self.address,
control_address=control_address,
approve_command=approve_cmd,
reject_command=reject_cmd,
moderation_days=mod_interval.days)))
message.attach(forward_mime)
ses.send_raw_email(
Source=control_address,
Destinations=[
moderator,
],
RawMessage={
'Data': message.as_string(),
},
)
def get(self):
if len(Exclusive.query().fetch()):
entity = Exclusive.query().fetch(1)[0]
else:
entity = {'text': ''}
self.response.write(render('exclusive', {'exclusive': entity}))
def current_data_route():
# Read temperature, luminosity and sound intensity
temp = board.temp.value()
light = board.light.value()
sound = board.sound.read() # Useless, we should capture data over a short period of time and return a mean
return render(['p', "Temperature : %s°C" % temp],
['p', "Luminosity : % Lux" % light],
['p', "Sound % ?" % sound])
def GET(self):
user = users.get_user()['username']
if user == "Xariec":
site_users = []
query = db.users.find()
for a in query:
site_users.append((a))
return render('xariec.html', site_users = site_users)
def GET(self):
user = users.get_user()['username']
access = users.get_user()['access']
if access > 1:
players = mongo.playerList(access)
sizes = mongo.sectorSizes()
hw = mongo.homeworldList()
return render('dbstuff.html', players = players, sizes = sizes, hw = hw)
else:
return web.seeother('/')
def POST(self):
post = web.input(_method='POST')
name = post['list']
cord = name.split(',')
x = cord[0]
y = cord[1]
test = db.warps.find_one({'x_origin': int(x), 'y_origin': int(y)})
query = test['player']
# query = x
return render('warps.html', query=query)
def moderate(self, msg):
# For some reason, this import doesn't work at the file level.
from control import sign
message_id = msg["message-id"]
if not message_id:
print("Unable to moderate incoming message due to lack of Message-ID: header.")
raise ValueError("Messages must contain a Message-ID: header.")
message_id = message_id.replace(":", "_") # Make it safe for subject-command.
# Put the email message into the list's moderation holding space on S3.
response = s3.put_object(
Bucket=config.s3_bucket, Key=self._s3_moderation_prefix + message_id, Body=msg.as_string()
)
# Get the moderation auto-deletion/auto-rejection interval from the S3 bucket lifecycle configuration.
lifecycle = s3.get_bucket_lifecycle_configuration(Bucket=config.s3_bucket)
from datetime import timedelta
mod_interval = timedelta(
days=next(
(
r["Expiration"]["Days"]
for r in lifecycle.get("Rules", [])
if r["Prefix"] == config.s3_moderation_prefix
),
3,
)
)
# Wrap the moderated message for inclusion in the notification to mods.
forward_mime = MIMEMessage(msg)
control_address = "lambda@{}".format(self.host)
for moderator in self.moderator_addresses:
# Build up the notification email per-moderator so that we can include
# pre-signed moderation commands specific to that moderator.
approve_cmd = sign('list {} mod approve "{}"'.format(self.address, message_id), moderator, mod_interval)
reject_cmd = sign('list {} mod reject "{}"'.format(self.address, message_id), moderator, mod_interval)
message = MIMEMultipart()
message["Subject"] = "Message to {} needs approval: {}".format(self.address, approve_cmd)
message["From"] = control_address
message["To"] = moderator
message.attach(
MIMEText(
templates.render(
"notify_moderators.jinja2",
list_name=self.address,
control_address=control_address,
approve_command=approve_cmd,
reject_command=reject_cmd,
moderation_days=mod_interval.days,
)
)
)
message.attach(forward_mime)
ses.send_raw_email(
Source=control_address, Destinations=[moderator], RawMessage={"Data": message.as_string()}
)
def GET(self):
user = users.get_user()['username']
access = users.get_user()['access']
if access >= 1:
players = mongo.playerList(access)
alliance = mongo.alliances(access)
score_time = mongo.scoreTime()
sector_time = mongo.sectorTime()
return render('intelViewer.html', players = players, alliances = alliance, score_time = score_time, sector_time = sector_time, access = access)
else:
return web.seeother('/')
def GET(self):
st = time_stamp()
user = users.get_user()['username']
access = users.get_user()['access']
if access >= 3:
info = ""
db.users.update({'username' : user},{"$push" :{'updates' : {'time' : st, 'action' : "View Users in Admin", 'info' : info}}})
uws_users = mongo.userControl()
return render('admin.html', access = uws_users)
else:
return web.seeother('/')
def copy_course(request):
request_params = request['request_params']
# print(request_params)
name = request_params['name']
old_course = site.get_course(name)
if old_course:
new_name = 'copy_' + name
new_course = old_course.clone()
new_course.name = new_name
site.courses.append(new_course)
return '200 OK', render('course_list.html', objects_list=site.courses)
def list_concepts(concepts):
def template_data(concept):
return {
'uri': 'concepts/%s' % concept._id, # XXX: URI hardcoded; breaks encapsulation
'label': concept.label()
}
concepts_data = (template_data(concept) for concept in concepts) # XXX: unnecessarily complex?
return render('list_concepts.html', title='Concepts',
concepts=concepts_data, root_uri='/') # XXX: root_uri hardcoded; breaks encapsulation
def GET(self):
user = users.get_user()['username']
access = users.get_user()['access']
if access > 2:
map = db.map_time.find().sort('utime', -1).limit(1)
for a in map:
last_map = a['utime']
print last_map
return render('upload.html', last_map = last_map)
else:
return web.seeother('/')
def POST(self):
post = web.input(_method='POST')
errors = {}
username = forms.get_or_add_error(post, 'username', errors, lang.NO_FIELD_SUPPLIED('username'))
if not errors:
result = db.users.find_one({'username':username})
forms.validate(errors, 'username', lang.NO_CONTACT_FOUND, lambda c: bool(c), (result,))
if result:
return web.seeother('/users/%s/' % result['username'])
else:
return render('/users/search.html', errors=errors)
def GET(self):
sectors = []
count = 0
collection = db.sector_map.find({'pname' : { "$in" : ["Corax", "Crazybonkers", "Deaths Advisor the Angry", "DEMENTED", "Fraya", "Henchman 21", "Lieutenant Xience", "pwnyxpress", "Sniffles", "Zapper"]}}).sort('last_update', -1).limit(50)
for a in collection:
if len(sectors) < 2000:
if a['last_update'] != "":
count +=1
sectors.append((a))
else:
continue
return render('collection.html', sectors = sectors, count = count)
def POST(self):
u_id = users.get_user()['_id']
post = web.input(_method='POST')
try:
button = post['button']
except:
print post
if button:
people = web_actions.Population()
single = people.getOnePersonnel(button, u_id)
button = people.getAllPersonnel(u_id)[1]
print single
return render('personnel.html', button=button, single=single)
def tag(bot, update, args):
'''Charlas etiquetadas con un deterinado.
'''
tag = args[0].strip().lower()
if tag in E.tags:
return True, templates.render(
'templates/tag.txt',
talks=E.tags[tag],
tag=tag,
)
else:
return False, "No reconozco ese tag. El comando `/tags` te " \
" mostrará las etiquetas disponibles."
def create_course(request):
if request['method'] == 'POST':
# метод пост
data = request['data']
name = data['name']
name = Application.decode_value(name)
category_id = data.get('category_id')
category = None
if category_id:
category = site.find_category_by_id(int(category_id))
course = site.create_course('record', name, category)
# Добавляем наблюдателей на курс
course.observers.append(email_notifier)
course.observers.append(sms_notifier)
site.courses.append(course)
# редирект?
# return '302 Moved Temporarily', render('create_course.html')
# Для начала можно без него
return '200 OK', render('create_course.html')
else:
categories = site.categories
return '200 OK', render('create_course.html', categories=categories)
def POST(self):
st = time_stamp()
user = users.get_user()['username']
access = users.get_user()['access']
if access >= 3:
uws_users = mongo.userControl()
post = web.input(_method='POST')
new_access_level = int(post['lvl'])
update_user = post['user']
user_updated = db.users.find_one({'_id' : ObjectId(post['user'])})['username']
info = "%s updated to lvl %d" %(user_updated, new_access_level)
db.users.update({'username' : user},{"$push" :{'updates' : {'time' : st, 'action' : "Update Users in Admin", 'info' : info}}})
new_access = mongo.updateAccess(update_user, new_access_level)
return render('admin.html', access = uws_users)
def post(self, poll_id):
ch = self.request.POST.get('choice')
poll = get_or_404(self, poll_id)
selected_choice = None
for c in poll.choices:
if c.id == ch:
selected_choice = c
if not selected_choice:
error = 'Invalid choice or no choice'
self.response.write(render('poll.html', { 'poll':poll, 'error_message':error }))
return
selected_choice.votes += 1
poll.total_votes += 1
poll.put()
return webapp2.redirect('/results/' + poll_id)
def GET(self, username):
contact = db.users.find_one({'username':username})
if not contact:
raise web.notfound()
trans, balance, people_owe_you, you_owe_people = transactions.get_transaction_details(db, users.get_user())
owes_you = False
you_owe = False
if contact['username'] in people_owe_you:
owes_you = people_owe_you[contact['username']][1]
elif contact['username'] in you_owe_people:
you_owe = you_owe_people[contact['username']][1]
return render('/users/profile.html', profile=contact, connected=self.connected(contact), owes_you = owes_you, you_owe = you_owe)
def getAll(self):
content = templates.render({
"base_url": ctx.base_url
},"doc.json")
api = json.loads(content)
api["supportedClass"] += [obj.toJSON() for obj in hydra.get_classes()]
for classObj in hydra.get_entrypoint_classes():
for apiClass in api["supportedClass"]:
if apiClass["@id"] == "vocab:EntryPoint":
apiClass["supportedProperty"].append(classObj.getEntryPointDoc())
break
api = json.loads(json.dumps(api, default=dumper, indent=2))
return ctx.success(api, 200, headers = hydra.LINK_HEADER)
def POST(self):
post = web.input(_method='POST')
errors = {}
try:
user = users.authenticate(post['username'], post['password'])
if user:
users.login(user)
else:
errors['__all__'] = lang.AUTH_FAILURE
except KeyError:
errors['__all__'] = lang.AUTH_FAILURE
if errors:
return render('login.html', errors=errors, next=post.get('next'))
else:
return web.seeother(post.get('next','/summary/'))
def doRender( handler, tname = 'index.htm', values = {} ):
logging.error( 'tname = ' + tname )
temp = os.path.join( os.path.dirname( __file__ ), 'templates', tname )
logging.error( temp )
if not os.path.isfile( temp ):
temp = os.path.join( os.path.dirname( __file__ ), 'templates', 'index.htm' )
logging.error( 'got here' )
newval = dict( values )
newval['path'] = handler.request.path
handler.session = Session()
if 'username' in handler.session:
newval['username'] = handler.session['username']
logging.error( 'jack tracing' + temp )
outstr = template.render( temp, newval, True, ( 'templates/', ) )
handler.response.out.write( outstr )
return True
def track(bot, update, args):
'''Listado de charlas de un track.
'''
is_valid, num_track = utils.as_integer(args[0])
print('is_valid: {}, num_track: {}'.format(is_valid, num_track))
if is_valid and E.is_valid_track(num_track):
track = E.tracks[num_track - 1]
text = templates.render(
'templates/track.txt',
num_track=num_track,
track=track,
talks=track.talks,
)
return True, str(text)
else:
return False, "Necesito un número entre 1 y {}".format(E.num_tracks)
def list_concepts(concepts):
def template_data(concept):
return {
'uri': 'concepts/%s' %
concept._id, # XXX: URI hardcoded; breaks encapsulation
'label': concept.label()
}
concepts_data = (template_data(concept)
for concept in concepts) # XXX: unnecessarily complex?
return render(
'list_concepts.html',
title='Concepts',
concepts=concepts_data,
root_uri='/') # XXX: root_uri hardcoded; breaks encapsulation
def POST(self):
post = web.input(_method='POST')
errors = {}
try:
user = users.authenticate(post['username'], post['password'])
if user:
users.login(user)
else:
errors['__all__'] = lang.AUTH_FAILURE
except KeyError:
errors['__all__'] = lang.AUTH_FAILURE
if errors:
return render('login.html', errors=errors, next=post.get('next'))
else:
# current_user = user
return web.seeother(post.get('next', '/default/'))
def render_item(self, item):
context = {}
count = str(self.count)
index = str(self.items.index(item) + 1)
index = '%s%s' % ('0' * (len(count) - len(index)), index)
context['item_index'] = index
context['item_count'] = count
context['is_playing'] = self.auto
context['is_paused'] = not self.auto
context['POPUP_WIDTH'] = settings.POPUP_WIDTH
context['COMMAND_CLOSE'] = COMMAND_CLOSE
context['COMMAND_NEXT'] = COMMAND_NEXT
context['COMMAND_PREVIOUS'] = COMMAND_PREVIOUS
context['COMMAND_FIRST'] = COMMAND_FIRST
context['COMMAND_LAST'] = COMMAND_LAST
context['COMMAND_PLAY'] = COMMAND_PLAY
context['COMMAND_PAUSE'] = COMMAND_PAUSE
html = templates.render(settings.POPUP_THEME, item, context)
return html
def POST(self):
st = time_stamp()
post = web.input(_method='POST')
errors = {}
try:
user = users.authenticate(post['username'], post['password'])
if user:
users.login(user)
db.users.update({'username' : post['username']},{"$push" :{'updates' : {'time' : st, 'action' : "Login", 'info' : ""}}})
else:
errors['__all__'] = lang.AUTH_FAILURE
except KeyError:
errors['__all__'] = lang.AUTH_FAILURE
if errors:
return render('login.html', errors=errors, next=post.get('next'))
else:
# current_user = user
return web.seeother(post.get('next' , '/' ))
def POST(self):
post = web.input(_method='POST')
errors = {}
username = forms.get_or_add_error(post, 'username', errors, lang.NO_FIELD_SUPPLIED('username'))
password = forms.get_or_add_error(post, 'password', errors, lang.NO_FIELD_SUPPLIED('password'))
password_again = forms.get_or_add_error(post, 'password_again', errors, lang.NO_FIELD_SUPPLIED('password again'))
forms.validate(errors, 'password_again', lang.PASSWORDS_DONT_MATCH, lambda p,p2: p == p2, (password, password_again))
if username is not None:
forms.validate(errors, 'username', lang.FIELD_MUST_BE_LEN('Username', 3), lambda u: len(u) >= 3, (username,))
forms.validate(errors, 'username', lang.USERNAME_TAKEN, lambda u: not bool(db.users.find_one({'username':u})), (username,))
if password is not None:
forms.validate(errors, 'password', lang.FIELD_MUST_BE_LEN('Password', 5), lambda p: len(p) >= 5, (password,))
if errors:
return render('register.html', errors=errors)
else:
users.register(username=username, password=users.pswd(password), access=0)
web.seeother('/login/')
def get(self):
self.response.write(render(
'works',
{ 'works': Work.get_root()['children'] }))
def show_concept(concept): # TODO: i18n
return render('show_concept.html',
title=concept.label(),
concept=concept,
concepts_uri='/concepts'
) # XXX: concepts_uri hardcoded; breaks encapsulation
def list_labels(labels):
return render(
'list_labels.html', title='Labels', labels=labels,
root_uri='/') # XXX: root_uri hardcoded; breaks encapsulation
def home_route():
return render(['p', ['a', {'href' : "/beeps"}, "Do some beeps"]],
['p', ['a', {'href' : "/room_data"}, "Display room data"]],
['p', ['a', {'href' : "/redbutton"}, "Red Button !"]])
def GET(self):
return render("register.html")
def get(self, serivce, user):
"""
Gets a feed for a given user and
"""
self.response.out.write(templates.render(""))
def show_concept(concept): # TODO: i18n
return render('show_concept.html', title=concept.label(), concept=concept,
concepts_uri='/concepts') # XXX: concepts_uri hardcoded; breaks encapsulation
def get(self):
template_variables = {
'message': "Hello World"
}
templates.render('home', template_variables, self)
def tags(bot, update):
'''Listado de tags.
'''
return True, templates.render('templates/tags.txt',
tags=sorted(E.tags.keys()))
def GET(self):
next = web.input(_method='GET').get(' next', '/default/')
return render('login.html', next=next)
def GET(self):
query = "Unknown"
return render('warps.html', query=query)
def main_view(request):
logger.log('Список курсов')
return '200 OK', render('course_list.html', objects_list=site.courses)
def GET(self):
return render('home.html')
def about_view(request):
result = {"secret": request.get('secret_key'), "key": request.get('key')}
return '200 OK', render('about.html', secret=result)
def category_list(request):
print(routes)
logger.log('Список категорий')
return '200 OK', render('category_list.html', objects_list=site.categories)
def GET(self):
print web.input()
return render("locked.html")
def GET(self):
return render("landing.html")
def list_labels(labels):
return render('list_labels.html', title='Labels', labels=labels,
root_uri='/') # XXX: root_uri hardcoded; breaks encapsulation
def GET(self):
return render("index.html")
async def hello_world(request):
return render("home.html", nombre="pepe")
def GET(self):
return render('register.html')
