def get(self):
"""hook for adding additional CSS if necessary
"""
loader = template.Loader(os.path.join(os.getcwd(), 'nbcluster_status'))
t = loader.load('clusterstatus.css')
self.set_header('Content-Type', 'text/css')
self.write(t.generate())
def render_mail(template_path, template_name, **kargs):
loader = template.Loader(template_path)
t = loader.load(template_name)
kargs["convert_ts"] = convert_ts
kargs["mapping_type"] = lambda t: type_mapping.get(t, "ip")
result = t.generate(**kargs)
send_mail(result)
def generate_model(model_name=None, model_type=None, appname=None):
""" generates a small model with the given modelname
also sets the right db and table settings and further boilerplate configuration.
Template engine = tornado.templates
"""
#
# set some attributes
#
try:
loader = template.Loader(templates["stubs_path"])
model_class_name = camel_case(model_name)
print("model_class_name: " + model_class_name)
model_name_plural = pluralize(model_name)
print("model_name_plural: " + model_name_plural)
#
# create the model
#
ofilePath = os.path.join(templates["model_path"], model_type)
ofile = open(os.path.join(ofilePath, model_name+".py"), "wb")
res = loader.load(model_type + "_model_template.py").generate(
model_name=model_name,
model_name_plural=model_name_plural,
model_class_name=model_class_name,
appname=appname,
model_type=model_type
)
ofile.write(res)
ofile.close()
except:
return False
return True
async def get(self, *args, **kwargs):
# web框架 都会有模版功能
word = "hello tornado"
# t = template.Template("<h1>{{ word }}</h1>")
loader = template.Loader(r"E:\tornado_overview\chapter02\templates")
# self.write(loader.load("hello.html").generate(word=word)) # 了解就行了
orders = [{
"name": "小米T恤 忍者米兔双截棍 军绿 XXL",
"image": "http://i1.mifile.cn/a1/T11lLgB5YT1RXrhCrK!40x40.jpg",
"price": 0,
"nums": 2
},
{
"name": "小米T恤 忍者米兔双截棍 军绿 XXL",
"image": "http://i1.mifile.cn/a1/T11lLgB5YT1RXrhCrK!40x40.jpg",
"price": 39,
"nums": 3
},
{
"name": "招财猫米兔 白色",
"image": "http://i1.mifile.cn/a1/T14BLvBKJT1RXrhCrK!40x40.jpg",
"price": 49,
"nums": 2
},
{
"name": "小米圆领纯色T恤 男款 红色 XXL",
"image": "http://i1.mifile.cn/a1/T1rrDgB4DT1RXrhCrK!40x40.jpg",
"price": 59,
"nums": 2
}
]
self.render("index2.html", orders=orders)
def get(self):
loader = template.Loader(config.ROOT_DIR)
return_str = loader.load(join(config.HTML_ROOT,
"index.html")).generate(
app_ip_address=config.APP_IP_ADDRESS,
app_port=config.PUBLIC_LISTEN_PORT)
self.finish(return_str)
async def get(self):
total_stats = self.compile_stats()
total_game_manager.stats = total_stats
total_game_manager.hands = game_manager.hands
loader = template.Loader("templates")
formatted_stats = total_game_manager.get_formatted()
self.write(loader.load("base2.html").generate(stats=formatted_stats, live=True))
def mail_connection(self):
return EmailBackend('smtp.gmail.com',
587,
'*****@*****.**',
'noreply@123',
True,
template_loader=template.Loader('.'))
def get(self):
result = {"text": "", "result": {}, "nlu_type": "stg"}
args = self.request.arguments
print args
text = ""
if "text" in args:
text = args["text"][0].strip()
result["text"] = text
nlu_type = "stg"
if "nlu_type" in args:
nlu_type = args["nlu_type"][0].strip()
result["nlu_type"] = nlu_type
if text:
nluResult = library.nlu_result(text,
_type="aladdin",
nlu_type=nlu_type)
else:
nluResult = {"exception": "Query is None!!"}
result["result"] = json.dumps(library._decode_dict(nluResult),
indent=2,
ensure_ascii=False)
loader = template.Loader("%s/static/template" % PWD)
self.write(loader.load("nlu.html").generate(o=result))
def get(self):
result = {}
result["error"] = ""
result["from"] = ""
result["to"] = ""
result["msg"] = ""
result["agency"] = ""
result["status"] = 500
args = self.request.arguments
_from = "5882"
_to = ""
_msg = ""
_agency = "SKT"
print args
if "from" in args:
_from = args["from"][0]
if "to" in args:
_to = args["to"][0]
if "msg" in args:
_msg = args["msg"][0].decode("utf-8")
if "agency" in args:
_agency = args["agency"][0].upper()
result["from"] = _from
result["to"] = _to
result["msg"] = _msg
result["agency"] = _agency
loader = template.Loader("%s/static/template" % PWD)
self.write(loader.load("sms.html").generate(o=result))
def get(self):
result = {"result": "Empty Result", "url": ""}
args = self.request.arguments
url = ""
if "url" not in args:
url = ""
else:
url = args["url"][0]
try:
f = urllib.urlopen(url)
data = f.read()
f.close()
try:
result["result"] = json.dumps(library._decode_dict(
json.loads(data)),
indent=2,
ensure_ascii=False)
except:
result["result"] = data
except:
result["result"] = traceback.format_exc()
pass
result["url"] = url
loader = template.Loader("%s/static/template" % PWD)
self.write(loader.load("proxy.html").generate(o=result))
def get(self):
result = {"text": "", "result": {}, "klp_index": {}, "klp_search": {}}
args = self.request.arguments
print args
text = ""
if "text" in args:
text = args["text"][0]
result["text"] = text
try:
f = urllib2.urlopen(KLP_INDEX_API % urllib.quote(text))
analyzerResult = json.loads(f.read(), "utf-8")
f.close()
except:
analyzerResult = {"exception": "Query is None!!"}
result["klp_index"] = json.dumps(library._decode_dict(analyzerResult),
indent=2,
ensure_ascii=False)
try:
f = urllib2.urlopen(KLP_SEARCH_API % urllib.quote(text))
analyzerResult = json.loads(f.read(), "utf-8")
f.close()
except:
analyzerResult = {"exception": "Query is None!!"}
result["klp_search"] = json.dumps(library._decode_dict(analyzerResult),
indent=2,
ensure_ascii=False)
loader = template.Loader("%s/static/template" % PWD)
self.write(loader.load("analyzer.html").generate(o=result))
def send_has_unread_message_email_handler(message):
'''如果用户不在线就发送邮件'''
from young.handler import BaseHandler
from app.user.document import UserDocument
from app.message.document import MessageDocument
message = MessageDocument.get_collection(pymongo=True).find_one(
{'_id': ObjectId(message.body)})
if not message:
return True
recipient_id = message['recipient'].id
topic = MessageTopic.message_type2topic(message['message_type'])
recipient = UserDocument.get_user_sync(recipient_id)
if recipient and recipient['activated']:
message = BaseHandler.translate_dbref_in_document(message)
if 'data' in message:
message['data'] = BaseHandler.translate_dbref_in_document(
message['data'], depth=2)
kwargs = {
'message_topic': topic,
'message': message,
'MessageTopic': MessageTopic,
'handler': BaseHandler
}
root = os.path.dirname(
os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
path = os.path.join(root, 'app/message/template')
loader = template.Loader(path)
html = loader.load("message.html").generate(**kwargs)
soup = BeautifulSoup(html, "html.parser")
link_list = soup.find_all('a')
for link in link_list:
new_link = link
if link['href'].startswith('/'):
new_link['href'] = EMAIL_SETTINGS['url'] + link['href']
link.replace_with(new_link)
img_list = soup.find_all('img')
for img in img_list:
new_img = img
if img['src'].startswith('/'):
new_img['src'] = EMAIL_SETTINGS['url'] + img['src']
img.replace_with(new_img)
body = ('{} <a href="{}/setting/notification">'
'关闭邮件提醒</a>').format(soup.prettify(), EMAIL_SETTINGS["url"])
msg = MIMEText(body, "html", 'utf-8')
msg["subject"] = "你有未读消息【Young社区】"
send_email(recipient['email'], msg)
return True
def main():
define("port", default=8888, type=int, help='web server port')
define("address", default='0.0.0.0', help='web server port')
options.parse_command_line()
path = lambda root, *a: os.path.join(root, *a)
ROOT = os.path.dirname(os.path.abspath(__file__))
settings = {}
settings['static_path'] = path(ROOT, "static")
settings['template_loader'] = template.Loader(path(ROOT, "templates"))
settings['login_url'] = "/login"
settings['debug'] = False
site.addsitedir(path(ROOT, 'handlers'))
url_patterns = [
(r"^/$", handlers.main.IndexHandler),
(r"^/index/$", handlers.main.IndexHandler),
(r"^/scan/$", handlers.main.ScanHandler),
(r"^/task/$", handlers.main.TaskHandler),
(r"^/vul/$", handlers.main.VulHandler),
(r"^/part/$", handlers.main.PartHandler),
(r"^/report/$", handlers.main.ReportHandler),
]
app = web.Application(url_patterns, **settings)
app.listen(port=options.port, address=options.address)
output.good("Web start at: http://%s:%s" % (options.address, options.port))
ioloop.IOLoop.current().start()
class CompareFilesHandler(tornado.web.RequestHandler):
loader = template.Loader('./web')
def post(self):
print "got request to compare files"
# get arguments
files_to_compare = self.get_argument('files', default=None)
num_selects = self.get_argument('num_selects', default=0)
if not files_to_compare:
data = json.dumps({'html': '<div> no files selected</div>'})
self.write(data)
return
files_to_compare = [i.strip() for i in files_to_compare.split(',')]
files_to_compare = [i for i in files_to_compare if i != '']
documents = []
for _file in files_to_compare:
files_with_prefix = glob.glob('uploads/%s' % _file)
if not files_with_prefix:
documents.append(file_not_found(_file))
continue
if not renderable_as_graph(_file):
documents.append(file_not_supported(_file))
continue
documents.append(file_supported(_file))
# generate images for them
for document in documents:
if not document['compatiable']:
document['image_link'] = '/images/not_found.jpg'
continue
images = map(os.path.basename, glob.glob('images/*.png'))
images = [i[:-4] for i in images]
name, ext = os.path.splitext(document['name'])
if name not in images:
# plotting it
plotter.plotter('uploads/%s' % document['name'],
'images/%s' % (name + '.png'))
document['image_link'] = '/images/%s' % (name + '.png')
operations = AVAILABLE_TRANSFORMATIONS
col_width = 90.0 / len(documents)
html = self.loader.load('compare.html').generate(
documents=documents,
operations=operations,
col_width=col_width,
num_selects=num_selects)
data = json.dumps({'html': html})
self.write(data)
def render_file(filename, args=None):
loader = template.Loader("templates/")
if args:
data = loader.load(filename).generate(**args)
else:
data = loader.load(filename).generate()
return data
def get_template(self, template_name):
"""
load the template with name.
"""
loader = template.Loader(self.get_lbconf_path)
t = loader.load(template_name)
return t
def print_way_bill(self):
sql = '''SELECT ID,HEADER,TOVAR,VALUME,PRICE,POINT POINT,DISCOUNT,KOEFF,PRICENDS,
SFMONEY,SMONEY,DMONEY,PRICEWNDS,SPOINT,KPACK,SPACK,SITOGOWNDS,NDS,SITOGO,
PLC,PNMB+P_NEW PNMB,RONMB RONMB,RONPP RONPP,KOMMB KOMMB,SPLC,SPNMB,CODE,NTOVAR,
WEIGHT,BUHPRICE,BUHSITOGOWNDS,NO_NDS,CTOVAR,sclad.GetPrice(wf.tovar,'R') pricer,
our_provider_price,price_kz
FROM tehno.W_Factura wf
WHERE Header = :pHeader
ORDER BY ntovar'''
result = Executor.exec_cls(sql, pHeader=self.head, multi=True)
total = sum(d.values["valume"] for d in result.data)
loader = template.Loader(TEMPLATE_DIR)
output = loader.load("waybill.html").generate(
data=result.data,
needre=self.needre,
header=self.header,
client_from=self.client_from,
client_to=self.client_to,
total=total)
output = output.replace('\n', '').replace('\r', '')
return {
'cmd':
'''self.Incunable(function(doc){ doc.write('%s') })''' % output
}
def write_ws_gateway_template(self, deposit):
template_loader = template.Loader(DEPOSIT_TEMPLATE_PATH)
deposit_data = deposit.get('Data')
t_loader = template_loader.load(deposit_data['html_template'])
deposit_html = t_loader.generate(**deposit_data).decode('utf-8')
self.write(deposit_html)
def post(self):
_id = self.get_argument("id")
title = self.get_argument("title", "")
content = self.get_argument("content", "")
users = get_vul_relate_users2(_id)
user_ids = [user.get("id") for user in users]
to = [user.get("email") for user in users if user.get("email")]
#if int(self.uid) not in user_ids:
# self.send_error(403, msg = "无权操作此漏洞")
# return
from logic.service import send_pack as service_async
settings = SystemSettings.get_or_none()
global_setting = json.loads(settings.global_setting)
vul = Vul.get_or_none(Vul._id == _id)
title = title or vul.vul_name
data = {"vul_name": vul.vul_name, \
"url": "{}/#/n_viewvulndetail?id={}".format(global_setting.get("domian"), vul._id), \
"title": title, \
"status": VUL_STATUS.get(str(vul.vul_status), ""), \
"content": content}
from tornado import template
loader = template.Loader("template")
text = loader.load("alert.html").generate(data = data)
service_async("service_email", {"msg": text, "to": to, "title": title})
self.write(dict(status = True, msg = '邮件已发送'))
def get(self):
loader = template.Loader(os.path.join(ROOT_DIR, 'warehouse'))
result = loader.load("print_party.js").generate(size=party_size)
self.write({
'def': [
{
'type': "button",
'text': 'Печать',
'img': "print.gif",
'imgdis': "print_dis.gif",
'action': 'do_tool_print_party'
},
{
'type': "button",
'text': 'Печать Подпартий',
'img': "print.gif",
'imgdis': "print_dis.gif",
'action': 'do_tool_print_extra_party'
},
],
'cmd':
result
})
def main():
debug_imports = bool(sys.argv[1]) if len(sys.argv) > 1 else False
print("Scanning for workflow files...")
list_workflows = scan_workflows(debug_imports)
print("Processing arguments...")
parser = CommandLineBase.init_parser(ignore_conflicts=True)
arguments = parser._actions
list_lines = [
obj[-1] for obj in sorted(
[convert_argument(*ia) for ia in enumerate(arguments)])
]
defaults = {}
html = ''.join(list_lines)
loader = template.Loader(os.path.join(WEB_FOLDER, "templates"))
opts, positional_opts, choices, defaults_opt = generate_opts(arguments)
path_to_out = os.path.join(WEB_FOLDER, "frontend.html")
print("Writing %s..." % path_to_out)
sout = loader.load("frontend.html").generate(
arguments=html,
workflows=list_workflows,
cmdline_states=json.dumps(defaults),
opts=json.dumps(opts),
positional_opts=json.dumps(positional_opts),
choices=json.dumps(choices),
defaults_opt=json.dumps(defaults_opt),
special_opts=json.dumps(CommandLineBase.SPECIAL_OPTS))
with open(path_to_out, "wb") as fout:
fout.write(sout)
return 0
def main():
parse_command_line()
client = AsyncHTTPClient(max_clients=100)
template_path = os.path.join(os.path.dirname(__file__), 'templates')
static_path = os.path.join(os.path.dirname(__file__), 'static')
template_loader_factory = lambda: template.Loader(template_path)
handlers = [
url(r'/$', RootHandler),
url(r'/logout$', LogoutHandler),
url(r'/submityelp$', SubmitYelpHandler),
url(r'/matchvenues$', MatchVenuesHandler),
url(r'%s$' % OAuthLoginHandler.URI, OAuthLoginHandler)
]
app = Application(
handlers,
debug=options.debug,
xsrf_cookies=False, # TODO
cookie_secret='deadb33fd00dc9234adeda42777',
template_path=template_path,
static_path=static_path,
memcache_client=memcache.Client([options.memcache_host], debug=0),
httpclient=client)
logging.info('starting on port %d' % options.port)
server = tornado.httpserver.HTTPServer(app)
server.listen(options.port)
tornado.ioloop.IOLoop.instance().start()
def get(self):
person = Person("Fe", date(1989, 2, 21))
loader = template.Loader("templates")
t = loader.load("person.html")
html = t.generate(name=person.name, days=person.days())
self.write(html)
def get(self):
conn = pymysql.connect(host='10.40.103.211',
port=9380,
user='******',
password='******',
db='QueryAnalyzer',
charset='utf8')
curs = conn.cursor(pymysql.cursors.DictCursor)
getHostSql = "select * from Hosts"
curs.execute(getHostSql)
hosts = curs.fetchall()
getKeywordSql = "select * from Keywords"
curs.execute(getKeywordSql)
keywords = curs.fetchall()
getResultSql = "select * from Results"
curs.execute(getResultSql)
results = curs.fetchall()
result = {}
loader = template.Loader("%s/static/template" % PWD)
self.write(
loader.load("compareResult.html").generate(o=result,
hosts=hosts,
keywords=keywords,
results=results))
print "getting compare data success"
conn.close()
def __init__(self, file_cacher):
super(PrintingExecutor, self).__init__()
self.file_cacher = file_cacher
template_dir = os.path.join(os.path.dirname(__file__),
"templates", "printing")
self.template_loader = template.Loader(template_dir, autoescape=None)
def get(self):
loader = template.Loader(os.path.join(ROOT_DIR, 'btk'))
out = self.cursor.var(cx_Oracle.CURSOR)
res = self.proc("shiva.Get_Iq_Status", [2, out])
all_status = fetchall_by_name(res[-1])
result = loader.load("btkconfirmin.js").generate(all_status=all_status)
self.write({
'def': [{
'type': "button",
'enabled': 'false',
'text': 'Печать',
'img': "print.gif",
'imgdis': "print_dis.gif",
'id': 'id_print',
'action': 'do_print'
}, {
'type': "button",
'text': 'Подтвердить',
'id': 'id_confirm',
'action': 'do_confirm'
}],
'cmd':
result
})
def run(self):
self.tord_static_path = os.path.join(
os.path.join(os.path.dirname(os.path.realpath(__file__)),
'static'), 'tord')
self.template = template.Loader(os.path.abspath(self.templates_dir))
settings.pubsub['klass'] = import_path(
'async_pubsub.%s_pubsub.%sPubSub' %
(self.pubsub_klass.lower(), self.pubsub_klass))
settings.pubsub['opts'] = self.pubsub_opts
self._add_http_route('%s/(.*)' % self.static_path,
web.StaticFileHandler,
{'path': os.path.abspath(self.static_dir)}, True)
self._add_http_route('%s/tord/(.*)' % self.static_path,
web.StaticFileHandler,
{'path': self.tord_static_path}, True)
self.app = web.Application(
SockJSRouter(WebSocketHandler, self.ws_path).urls +
settings.routes['http'],
debug=self.debug)
self.app.listen(self.port)
logger.info('Listening on port %s ...' % self.port)
try:
ioloop.IOLoop.instance().start()
except KeyboardInterrupt:
pass
finally:
logger.info('Shutting down ...')
def generate_auth(model_type, appname=None):
"""
generates a small handler
"""
#
# set some attributes
#
loader = template.Loader(cfg.templates["stubs_path"])
handler_class_name = camel_case(handler_name)
print(40 * "-")
print(" generating Authentication: " + handler_class_name)
print(40 * "-")
#
# create the Model
#
print("...generating model: type: " + model_type)
import medium.generate_model as gm
import os.path
ret = gm.generate_model("pow_user", model_type=None, appname=appname)
assert ret is True
#
# create the Auth class
#
print("... created: " + ofile_name)
print(40 * "-")
return
def generate_scaffold(handler_name, appname={{appname}}):
"""
generates the plain html view scaffolding
"""
loader = template.Loader(cfg.templates["stubs_path"])
handler_class_name = camel_case(handler_name)
#
# generate the scaffolding
#
#rest_methods = ["show", "list", "page", "new", "create", "edit", "update", "destroy"]
views = ["show", "list", "page"]
for view in views:
template_file = "scaffold_" + view + "_view.tmpl"
ofile_name = os.path.join(cfg.templates["view_path"], handler_name + "_" + view ".tmpl")
ofile = open(ofile_name, "wb")
res = loader.load(template_file).generate(
handler_name=handler_name,
handler_class_name=handler_class_name,
appname=appname
)
ofile.write(res)
ofile.close()
print("... created view: " + ofile_name)
return
def make_app():
uris = [(r"/", CaptchaBotHandler)]
app_settings = {
"template_loader": template.Loader("templates"),
"static_path": "static"
}
return web.Application(uris, **app_settings)
