def send_auth_captcha(identity):
"""Send authentication captcha to an identity, the identity can be a cellphone or an email.
"""
if not identity:
raise Exception('Identity is not provided.')
if CELLPHONE_PATTERN.match(identity):
user = User.objects.get(cellphone=identity, cellphoneBindingCaptcha__exists=False, status=1)
now = datetime.now()
user.cellphoneAuthCaptcha = Captcha(captcha=str(random())[2:8],
expireTime=datetime.fromtimestamp(now.timestamp() + 30 * 60))
user.updateTime = now
user = user.save()
template = Loader('templates/account/').load('cellphone_auth_captcha.txt')
content = template.generate(captcha=user.cellphoneAuthCaptcha.captcha)
send_sms(user.cellphone, content.decode('utf-8'))
return user
elif EMAIL_PATTERN.match(identity):
user = User.objects.get(email=identity, emailBindingCaptcha__exists=False, status=1)
now = datetime.now()
user.emailAuthCaptcha = Captcha(captcha=md5((str(random())[2:]).encode('utf-8')).hexdigest(),
expireTime=datetime.fromtimestamp(now.timestamp() + 24 * 60 * 60))
user.updateTime = now
user = user.save()
template = Loader('templates/account/').load('email_auth_captcha.html')
content = template.generate(captcha=user.emailAuthCaptcha.captcha)
send_mail([user.email], '身份验证', content.decode('utf-8'))
return user
else:
raise Exception('Invalid identity.')
def async_callback(self, async_result):
"""
Callback executed once the function called by run_background() returns
something, async_result single arg must be an HTMLAsyncResult instance.
This callback is in charge to render the final HTML content returned to the client.
"""
if not isinstance(async_result, HTMLAsyncResult):
self.finish()
return
if async_result.secure_cookie != None and 'name' in async_result.secure_cookie and 'content' in async_result.secure_cookie:
self.set_secure_cookie(async_result.secure_cookie['name'], async_result.secure_cookie['content'], expires_days=0.5)
if async_result.http_code in (301, 302, 401) and async_result.redirection is not None:
self.set_secure_cookie('referer_uri', self.request.uri, expires_days=0.5)
self.redirect(async_result.redirection)
return
if async_result.http_code == 200:
if async_result.template_path is not None:
self.loader = Loader(async_result.template_path)
self.write(self.loader.load(async_result.template_file).generate(**async_result.data))
self.finish()
return
else:
self.render(async_result.template_file, **async_result.data)
return
else:
self.render(async_result.template_file, **async_result.data)
return
def get(self, *args, **kwargs):
"""
provide details of cpu and memory usage
"""
context = {
'cpu': {
'user': psutil.cpu_times_percent().user,
'system': psutil.cpu_times_percent().system,
'idle': psutil.cpu_times_percent().idle,
'iowait': psutil.cpu_times_percent().iowait,
'usage': psutil.cpu_percent()
},
'memory': {
'percent': psutil.virtual_memory().percent,
'total': psutil.virtual_memory().total,
'available': psutil.virtual_memory().available,
'used': psutil.virtual_memory().used,
'free': psutil.virtual_memory().free,
'cached': psutil.virtual_memory().cached
}
}
templateRoot = options.TEMPLATE_ROOT
loader = Loader(templateRoot)
templateName = 'stats.html'
response = loader.load(templateName).generate(**context)
self.write(response)
self.finish()
def _do_send(self, params, to, subject, template_name):
# Create message container - the correct MIME type is multipart/alternative.
msg = MIMEMultipart('alternative')
msg['Subject'] = subject
msg['From'] = self.config['from'].encode('utf-8', 'ignore')
msg['To'] = to
# Create the body of the message (a plain-text and an HTML version).
loader = Loader('./templates/mail')
text = loader.load(template_name + '.txt').generate(**params)
html = loader.load(template_name + '.html').generate(**params)
# Record the MIME types of both parts - text/plain and text/html.
part1 = MIMEText(text, 'plain')
part2 = MIMEText(html, 'html')
# Attach parts into message container.
# According to RFC 2046, the last part of a multipart message, in this case
# the HTML message, is best and preferred.
msg.attach(part1)
msg.attach(part2)
# sendmail function takes 3 arguments: sender's address, recipient's address
# and message to send - here it is sent as one string.
if self.config['dummy']:
self.logger.warning(
'WARNING: Not sending e-mail to {0}, subj: {1}'.format(
msg['To'], subject))
else:
s = smtplib.SMTP(host=self.config['host'].encode(
'utf-8', 'ignore'),
port=self.config['port'])
s.starttls()
s.login(self.config['login'].encode('utf-8', 'ignore'),
self.config['password'].encode('utf-8', 'ignore'))
s.sendmail(msg['From'], [msg['To'], msg['From']], msg.as_string())
s.quit()
def get(self, path):
# Caching strategy.
# 1. If we don't have a version parameter, redirect
curVersion = self.get_version()
try:
version = url_escape(self.get_argument('v'))
except web.MissingArgumentError:
uri = self.request.uri
uri += '&' if self.request.query else '?'
uri += 'v=%s' % curVersion
self.redirect(uri)
return
# 2. Make sure version is correct
if IMAGE_VERSION is not None and version != curVersion:
uri = self.request.uri.replace('v=%s' % version, 'v=%s' % curVersion)
self.redirect(uri)
return
if not path:
path = 'index.html'
loader = Loader(HTML_DIR)
section = path.split('.')[0]
try:
context = getattr(self, section)()
except AttributeError:
context = {}
context['cloud_url'] = CLOUD_HTTP_ADDRESS
context['bufferSize'] = get_jack_buffer_size()
context['sampleRate'] = get_jack_sample_rate()
self.write(loader.load(path).generate(**context))
def __init__(self):
self.requester = None
self.Init = False
self.Loader = Loader(POUTPUT_TEMPLATES_DIR)
self.mNumLinesToShow = 15
self.CounterList = []
self.requester = requester
def get(self):
loader = Loader("./")
bl = db.getAvailableBanksWithMark()
t = util.getFetchedTime()
self.write(
loader.load("index.html").generate(availableBanks=bl,
fetchedTime=t))
def write_error(self, status_code, **kwargs):
if status_code in (404, 500):
error_page = '{}.html'.format(status_code)
if isfile(join(site_dir, error_page)):
self.write(Loader(site_dir).load(error_page).generate())
else:
super().write_error(status_code, **kwargs)
def render_template(self, tpl, context):
try:
path, tpl = tpl.rsplit('/', 1)
except ValueError:
path = ''
path = os.path.join(settings.TEMPLATE_PATH, 'social', path)
return Loader(path).load(tpl).generate(**context)
def users_added_callback(self, users):
'''
Server url will be dynamic to work same code on different servers
in case on user enrollment and iOS profile generation also.
'''
loader = Loader("/opt/toppatch/mv/media/app/")
server_url = environ.get('SERVER_CNAME')
ses_conn = ses.connect_to_region(
'us-east-1',
aws_access_key_id=environ.get('AWS_SES_ACCESS_KEY_ID'),
aws_secret_access_key=environ.get('AWS_SES_SECRET_ACCESS_KEY'))
for user in users:
link = str(server_url) + '/enroll/' + \
str(user.get('enrollment_id'))
message = loader.load('user_enroll_mail.html').generate(
company_name=user.get('company_name'),
user_passwd=user.get('passcode'), activation_link=link)
try:
ses_conn.send_email('*****@*****.**',
'MDM Enrollment verification', message,
[user['email']], format='html')
except Exception as err:
print repr(err)
def homepage(biothings, args):
loader = Loader(templates.__path__[0])
template = loader.load("home.html")
return template.generate(alert='Front Page Not Configured.',
title='Biothings API',
contents=biothings.handlers.keys(),
support=biothings.metadata.types,
url='http://biothings.io/')
def __init__(self):
super(SMTP,
self).__init(host=opts.smtp_host,
ports=opts.smtp_port,
username=opts.smtp_username,
password=opts.smtp_password,
use_tls=smtp_use_tls,
template_loader=Loader(opts.email_template_path))
def __init__(self, **kwargs):
mandatory_args = ["username", "password", "host", "port"]
for x in mandatory_args:
if kwargs.get(x, False) == False:
raise ValueError("%s must be provided" % (x))
self.__dict__[x] = kwargs[x]
loader = Loader("templates/email")
self.EMAIL_HTML_TEMPLATE = loader.load("document_send_email.html")
async def get(self):
reference = self.get_argument('reference', None)
#if not reference: send error page
feedbacks = await FeedbackService.get_all_feedback(reference)
loader = Loader(self.get_template_path())
self.write(
loader.load('feedback_table.html').generate(feedbacks=feedbacks,
reference=reference))
def get(self, username):
user = session.query(User).filter(User.username == username).first()
token = user.generate_confirmation_token()
message = Loader('templates').load('mail_template.html').generate(
title="Tornado-blog", username=username, content=token)
send_email(msg_to=user.email, message=message)
self.render('login.html',
message='A new email has been sent to you email-address!')
def generate_credentials():
loader = Loader("static/auth")
my_cred_file = loader.load("google_secret_format.txt")
result = my_cred_file.generate().decode("utf-8") % (
conf.GOOGLE_CLIENT_ID, conf.GOOGLE_PROJECT_ID,
conf.GOOGLE_CLIENT_SECRET, conf.BASE_URL + "/docs/")
with open(conf.CLIENT_SECRETS_FILE, "w") as cred_json:
cred_json.write(result)
def add_dir(self, template_dir):
"""Add new template directory to loader
:param template_dir: str of template directory.
:return:
"""
if template_dir in self._loaders:
return
self._loaders[template_dir] = Loader(template_dir)
def run(self):
# log = Logger('ActivationWorkerThread')
# TAG = 'run'
print 'ActivationWorkerThread'
### load html file for rendering ####
loader = Loader("/opt/toppatch/mv/media/app/")
t_status = 'alert-danger'
if self.hash_url:
salt_key = environ.get('salt_key')
json_url_key = environ.get('json_url_key')
danger_signer = TimedJSONWebSignatureSerializer(json_url_key)
try:
data_dict = danger_signer.loads(self.hash_url, salt=salt_key)
company_data = data_dict.get('cmd_hash')
admin_data = data_dict.get('adm_hash')
if company_data and admin_data:
admin = LoginDBHelper()
company_id = company_data
admin_id = admin_data
status = admin.set_login(admin_id, company_id)
if status:
message = '''Success! Please visit \
https://demo-mdm.toppatch.com and login using your admin \
email as username and password used at the time of \
Registration.
'''
message = message.replace(' ', '')
t_status = 'alert-success'
else:
message = "Mr. Intruder U r failed in this attemps.!!!"
else:
message = "Mr. Intruder U r failed in this attemps.!!!"
except SignatureExpired:
message = 'Sorry! This link was already expired'
except BadSignature:
message = '''Thanks for visiting . Please try agian after \
some time to activate the link sent to you.'''
else:
message = 'Sorry! This link was already expired'
self.request.write(loader.load("error_invalid.html").generate(
message=message, status=t_status))
tornado.ioloop.IOLoop.instance().add_callback(self.callback)
def __create_handler__(self, handler_name):
loader = Loader(os.path.join(os.getcwd(), "templates", "bake"))
temp_file = open(
os.path.join(self.project_helper.get_handler_folder(),
handler_name + self.HANDLER_QUALIFIER + '.py'), 'w')
temp_file.write(
loader.load("base_handler.plate").generate(
handler_name=handler_name))
temp_file.close()
logging.debug("[*] Finished generating " + temp_file.name)
def generate_string(self, file_template, template_values, file_values):
loader = Loader(os.path.join(os.getcwd(), 'templates'))
ret = loader.load(file_template, parent_path='./')
try:
content = ret.generate().replace(template_values, file_values)
except TypeError:
logging.error("template_values or file_values is not bytes.")
pass
else:
return content
def generate_export_file(self, job_id):
main_info = yield self.job_dao.query_job_base_info(job_id)
if main_info['status'] not in [
type_define.STATUS_JOB_REJECTED,
type_define.STATUS_JOB_COMPLETED
]:
self.finish_with_error(error_codes.EC_SYS_ERROR, '%s未归档')
filename = 'job_%s_%s.html' % (job_id,
main_info['title'].decode('utf-8'))
dir_path = 'res/download/job_export'
net_path = self.get_res_file_path(filename, dir_path)
file_path = self.get_res_file_path(filename, dir_path, True)
if os.path.isfile(file_path):
raise gen.Return([net_path, file_path, filename])
status_map = {
type_define.STATUS_JOB_PROCESSING: '处理中',
type_define.STATUS_JOB_COMPLETED: '已完成',
type_define.STATUS_JOB_CANCEL: '已撤回',
type_define.STATUS_JOB_REJECTED: '未通过',
}
main_info['status'] = status_map[main_info['status']]
branch_id = self.get_argument('branch_id', None)
node_list = yield self.job_dao.query_job_node_list(job_id, branch_id)
for item in node_list:
attachment_type = [
[
'has_attachment', type_define.TYPE_JOB_ATTACHMENT_NORMAL,
'attachment'
],
[
'has_img', type_define.TYPE_JOB_ATTACHMENT_IMG,
'img_attachment'
],
]
for _type in attachment_type:
if item[_type[0]]:
attachment = yield self.job_dao.query_node_attachment_list(
item['id'], _type[1])
item[_type[2]] = attachment
content = self.abstract_job_content(item['content'])
content = self.html_to_text(content)
item['content'] = content
if node_list[0]['rec_set']:
rec_set = yield self.job_dao.query_uid_set(node_list[0]['rec_set'])
else:
rec_set = None
loader = Loader(self.get_template_path(), autoescape=None)
result = loader.load('base_job_export.html').generate(
rec_set=rec_set,
main_info=main_info,
node_list=node_list,
)
fid = codecs.open(file_path, 'w', encoding='utf-8')
fid.write(result.decode('utf-8'))
raise gen.Return([net_path, file_path, filename])
def __init__(self):
super(SMTP, self).__init__(host=opts.smtp_host,
port=opts.smtp_port,
username=opts.smtp_username,
password=opts.smtp_password,
use_tls=opts.smtp_use_tls,
template_loader=Loader(
os.path.join(opts.themes_directory,
opts.selected_theme,
'messages')),
url=opts.base_url)
def render_template(template_name, **kwargs):
global template_loader
if template_loader is None or True:
# XXX: enable template caching
template_loader = Loader('templates')
return template_loader.load(template_name).generate(
**kwargs,
lc = lc.get_dict(),
conf = conf.configuration,
comp = competition,
)
def registration(self):
print("ConfReg:", self.request.data)
if "t" not in self.request.data:
raise Exception("There is no token in request")
confirm_data_table = Confirm_Data()
confirm = confirm_data_table.get_data_by_token(self.request.data["t"])
if confirm is None:
raise Exception("Confirm registration token not find")
print("RegData:", )
loader = Loader("templates")
return loader.load("base.html").generate()
class TemplateHandler(RequestHandler):
etc_loader = Loader(args.etcdir)
admin_loader = Loader(args.admindir)
def initialize(self, path=None):
# GuiServerPart passes this in, so handle it
pass
def get_template_path(self):
# Return the directory we put our templated index.html in
return args.templatedir
def get(self, path):
if path == "details":
# /details/... shouldn't have bottom nav
self.render("withoutnav.html")
else:
# /gui/... should have index.html, templated with nav
self.render("index.html", etc_loader=self.etc_loader,
admin_loader=self.admin_loader)
async def get(self):
handlers = []
for x in self.application.handlers_api:
# FIXME
url = x.reverse().replace('?', '')
handlers.append({'name': x.name, 'url': url})
if handlers:
handlers = sorted(handlers, key=lambda k: k['name'])
loader = Loader('politicos_api/templates')
content = loader.load('routes.html').generate(handlers=handlers)
await self.write(content)
def create_files(self):
self.loader = Loader(os.path.join(os.getcwd(), "templates"))
for template, file_name in self.templates:
temp_file = open(
os.path.join(os.getcwd(), self.project_name, file_name), 'w')
temp_file.write(
self.loader.load(template + ".plate").generate(
project_name=self.project_name))
temp_file.close()
logging.debug("[*] Finished generating " + template + " Template!")
def write_page(response, new_name, new_width, new_height, new_max_players,
new_error):
loader = Loader('templates/')
page = loader.load('newgame.html').generate(
app=App.instance,
name=new_name,
width=new_width,
height=new_height,
max_players=new_max_players,
error=new_error)
response.write(page)
def confirm_registration(self):
try:
print("ConfirmRegData:", self.request.data)
Confirm_Data.clear_expired_rows()
confirm_table = Confirm_Data()
loader = Loader("templates")
return loader.load("base.html").generate()
return "OK"
except Exception as e:
raise e
def get(self, data):
log = Logger('CheckInHandler Get')
tag = 'Profile get method'
user_agent = self.request.headers['User-Agent']
if 'iPad' in user_agent or 'iPhone OS' in user_agent:
loader = Loader("/opt/toppatch/mv/media/app/")
self.write(
loader.load("enroll_form.html").generate(
temp_enroll=data))
elif 'Android' in user_agent:
self.redirect('/android_profile.apk')
log.i(tag, 'Downloading the Android APK')
else:
log.i(tag, 'Incorrect browser used in passverify')
loader = Loader("/opt/toppatch/mv/media/app/")
self.write(loader.load("error_invalid.html").generate(
message='Please use Android or iOS device to open this link',
status='alert-danger'))
