def get(self): auth_level = self.is_user_authorized() if auth_level == models.AUTH_LEVEL_REGISTERED_USER: self.redirect("/account/activate/reminder/") elif auth_level == models.AUTH_LEVEL_ACTIVATED_USER: today = datetime.utcnow() year = self.request.get("year") month = self.request.get("month") if not year or not month: year = today.year month = today.month else: year = dec(year) month = dec(month) articles = Article.get_all_published_student_articles_for_month(year, month) books = Book.get_latest(count=10) response = render_template( "blog_students.html", year_list=models.BLOG_YEAR_LIST, month_list=models.MONTH_LIST, today=today, requested_year=year, requested_month=month, articles=articles, books=books, ) self.response.out.write(response) else: response = render_template("index.html") self.response.out.write(response)
def index(request): if tokens_p(request): # get the realname here. we already have it in the js account model api = get_api() account_id = urllib.unquote(request.session['oauth_token_set']['account_id']) try: res = api.account_info(account_id = account_id) except: res = None # got account info from the server if res and res.response: if 200 == res.response.get('response_status', 0): e = ET.fromstring(res.response.get('response_data', '<xml/>')) fullname = e.findtext('fullName') return utils.render_template('ui/index', { 'ACCOUNT_ID': account_id, 'FULLNAME': fullname, 'ALLOW_ADDING_RECORDS': settings.ALLOW_ADDING_RECORDS, 'HIDE_GET_MORE_APPS': settings.HIDE_GET_MORE_APPS, 'HIDE_SHARING': settings.HIDE_SHARING }) # error return_url = request.session.get('return_url', '/') err_msg = res.response.get('response_data', '500: Unknown Error') return utils.render_template(LOGIN_PAGE, {'ERROR': ErrorStr(err_msg), 'RETURN_URL': return_url, 'SETTINGS': settings}) return HttpResponseRedirect(reverse(login))
def POST(self, key): i = web.input(v=None, _method="GET") if spamcheck.is_spam(): return render_template("message.html", "Oops", 'Something went wrong. Please try again later.') recap = get_recaptcha() if recap and not recap.validate(): return render_template("message.html", 'Recaptcha solution was incorrect', 'Please <a href="javascript:history.back()">go back</a> and try again.' ) v = i.v and safeint(i.v, None) work = web.ctx.site.get(key, v) if work is None: raise web.notfound() try: helper = SaveBookHelper(work, None) helper.save(web.input()) add_flash_message("info", utils.get_message("flash_work_updated")) raise web.seeother(work.url()) except (ClientException, ValidationException) as e: add_flash_message('error', str(e)) return self.GET(key)
def register(request): """ http://localhost/change_password Returns the register template (GET) or creates a new account (POST) """ if HTTP_METHOD_POST == request.method: if not settings.REGISTRATION.get('enable', False): return utils.render_template('ui/error', {'error_message': ErrorStr('Registration disabled'), 'error_status': 403}) # create the account post = request.POST set_primary = settings.REGISTRATION.get('set_primary_secret', 1) user_hash = {'account_id': post.get('account_id'), 'contact_email': post.get('account_id'), # TODO:the contact_email key is not present in the register form for now, so use the account_id 'full_name': post.get('full_name'), 'primary_secret_p': set_primary, 'secondary_secret_p': settings.REGISTRATION.get('set_secondary_secret', 1)} api = get_api() res, content = api.account_create(body=user_hash) # on success, forward to page according to the secrets that were or were not generated if '200' == res['status']: account_xml = content or '<root/>' account = utils.parse_account_xml(account_xml) account_id = account.get('id') if not set_primary: return utils.render_template(LOGIN_PAGE, {'MESSAGE': _('You have successfully registered.') + ' ' + _('After an administrator has approved your account you may login.'), 'SETTINGS': settings}) # display the secondary secret if there is one has_secondary_secret = (None != account.get('secret') and len(account.get('secret')) > 0) if has_secondary_secret: return utils.render_template('ui/register', {'SETTINGS': settings, 'ACCOUNT_ID': account_id, 'SECONDARY': account.get('secret'), 'MESSAGE': _('You have successfully registered.') + ' ' + _('At the link sent to your email address, enter the following activation code:')}) return HttpResponseRedirect('/accounts/%s/send_secret/sent' % account_id) return utils.render_template('ui/register', {'ERROR': ErrorStr((content or 'Setup failed')), 'SETTINGS': settings}) return utils.render_template('ui/register', {'SETTINGS': settings})
def GET(self, key): if not is_admin(): return render_template('permission_denied', web.ctx.path, "Permission denied.") edition = web.ctx.site.get(key) if not edition: raise web.notfound() if edition.ocaid: ebook_key = "ebooks/" + edition.ocaid ebook = web.ctx.site.store.get(ebook_key) or {} else: ebook = None i = web.input(updatestatus=None) if i.updatestatus == 't': edition.update_loan_status() edition_loans = get_edition_loans(edition) user_loans = [] user = accounts.get_current_user() if user: user_loans = get_loans(user) return render_template("borrow_admin", edition, edition_loans, ebook, user_loans, web.ctx.ip)
def create_developer_account(request): if request.method == "GET": return utils.render_template('ui/create_developer_account', {}) api = get_api() username = request.POST.get("username") password = request.POST.get("password") given_name = request.POST.get("given_name") family_name = request.POST.get("family_name") department = request.POST.get("department") role = request.POST.get("role") data = {"account_id" : username, "password" : password, "given_name" : given_name, "family_name" : family_name, "department": department, "role" : role} ret = api.call("POST", "/users/", options={'data': data}) if (ret == "account_exists"): return utils.render_template('ui/create_developer_account', { 'error': "Account '%s' is already registered."%username }) return utils.render_template(LOGIN_PAGE, {"error": "Account %s has been created. Please log in."%username, "account" : username } )
def account_initialization_2(request): if request.method == HTTP_METHOD_POST: account_id = request.path_info.split('/')[3] username = request.POST['username'].lower().strip() password = request.POST['pw1'] errors = { 'generic': 'There was a problem updating your data. Please try again. If you are unable to change your password please contact support.', 'collision': 'That username is already taken. Please enter different one.' } api = IndivoClient(settings.CONSUMER_KEY, settings.CONSUMER_SECRET, settings.INDIVO_SERVER_LOCATION) ret = api.add_auth_system( account_id = account_id, data = {'system':'password', 'username': username, 'password': password}) if ret.response['response_status'] == 200: # everything's OK, log this person in, hard redirect to change location tokens_get_from_server(request, username, password) return HttpResponseRedirect('/') elif ret.response['response_status'] == 400: return utils.render_template('ui/account_init_2', {'ERROR': errors['collision']}) else: return utils.render_template('ui/account_init_2', {'ERROR': errors['generic']}) else: return utils.render_template('ui/account_init_2', {})
def get(self): tweets = models.Tweet.all().search(self.request.get("q")).order('-created_at').fetch(1000) template_values = { "tweets": tweets, "searchterm": self.request.get("q") } utils.render_template(self, "views/search.html", template_values)
def get(self, path): if not path.startswith(config.url_prefix): if path not in ROOT_ONLY_FILES: self.error(404) self.response.out.write(utils.render_template('404.html')) return else: if config.url_prefix != '': path = path[len(config.url_prefix):]# Strip off prefix if path in ROOT_ONLY_FILES:# This lives at root self.error(404) self.response.out.write(utils.render_template('404.html')) return content = get(path) if not content: self.error(404) self.response.out.write(utils.render_template('404.html')) return serve = True if 'If-Modified-Since' in self.request.headers: try: last_seen = datetime.datetime.strptime( self.request.headers['If-Modified-Since'].split(';')[0],# IE8 '; length=XXXX' as extra arg bug HTTP_DATE_FMT) if last_seen >= content.last_modified.replace(microsecond=0): serve = False except ValueError, e: import logging logging.error('StaticContentHandler in static.py, ValueError:' + self.request.headers['If-Modified-Since'])
def get(self): from pickle import dumps from ebs.merchant.api import get_ebs_request_parameters dr = self.request.get('DR') if dr: billing_settings = BillingSettings.get_settings(deployment_mode=ebs_mode) request = get_ebs_request_parameters(dr, billing_settings.secret_key) response_code = request.get('ResponseCode', None) response_message = request.get('ResponseMessage', 'There was no response from the billing system.') group = self.session.get('participant_group') group.transaction_response_id = str(request.get('PaymentID')) group.transaction_response_code = str(response_code) group.transaction_response_message = response_message group.transaction_response_type = TRANSACTION_TYPE_EBS group.transaction_response_amount = request.get('Amount', '0') group.transaction_response = str(request) group.transaction_response_object = db.Blob(dumps(request)) group.when_transaction_response_occurred = request.get('DateCreated') group.put() if response_code == 0: # mark the participant group as paid. message_title = 'Thank you for participating in the summit' group_id = group.key().id() logging.info('Payments for group: %s with %d processed.' % (group.title, group_id)) participants = self.session.get('participants') if participants: # Send email to all the participants about their attendance. for participant in participants: queue_mail_task(url='/worker/mail/thanks/registration/', params=dict( full_name=participant.full_name, email = participant.email, key=str(participant.key()) ), method='POST' ) # Send email to the payer the invoice. primary_participant = self.session.get('primary_participant') queue_mail_task(url='/worker/mail/thanks/registration_payment/', params=dict( full_name=primary_participant.full_name, email = primary_participant.email, key=str(primary_participant.key()), transaction_amount=group.transaction_response_amount ), method='POST' ) else: message_title = 'There was an error processing your payment.' response = render_template('thank_you.html', message_title=message_title, message_body=response_message + ''' Thank you for registering for the summit. An email confirming your payment and registration shall be sent to you shortly. In case you don't receive the email confirmation within 24 hours or you have any queries, please contact +91 22 66301060 / 22026166 from 10.30 AM IST to 6.30 AM IST''') else: response = render_template('thank_you.html', message_title="A problem occurred with the billing system.", message_body="We did not receive a proper response from the billing system.") self.response.out.write(response)
def generate_local_dockerfile(): loginfo('Generating local Dockerfile ...') context = { 'seafile_version': seafile_version, 'https': is_https(), 'domain': get_conf('server.domain'), } render_template('/templates/Dockerfile.template', join(generated_dir, 'Dockerfile'), context)
def GET(self, key): if not web.ctx.site.can_write(key): return render_template("permission_denied", web.ctx.fullpath, "Permission denied to edit " + key + ".") author = web.ctx.site.get(key) if author is None: raise web.notfound() return render_template("type/author/edit", author)
def token_login_index(request, token): request.session.flush() api = get_api() reqstore = request.GET if (request.method == 'POST'): reqstore = request.POST initial_app= reqstore.get('initial_app', "") options = {'data': {'token':token}} pin= reqstore.get('pin', "") if pin: options['data']['pin'] = pin logintokenxml = api.call("GET", "/session/from_direct_url", options=options) if logintokenxml.startswith("Permission Denied"): return utils.render_template("ui/need_pin",{}) logintoken= ET.fromstring(logintokenxml) record_id = logintoken.find("Record").get("id") record_name = logintoken.find("Record").get("label") session_tokens = dict(urlparse.parse_qsl(logintoken.get("value"))) account_id = session_tokens['account_id'] request.session['oauth_token_set'] = session_tokens request.session['account_id'] = urllib.unquote(account_id) api = get_api(request) account_id = urllib.unquote(request.session['oauth_token_set']['account_id']) ret = api.account_info(account_id = account_id) e = ET.fromstring(ret.response['response_data']) fullname = e.findtext('givenName') +" "+ e.findtext('familyName') target_template = "ui/proxy_index" credentials = "''" manifest = "''" if (initial_app != ""): target_template = "ui/single_app_view" credentials = single_app_get_credentials(api, account_id, initial_app, record_id) manifest = single_app_get_manifest(api, initial_app) return utils.render_template(target_template, { 'ACCOUNT_ID': session_tokens["account_id"], 'FULLNAME': fullname, 'PROXIED_RECORD_ID' : record_id, 'PROXIED_RECORD_NAME': record_name, 'INITIAL_APP': initial_app, 'SMART_PASSTHROUGH_SERVER': passthrough_server , 'CREDENTIALS': credentials, 'MANIFEST': manifest })
def launch_app(request, app_id): """ Entry point for a given app. If the app does not exist (or another exception occurrs), will render /ui/error with the given error message. On success, renders /ui/record_select after the user has logged in. Selecting a record will call the app's start_url. """ # make the user login first login_url = "%s?return_url=%s" % (reverse(login), urllib.quote(request.get_full_path())) account_id = urllib.unquote(request.session.get('account_id', '')) if not account_id: return HttpResponseRedirect(login_url) # logged in, get information about the desired app api = get_api() # gets the API with chrome credentials ret = api.get_app_info(app_id=app_id) res = ret.response if ret else {} status = res.get('response_status', 500) error_message = None if 404 == status: error_message = ErrorStr('No such App').str() elif 200 != status: error_message = ErrorStr(res.get('response_data', 'Error getting app info')).str() if error_message is not None: return utils.render_template('ui/error', {'error_message': error_message, 'error_status': status}) # success, find start URL template xml = res.get('response_data', '<root />') e = ET.fromstring(xml) start_url = e.findtext('startURLTemplate') # read account records api.update_token(request.session.get('oauth_token_set')) # must be in app-credential-mode now ret = api.read_records(account_id = account_id) res = ret.response if ret else {} status = res.get('response_status', 500) if 404 == status: error_message = ErrorStr('Unknown account').str() elif 403 == status: return HttpResponseRedirect(login_url) elif 200 != status: error_message = ErrorStr(res.get('response_data', 'Error getting account records')).str() if error_message: return utils.render_template('ui/error', {'error_message': error_message, 'error_status': status}) # parse records XML records_xml = res.get('response_data', '<root/>') records_extracted = [[r.get('id'), r.get('label')] for r in ET.fromstring(records_xml).findall('Record')] records = [] for rec_id, rec_label in records_extracted: rec_dict = { 'record_id': rec_id, 'carenet_id' : '' } # TODO: Carenets are not yet supported records.append([rec_id, rec_label, _interpolate_url_template(start_url, rec_dict)]) return utils.render_template('ui/record_select', {'SETTINGS': settings, 'APP_ID': app_id, 'RECORD_LIST': records})
def generate_local_nginx_conf(): # Now create the final nginx configuratin domain = get_conf('server.hostname') context = { 'https': is_https(), 'domain': domain, } render_template('/templates/seafile.nginx.conf.template', '/etc/nginx/sites-enabled/seafile.nginx.conf', context)
def generate_local_nginx_conf(): # Now create the final nginx configuratin domain = get_conf('SEAFILE_SERVER_HOSTNAME', 'seafile.example.com') context = { 'https': is_https(), 'domain': domain, } render_template('/templates/seafile.nginx.conf.template', '/etc/nginx/sites-enabled/seafile.nginx.conf', context)
def get(self): project_json = map(lambda x: x.as_json(include_relationships=True), self.auth.user.projects) task_json = map(lambda x: x.as_json(), self.auth.user.tasks); params = { 'courses': self.auth.user.courses, 'project_json': project_json, 'task_json': task_json } render_template(self, 'home.html', params)
def GET(self): if not self.has_permission(): return render_template("permission_denied", "/books/add", "Permission denied to add a book to Open Library.") i = web.input(work=None, author=None) work = i.work and web.ctx.site.get(i.work) author = i.author and web.ctx.site.get(i.author) return render_template('books/add', work=work, author=author, recaptcha=get_recaptcha())
def get(self, mode): tweets = models.Tweet.all().order('-created_at').fetch(10) template_values = { "tweets": tweets, "searchterm": self.request.get("q") } if mode == "panel": utils.render_template(self, "views/panel.html", template_values) else: utils.render_template(self, "views/live.html", template_values)
def consume(self, client, frame): ''' Consumes a frame from the queue ''' try: # get configuration mail_host = self.config['mail']['host'] # get parameters params = json.loads(frame.body.decode()) self.logger.debug(params) # call submit method of flask application # generates output file and self.logger.debug('processing input file: ' + params['file_id']) self.process_file(params['file_id'], params['model_version']) self.logger.debug('finished processing input file: ' + params['file_id']) # send user results self.logger.debug('sending results email to user') send_mail( host=mail_host, sender='SOCcer<*****@*****.**>', recipient=params['recipient'], subject='SOCcer - Your file has been processed', contents=render_template('templates/user_email.html', params) ) except Exception as e: # capture error information error_info = { 'file_id': params['file_id'], 'params': json.dumps(params, indent=4), 'exception_info': format_exc(), 'process_output': getattr(e, 'output', 'None') } self.logger.exception(error_info) # send user error email self.logger.debug('sending error email to user') send_mail( host=mail_host, sender='SOCcer<*****@*****.**>', recipient=params['recipient'], subject='SOCcer - An error occurred while processing your file', contents=render_template('templates/user_error_email.html', params) ) # send admin error email self.logger.debug('sending error email to administrator') send_mail( host=mail_host, sender='SOCcer<*****@*****.**>', recipient=self.config['mail']['admin'], subject='SOCcer - Exception occurred', contents=render_template('templates/admin_error_email.html', error_info) )
def render_kube_services(config): """overwrite config['kubelables'] if want to change node type for certain services""" """prepare /etc/kubernetes/kubelet.service for nodes by roles""" utils.render_template_directory("./services/", "./deploy/services/", config) config['labels'] = ["{{cnf['labels'] | join(',')}}"] for role in ["infra", "worker"]: utils.render_template( "template/cloud-config/{}.kubelet.service.template".format(role), "./deploy/cloud-config/{}.kubelet.service.template".format(role), config)
def render_restfulapi(config): if not os.path.exists("./deploy/RestfulAPI"): os.system("mkdir -p ./deploy/RestfulAPI") config = get_stat_of_sku(config) utils.render_template("./template/RestfulAPI/config.yaml", "./deploy/RestfulAPI/config.yaml", config) utils.render_template("./template/master/restapi-kubeconfig.yaml", "./deploy/master/restapi-kubeconfig.yaml", config) config["restapi"] = "http://{}:{}".format( config["kubernetes_master_node"][0], config["restfulapiport"]) return config
def POST(self): i = web.input(email='', irl='', comment='') fields = web.storage({ 'email': i.email, 'irl': i.irl, 'comment': i.comment, 'sent': datetime.datetime.utcnow(), }) msg = render_template('email/spam_report', fields) web.sendmail(config.from_address, config.report_spam_address, 'Open Library spam report', str(msg)) return render_template("contact/spam/sent")
def GET(self, key): i = web.input(v=None) v = i.v and safeint(i.v, None) if not web.ctx.site.can_write(key): return render_template("permission_denied", web.ctx.fullpath, "Permission denied to edit " + key + ".") edition = web.ctx.site.get(key, v) if edition is None: raise web.notfound() work = edition.works and edition.works[0] if not work: # HACK: create dummy work when work is not available to make edit form work work = web.ctx.site.new( '', { 'key': '', 'type': { 'key': '/type/work' }, 'title': edition.title, 'authors': [{ 'type': '/type/author_role', 'author': { 'key': a['key'] } } for a in edition.get('authors', [])] }) recap_plugin_active = is_plugin_enabled('recaptcha') #check to see if account is more than two years old old_user = False user = web.ctx.site.get_user() account = user and user.get_account() if account: create_dt = account.creation_time() now_dt = datetime.datetime.utcnow() delta = now_dt - create_dt if delta.days > 365 * 2: old_user = True if recap_plugin_active and not old_user: public_key = config.plugin_recaptcha.public_key private_key = config.plugin_recaptcha.private_key recap = recaptcha.Recaptcha(public_key, private_key) else: recap = None return render_template('books/edit', work, edition, recaptcha=recap)
def GET(self, key): i = web.input(v=None, _method="GET") v = i.v and safeint(i.v, None) if not web.ctx.site.can_write(key): return render_template("permission_denied", web.ctx.fullpath, "Permission denied to edit " + key + ".") work = web.ctx.site.get(key, v) if work is None: raise web.notfound() return render_template('books/edit', work)
def GET(self, key): i = web.input(v=None, _method="GET") v = i.v and safeint(i.v, None) if not web.ctx.site.can_write(key): return render_template("permission_denied", web.ctx.fullpath, "Permission denied to edit " + key + ".") work = web.ctx.site.get(key, v) if work is None: raise web.notfound() return render_template('books/edit', work, recaptcha=get_recaptcha())
def POST(self): data = web.input() print(data) param = {'username': data.username, 'password': data.password} ret = utils.db.users.find(param) print(ret.count()) flag = True if ret.count() > 0 else False print(flag) if flag: return utils.render_template('main.html', msg=u'密码正确', **data) else: return utils.render_template('login.html', msg=u'密码错误', **data)
def POST(self): data = web.input() print(data) param = {'username':data.username,'password':data.password} ret = utils.db.users.find(param) print(ret.count()) flag = True if ret.count()>0 else False print(flag) if flag: return utils.render_template('main.html',msg=u'密码正确',**data) else: return utils.render_template('login.html',msg=u'密码错误',**data)
def POST(self): i = web.input(email='', irl='', comment='') fields = web.storage({ 'email': i.email, 'irl': i.irl, 'comment': i.comment, 'sent': datetime.datetime.utcnow(), 'browser': web.ctx.env.get('HTTP_USER_AGENT', '') }) msg = render_template('email/spam_report', fields) web.sendmail(i.email, config.report_spam_address, msg.subject, str(msg)) return render_template("contact/spam/sent")
def generate_local_nginx_conf(): # Now create the final nginx configuratin domain = get_conf('server.hostname') context = { 'https': is_https(), 'domain': domain, } render_template( '/templates/seafile.nginx.conf.template', join(generated_dir, 'seafile.nginx.conf'), context )
def get(self, uid): users = models.User.all().order('-tweetcount') user = models.User.get_by_key_name("u_" + uid) tweets = models.Tweet.get(user.tweetlist) details = utils.get_user_details(user) template_values = { "users": users, "user": user, "tweets": tweets, "details": details } utils.render_template(self, "views/person.html", template_values)
def update_ecs_service(airflow_service): aws_account_id = get_aws_account_id() ecs_service = render_template( '{{ serviceName }}-{{ ENVIRONMENT }}-{airflow_service}').format( airflow_service=airflow_service) ecs_cluster = render_template( 'arn:aws:ecs:{{ AWS_REGION }}:{aws_account_id}:cluster/{{ serviceName }}-{{ ENVIRONMENT }}-ecs-cluster' ).format(aws_account_id=aws_account_id) logging.info(f'RESTARTING SERVICE: {ecs_service}') ecs_client.update_service(cluster=ecs_cluster, service=ecs_service, forceNewDeployment=True)
def login(request, info="", template=LOGIN_PAGE): """ clear tokens in session, show a login form, get tokens from indivo_server, then redirect to index FIXME: make note that account will be disabled after 3 failed logins!!! """ # generate a new session request.session.flush() # set up the template errors = { 'missing': 'Either the username or password is missing. Please try again', 'incorrect': 'Incorrect username or password. Please try again.', 'disabled': 'This account has been disabled/locked.' } FORM_USERNAME = '******' FORM_PASSWORD = '******' FORM_RETURN_URL = 'return_url' # process form vars if request.method == HTTP_METHOD_GET: return_url = request.GET.get(FORM_RETURN_URL, '/') if (return_url.strip() == ""): return_url = '/' template_data = {FORM_RETURN_URL: return_url} return utils.render_template(template, template_data) if request.method == HTTP_METHOD_POST: return_url = request.POST.get(FORM_RETURN_URL, '/') if (return_url.strip() == ""): return_url = '/' if request.POST.has_key(FORM_USERNAME) and request.POST.has_key( FORM_PASSWORD): username = request.POST[FORM_USERNAME] password = request.POST[FORM_PASSWORD] else: # Also checked initially in js return utils.render_template(template, { 'error': errors['missing'], FORM_RETURN_URL: return_url }) else: utils.log('error: bad http request method in login. redirecting to /') return HttpResponseRedirect('/') # get tokens from the backend server and save in this user's django session ret = tokens_get_from_server(request, username, password) if not ret: return utils.render_template(LOGIN_PAGE, { 'error': errors['incorrect'], FORM_RETURN_URL: return_url }) return HttpResponseRedirect(return_url)
def render_template_or_dir(config, args): nargs = args.nargs # no destination, then mirror one in ./deploy folder src = nargs[0] if len(nargs) == 1: dst = os.path.join("deploy", src.split("template/")[1]) else: dst = nargs[1] if os.path.isdir(src): utils.render_template_directory(src, dst, config) else: utils.render_template(src, dst, config)
def POST(self): i = web.input(title="", author_name="", author_key="", publisher="", publish_date="", id_name="", id_value="", _test="false") if spamcheck.is_spam(i): return render_template("message.html", "Oops", 'Something went wrong. Please try again later.') if not web.ctx.site.get_user(): recap = get_recaptcha() if recap and not recap.validate(): return render_template('message.html', 'Recaptcha solution was incorrect', 'Please <a href="javascript:history.back()">go back</a> and try again.' ) match = self.find_matches(i) saveutil = DocSaveHelper() if i.author_key == '__new__': if i._test != 'true': a = new_doc('/type/author', name=i.author_name) comment = utils.get_message('comment_new_author') # Save, but don't commit, new author. # It will be committed when the Edition is created below. saveutil.save(a) i.author_key = a.key # since new author is created it must be a new record match = None if i._test == 'true' and not isinstance(match, list): if match: return 'Matched <a href="%s">%s</a>' % (match.key, match.key) else: return 'No match found' if isinstance(match, list): # multiple matches return render_template('books/check', i, match) elif match and match.key.startswith('/books'): # work match and edition match, match is an Edition return self.work_edition_match(match) elif match and match.key.startswith('/works'): # work match but not edition work = match return self.work_match(saveutil, work, i) else: # no match return self.no_match(saveutil, i)
def render_for_worker_generic(config, args): # TODO: split into generic + specific node for options.env and worker-kubeconfig.yaml config["etcd_endpoints"] = "$ETCD_ENDPOINTS" orig_api_servers = config["api_servers"] if "api_servers" in config else '' config["api_servers"] = "$KUBE_API_SERVER" utils.render_template_directory("template/kubelet", "deploy/kubelet", config) utils.render_template("template/cloud-config/worker.upgrade.list", "./deploy/cloud-config/worker.upgrade.list", config) utils.render_template("template/cloud-config/worker_fallback.sh.template", "./deploy/cloud-config/worker_fallback.sh", config) if orig_api_servers: config["api_servers"] = orig_api_servers
def showcase_index(request): api = get_api() initial_app= request.GET.get('initial_app', "") ret = tokens_get_from_server(request, settings.PROXY_USER, settings.PROXY_PASSWORD) if not ret: return utils.render_template(LOGIN_PAGE, {'error': 'Could not find proxied user'}) return utils.render_template('ui/showcase', { 'ACCOUNT_ID': settings.PROXY_USER, 'INITIAL_APP': initial_app, 'SMART_PASSTHROUGH_SERVER': passthrough_server })
def generate_local_nginx_conf(): custom = get_conf('SEAFILE_SERVER_NGINX_CONF_CUSTOM', 'false') if custom: return # Now create the final nginx configuration domain = get_conf('SEAFILE_SERVER_HOSTNAME', 'seafile.example.com') context = { 'https': is_https(), 'domain': domain, } render_template('/templates/seafile.nginx.conf.template', '/etc/nginx/sites-enabled/seafile.nginx.conf', context)
def __call__(self, ctx, mgr): source = resolve(self.source, ctx) dest = resolve(self.dest, ctx) if self.mode: ldest = '_%s'%source render_template(source, ldest, ctx) put(ldest, ldest) run('sudo mv %s %s'%(ldest, dest)) run('sudo chmod %s %s'%(self.mode, dest)) if self.owner: run('sudo chown %s %s'%(self.owner, dest)) local('rm -f %s'%ldest) else: render_template(source, dest, ctx)
def get(self): course = self.params.course projects = self.auth.user.projects_for_course(course) project_json = map(lambda p: p.as_json(include_relationships=True), projects) tasks = self.auth.user.tasks_for_course(course) task_json = map(lambda t: t.as_json(), tasks) params = { 'course': course, 'project_json': project_json, 'course_key': course.key.urlsafe(), 'task_json': task_json } render_template(self, 'course.html', params)
def POST(self): i = web.input(title="", author_name="", author_key="", publisher="", publish_date="", id_name="", id_value="", _test="false") if spamcheck.is_spam(i): return render_template( "message.html", "Oops", 'Something went wrong. Please try again later.') recap_plugin_active = is_plugin_enabled('recaptcha') if recap_plugin_active and not web.ctx.site.get_user(): public_key = config.plugin_recaptcha.public_key private_key = config.plugin_recaptcha.private_key recap = recaptcha.Recaptcha(public_key, private_key) if not recap.validate(): return 'Recaptcha solution was incorrect. Please <a href="javascript:history.back()">go back</a> and try again.' saveutil = DocSaveHelper() match = self.find_matches(saveutil, i) if i._test == "true" and not isinstance(match, list): if match: return 'Matched <a href="%s">%s</a>' % (match.key, match.key) else: return 'No match found' if isinstance(match, list): # multiple matches return render_template("books/check", i, match) elif match and match.key.startswith('/books'): # work match and edition match return self.work_edition_match(match) elif match and match.key.startswith('/works'): # work match but not edition work = match return self.work_match(saveutil, work, i) else: # no match return self.no_match(saveutil, i)
def render_storagemanager(config, nodename): deploy_path = "./deploy/StorageManager/{}_storage_manager.yaml".format( nodename) utils.render_template("./template/StorageManager/config.yaml", deploy_path, config) with open("./deploy/cloud-config/file_map.yaml") as rf: file_map = yaml.safe_load(rf) file_map["{}_storage_manager".format(nodename)] = [{ "src": deploy_path, "dst": "/etc/StorageManager/config.yaml" }] with open("./deploy/cloud-config/file_map.yaml", "w") as wf: yaml.dump(file_map, wf)
def generate_local_nginx_conf(): # Now create the final nginx configuratin domain = get_conf('SEAFILE_SERVER_HOSTNAME', 'seafile.example.com') context = { 'https': is_https(), 'domain': domain, } if not os.path.isfile('/shared/nginx/conf/seafile.nginx.conf'): render_template('/templates/seafile.nginx.conf.template', '/etc/nginx/sites-enabled/seafile.nginx.conf', context) nginx_etc_file = '/etc/nginx/sites-enabled/seafile.nginx.conf' nginx_shared_file = '/shared/nginx/conf/seafile.nginx.conf' call('mv {0} {1} && ln -sf {1} {0}'.format(nginx_etc_file, nginx_shared_file))
def change_password(request): if request.method == HTTP_METHOD_POST: account_id = request.POST['account_id'] old_password = request.POST['oldpw'] password = request.POST['pw1'] errors = {'generic': 'There was a problem updating your password. Please try again. If you are unable to set up your account please contact support.'} api = get_api(request) ret = api.account_change_password(account_id = account_id, data={'old':old_password, 'new':password}) if ret.response['response_status'] == 200: return utils.render_template('ui/change_password_success', {}) else: return utils.render_template('ui/change_password', {'ERROR': errors['generic'], 'ACCOUNT_ID': account_id}) else: account_id = urllib.unquote(request.session['oauth_token_set']['account_id']) return utils.render_template('ui/change_password', {'ACCOUNT_ID': account_id})
def GET(self, key): i = web.input(v=None) v = i.v and safeint(i.v, None) if not web.ctx.site.can_write(key): return render_template("permission_denied", web.ctx.fullpath, "Permission denied to edit " + key + ".") edition = web.ctx.site.get(key, v) if edition is None: raise web.notfound() work = edition.works and edition.works[0] # HACK: create dummy work when work is not available to make edit form work work = work or web.ctx.site.new('', {'key': '', 'type': {'key': '/type/work'}, 'title': edition.title}) return render_template('books/edit', work, edition)
def get(self): auth_level = self.is_user_authorized() if auth_level == models.AUTH_LEVEL_REGISTERED_USER: self.redirect("/account/activate/reminder/") elif auth_level == models.AUTH_LEVEL_ACTIVATED_USER: from datetime import datetime today = datetime.utcnow() training_announcements = TrainingProgram.get_all_approved_for_month(today.year, today.month) response = render_template("training_announcements.html", training_announcements=training_announcements) self.response.out.write(response) else: response = render_template("index.html") self.response.out.write(response)
def POST(self): i = web.input(title="", publisher="", publish_date="", id_name="", id_value="", _test="false") if spamcheck.is_spam(i): return render_template( "message.html", "Oops", 'Something went wrong. Please try again later.') if not web.ctx.site.get_user(): recap = get_recaptcha() if recap and not recap.validate(): return render_template( 'message.html', 'Recaptcha solution was incorrect', 'Please <a href="javascript:history.back()">go back</a> and try again.' ) i = utils.unflatten(i) saveutil = DocSaveHelper() created_author = saveutil.create_authors_from_form_data( i.authors, i.author_names, _test=i._test == 'true') match = None if created_author else self.find_matches(i) if i._test == 'true' and not isinstance(match, list): if match: return 'Matched <a href="%s">%s</a>' % (match.key, match.key) else: return 'No match found' if isinstance(match, list): # multiple matches return render_template('books/check', i, match) elif match and match.key.startswith('/books'): # work match and edition match, match is an Edition return self.work_edition_match(match) elif match and match.key.startswith('/works'): # work match but not edition work = match return self.work_match(saveutil, work, i) else: # no match return self.no_match(saveutil, i)
def remote_config_update(config, args, check_module=False): ''' client end(infra/NFS node) config file update ./ctl.py -s svc configupdate restfulapi ./ctl.py [-r storage_machine1 [-r storage_machine2]] -s svc configupdate storage_manager by default sudo ''' if check_module: assert set(args.nargs[1:]) - set([ "restfulapi", "storagemanager", "repairmanager", "dashboard" ]) == set(), "not supported" # need to get node list for this subcommand of svc, so load status.yaml if not os.path.exists(FILE_MAP_PATH): utils.render_template("template/cloud-config/file_map.yaml", FILE_MAP_PATH, config) with open(FILE_MAP_PATH) as f: file_map = yaml.load(f) for module in args.nargs[1:]: if module == "jobmanager": module = "restfulapi" if module in ["restfulapi", "dashboard", "repairmanager"]: render_func = eval("render_{}".format(module)) render_func(config) infra_nodes, _ = load_node_list_by_role_from_config( config, ["infra"], False) for file_pair in file_map[module]: src_dst_list = [file_pair["src"], file_pair["dst"]] execute_in_parallel(config, infra_nodes, src_dst_list, True, copy2_wrapper, noSupressWarning=args.verbose) elif module == "storagemanager": nfs_nodes, _ = load_node_list_by_role_from_config( config, ["nfs"], False) for node in nfs_nodes: config["storage_manager"] = config["machines"][node][ "storage_manager"] render_storagemanager(config, node) src_dst_list = [ "./deploy/StorageManager/{}_storage_manager.yaml".format( node), "/etc/StorageManager/config.yaml" ] args_list = (config["machines"][node]["fqdns"], config["ssh_cert"], config["admin_username"], src_dst_list, True, args.verbose) copy2_wrapper(args_list)
def get(self, path): """Handle GET request on static blog content. Only get the static content and pass it to 'output_content'.""" if not path.startswith(config.url_prefix): # Query does not start with prefix. It is OK if it should # be so, like for robots, else that's a 404 error. if path not in ROOT_ONLY_FILES: self.error(404) self.response.out.write(utils.render_template('404.html')) return else: # Query starts with prefix. if config.url_prefix != '': # Strip it off. path = path[len(config.url_prefix):] if path in ROOT_ONLY_FILES: # This lives at root self.error(404) self.response.out.write(utils.render_template('404.html')) return # Retrive the 'StaticContent' object from datastore or memcache. content = get(path) if not content: self.error(404) self.response.out.write(utils.render_template('404.html')) return # Ready to serve... serve = True # ... but first check If-Modified-Since and If-None-Match HTTP # headers (that are used for serving only if content has changed). if 'If-Modified-Since' in self.request.headers: try: last_seen = datetime.datetime.strptime( # IE8 '; length=XXXX' as extra arg bug self.request.headers['If-Modified-Since'].split(';')[0], HTTP_DATE_FMT ) if last_seen >= content.last_modified.replace(microsecond=0): serve = False except ValueError, e: import logging logging.error( 'StaticContentHandler in static.py, ValueError: ' + \ self.request.headers['If-Modified-Since'] )
def init_letsencrypt(): loginfo('Preparing for letsencrypt ...') wait_for_nginx() if not exists(ssl_dir): os.mkdir(ssl_dir) domain = get_conf('SEAFILE_SERVER_HOSTNAME', 'seafile.example.com') context = { 'ssl_dir': ssl_dir, 'domain': domain, } render_template('/templates/letsencrypt.cron.template', join(generated_dir, 'letsencrypt.cron'), context) ssl_crt = '/shared/ssl/{}.crt'.format(domain) if exists(ssl_crt): loginfo('Found existing cert file {}'.format(ssl_crt)) if cert_has_valid_days(ssl_crt, 30): loginfo( 'Skip letsencrypt verification since we have a valid certificate' ) if exists(join(ssl_dir, 'letsencrypt')): # Create a crontab to auto renew the cert for letsencrypt. call('/scripts/auto_renew_crt.sh {0} {1}'.format( ssl_dir, domain)) return loginfo('Starting letsencrypt verification') # Create a temporary nginx conf to start a server, which would accessed by letsencrypt context = { 'https': False, 'domain': domain, } if not os.path.isfile('/shared/nginx/conf/seafile.nginx.conf'): render_template('/templates/seafile.nginx.conf.template', '/etc/nginx/sites-enabled/seafile.nginx.conf', context) call('nginx -s reload') time.sleep(2) call('/scripts/ssl.sh {0} {1}'.format(ssl_dir, domain)) # if call('/scripts/ssl.sh {0} {1}'.format(ssl_dir, domain), check_call=False) != 0: # eprint('Now waiting 1000s for postmortem') # time.sleep(1000) # sys.exit(1) call('/scripts/auto_renew_crt.sh {0} {1}'.format(ssl_dir, domain))
def POST(self): i = web.input(title="", author_name="", author_key="", publisher="", publish_date="", id_name="", id_value="", _test="false") saveutil = DocSaveHelper() match = self.find_matches(saveutil, i) if i._test == "true" and not isinstance(match, list): if match: return 'Matched <a href="%s">%s</a>' % (match.key, match.key) else: return 'No match found' if isinstance(match, list): # multiple matches return render_template("books/check", i, match) elif match and match.key.startswith('/books'): # work match and edition match return self.work_edition_match(match) elif match and match.key.startswith('/works'): # work match but not edition work = match return self.work_match(saveutil, work, i) else: # no match return self.no_match(saveutil, i)
def export_xml(self): documents = copy.deepcopy(self.resources) dottable_documents = [] for document in documents: document[ "grading_criteria"] = True if document in self.grading_criteria else None dottable_documents.append(DottableDict(document)) milestones = [ DottableDict({ "name": key, "mmddyy": value.strftime("%m/%d/%Y") }) for key, value in self.milestone_dates.iteritems() ] data = { "documents": dottable_documents, "milestones": milestones, "group_activity": self, "activity_component_path": resource_filename(__name__, 'templates/activity_component.xml') } return render_template('/templates/xml/group_activity.xml', data)
def _add_kube_proxy_windows(self): template_file = os.path.join( os.getcwd(), "cluster-api/kube-proxy/kube-proxy-windows.yaml.j2") server_core_tag = "windowsservercore-%s" % ( self.opts.base_container_image_tag) context = { "kubernetes_version": self.kubernetes_version, "server_core_tag": server_core_tag, "enable_win_dsr": str(self.opts.enable_win_dsr).lower(), "flannel_mode": self.opts.flannel_mode } output_file = "/tmp/kube-proxy-windows.yaml" utils.render_template(template_file, output_file, context) cmd = [self.kubectl, "apply", "-f", output_file] utils.retry_on_error()(utils.run_shell_cmd)(cmd)
def render_elasticsearch_node_specific(config, args): if not "elasticsearch_node" in config or len( config["elasticsearch_node"]) == 0: print( "Warning: no elasticsearch node specified, logging service might not work as expected." ) return config.pop("mount_and_link", []) config = escaped_etcd_end_point_and_k8s_api_server(config) example_node_name = config["elasticsearch_node"][0].split(".")[0] config["kube_labels"] = get_kube_labels_of_machine_name( config, example_node_name) config["file_modules_2_copy"] = ["kubernetes_common", "kubelet_worker"] utils.render_template( "./template/cloud-config/cloud_init_worker.txt.template", "./deploy/cloud-config/cloud_init_elasticsearch.txt", config)
def to_card_thumbnail(card_json: JsonDict) -> str: """Generates HTML that shows card thumbnail(s). Args: card_json (JsonDict): JSON of a Scryfall Card object. Returns: str: htmlbox code. """ # img_uris ~ URI for card thumbnail(s) if "card_faces" in card_json and "image_uris" in card_json["card_faces"][0]: # Double-faced cards have 2 thumbnails, i.e. transform cards. img_uris = [ face["image_uris"]["normal"] for face in card_json["card_faces"] ] elif "image_uris" in card_json: # Most cards have 1 thumbnail. Split cards fall under this category. img_uris = [card_json["image_uris"]["normal"]] else: # Fallback: image_uris isn't guaranteed to exist or be non-null but the previous # conditional cases should cover most cards. return 'Immagine per <a href="{}">{}</a> non disponibile.'.format( card_json["scryfall_uri"], card_json["name"], ) return utils.render_template( "commands/mtg_card.html", img_uris=img_uris, scryfall_uri=card_json["scryfall_uri"], )
def generate_resource(cls, post, resource, pagenum=1, start_ts=None): import models q = models.BlogPost.all().order('-published') q.filter('published <', start_ts or datetime.datetime.max) cls._filter_query(resource, q) posts = q.fetch(config.posts_per_page + 1) more_posts = len(posts) > config.posts_per_page path_args = { 'resource': resource, } _get_path = lambda: \ cls.first_page_path if path_args['pagenum'] == 1 else cls.path path_args['pagenum'] = pagenum - 1 prev_page = _get_path() % path_args path_args['pagenum'] = pagenum + 1 next_page = cls.path % path_args template_vals = { 'generator_class': cls.__name__, 'posts': posts[:config.posts_per_page], 'prev_page': prev_page if pagenum > 1 else None, 'next_page': next_page if more_posts else None, } rendered = utils.render_template("listing.html", template_vals) path_args['pagenum'] = pagenum static.set(_get_path() % path_args, rendered, config.html_mime_type) if more_posts: deferred.defer(cls.generate_resource, None, resource, pagenum + 1, posts[-2].published)
def GET(self, key): page = web.ctx.site.get(key) if not page: raise web.notfound() return render_template("books/daisy", page)
def POST(self, key): author = web.ctx.site.get(key) if author is None: raise web.notfound() i = web.input(_comment=None) formdata = self.process_input(i) try: if not formdata: raise web.badrequest() elif "_save" in i: author.update(formdata) author._save(comment=i._comment) raise web.seeother(key) elif "_delete" in i: author = web.ctx.site.new(key, { "key": key, "type": { "key": "/type/delete" } }) author._save(comment=i._comment) raise web.seeother(key) except (ClientException, ValidationException) as e: add_flash_message('error', str(e)) author.update(formdata) author['comment_'] = i._comment return render_template("type/author/edit", author)