def _setup_dynamic_flask_blueprint_api(self): # Create a dynamic flask blueprint with a known prefix api = uuid.uuid4().hex url_prefix = '/_%s_TEST' % api blueprint = blueprints.Blueprint(api, __name__, url_prefix=url_prefix) self.url_prefix = url_prefix self.flask_blueprint = blueprint self.cleanup_instance('flask_blueprint', 'url_prefix')
def __init__(self, app, model, url_prefix): model = model blueprint = blueprints.Blueprint("app_error", 'app_error', root_path=root_path, template_folder="templates", url_prefix=url_prefix) @blueprint.route('/') def view_list(): """ List exceptions based on the page number :return: rendered template """ title = "App Error" page = request.args.get('page', 1, type=int) error = False errors = model.get_exceptions_per_page(page_number=page) next_url = url_for('app_error.view_list', page=errors.next_num) \ if errors.has_next else None prev_url = url_for('app_error.view_list', page=errors.prev_num) \ if errors.has_prev else None return render_template('list.html', error=error, title=title, errors=errors, next_url=next_url, prev_url=prev_url) @blueprint.route('/<string:rhash>') def view_detail(rhash): """ Display a specific exception having hash rhash :param rhash: hash key of the exception :return: detailed view page """ obj = model.get_entity(rhash) error = False if obj is None: abort(404) title = "%s : %s" % (obj.method, obj.path) return render_template('detail.html', error=error, title=title, obj=obj) @blueprint.route('/delete_entity/<string:rhash>') def view_delete(rhash): """ Delete a specific exceptions identified by rhash :param rhash: hash key of the exception :return: redirect back to the home page """ model.delete_entity(rhash) return redirect(url_for('app_error.view_list')) app.register_blueprint(blueprint)
def __init__(self, blueprint_url_prefix='', api_url_prefix='', default_mediatype='application/json', decorators=None, errors=None): self.__before_request_functions_added = False self.__after_request_functions_added = False self._default_mediatype = default_mediatype blueprint_url_prefix = blueprint_url_prefix.rstrip('/') api_url_prefix = api_url_prefix.rstrip('/') if api_url_prefix and not api_url_prefix.startswith('/'): self._api_url_prefix = '/%s' % api_url_prefix else: # NOTE(morgan): If the api_url_prefix is empty fall back on the # class-level defined `_api_url_prefix` if it is set. self._api_url_prefix = (api_url_prefix or getattr(self, '_api_url_prefix', '')) if blueprint_url_prefix and not blueprint_url_prefix.startswith('/'): self._blueprint_url_prefix = self._build_bp_url_prefix( '/%s' % blueprint_url_prefix) else: self._blueprint_url_prefix = self._build_bp_url_prefix( blueprint_url_prefix) self.__blueprint = blueprints.Blueprint( name=self._name, import_name=self._import_name, url_prefix=self._blueprint_url_prefix) self.__api = flask_restful.Api( app=self.__blueprint, prefix=self._api_url_prefix, default_mediatype=self._default_mediatype, decorators=decorators, errors=errors) # NOTE(morgan): Make sure we're using oslo_serialization.jsonutils # instead of the default json serializer. Keystone has data types that # the default serializer cannot handle, representation is a decorator # but since we instantiate the API in-line we need to do some magic # and call it as a normal method. self.__api.representation('application/json')(self._output_json) self._add_resources() self._add_mapped_resources() # Apply Before and After request functions self._register_before_request_functions() self._register_after_request_functions() # Assert is intended to ensure code works as expected in development, # it is fine to optimize out with python -O msg = '%s_request functions not registered' assert self.__before_request_functions_added, msg % 'before' # nosec assert self.__after_request_functions_added, msg % 'after' # nosec
def __init__(self, name='auth', url_prefix='/auth'): self.blueprint = blueprints.Blueprint( name, __name__, url_prefix=url_prefix, template_folder=self.get_template_folder()) self.blueprint.route(self.get_login_endpoint())( self.generate_login_view()) self.blueprint.route(self.get_authenticate_endpoint(), methods=('POST', ))( self.generate_authenticate_view())
def website_create(): website = blueprints.Blueprint('website', __name__, url_prefix='/website', static_folder = "dist/static", template_folder = "dist") @website.route('/') def index(): return render_template("index.html") # @website.route("/static/<path:path>") # def static_dir(path): # return send_from_directory("dist/static", path) return website
def __init__(self, blueprint_url_prefix='', api_url_prefix='', default_mediatype='application/json', decorators=None, errors=None): self.__before_request_functions_added = False self.__after_request_functions_added = False self._default_mediatype = default_mediatype blueprint_url_prefix = blueprint_url_prefix.rstrip('/') api_url_prefix = api_url_prefix.rstrip('/') if api_url_prefix and not api_url_prefix.startswith('/'): self._api_url_prefix = '/%s' % api_url_prefix else: self._api_url_prefix = api_url_prefix if blueprint_url_prefix and not blueprint_url_prefix.startswith('/'): self._blueprint_url_prefix = self._build_bp_url_prefix( '/%s' % blueprint_url_prefix) else: self._blueprint_url_prefix = self._build_bp_url_prefix( blueprint_url_prefix) self.__blueprint = blueprints.Blueprint( name=self._name, import_name=self._import_name, url_prefix=self._blueprint_url_prefix) self.__api = flask_restful.Api( app=self.__blueprint, prefix=self._api_url_prefix, default_mediatype=self._default_mediatype, decorators=decorators, errors=errors) self._add_resources() self._add_mapped_resources() # Apply Before and After request functions self._register_before_request_functions() self._register_after_request_functions() # Assert is intended to ensure code works as expected in development, # it is fine to optimize out with python -O msg = '%s_request functions not registered' assert self.__before_request_functions_added, msg % 'before' # nosec assert self.__after_request_functions_added, msg % 'after' # nosec
def __init__(self, blueprint_url_prefix='', api_url_prefix='', default_mediatype='application/json', decorators=None, errors=None): self._blueprint_url_prefix = blueprint_url_prefix self._default_mediatype = default_mediatype self._api_url_prefix = api_url_prefix self.__blueprint = blueprints.Blueprint( name=self._name, import_name=self._import_name, url_prefix=self._build_bp_url_prefix(self._blueprint_url_prefix)) self.__api_bp = flask_restful.Api( app=self.__blueprint, prefix=self._api_url_prefix, default_mediatype=self._default_mediatype, decorators=decorators, errors=errors) self._add_resources()
from flask import blueprints common = blueprints.Blueprint("common", __name__) from . import image from . import location from . import video from . import audio
services_response_schema, RevisionsResponse, revisions_response_schema, ) from confidant.services import ( credentialmanager, iamrolemanager, keymanager, servicemanager, webhook, ) from confidant.utils import maintenance, misc from confidant.utils.dynamodb import decode_last_evaluated_key logger = logging.getLogger(__name__) blueprint = blueprints.Blueprint('services', __name__) acl_module_check = misc.load_module(settings.ACL_MODULE) @blueprint.route('/v1/roles', methods=['GET']) @authnz.require_auth def get_iam_roles_list(): """ Get a list of IAM roles from the configured AWS account. .. :quickref: IAM Roles; Get a list of IAM roles from the configured AWS account. **Example request**:
from flask import blueprints from .github import GitHubIdentityVerificationCallbackResource from .slack import SlackEventSubscriptionResource, SlackSlashCommandDispatchResource from busy_beaver.config import SLACK_SIGNING_SECRET from busy_beaver.decorators import verify_slack_signature integration_bp = blueprints.Blueprint("integrations", __name__) slack_verification_required = verify_slack_signature(SLACK_SIGNING_SECRET) view = SlackEventSubscriptionResource.as_view("slack_event_subscription") integration_bp.add_url_rule("/slack-event-subscription", view_func=slack_verification_required(view)) view = SlackSlashCommandDispatchResource.as_view( "slack_slash_command_dispatcher") integration_bp.add_url_rule("/slack-slash-commands", view_func=slack_verification_required(view)) integration_bp.add_url_rule( "/github-integration", view_func=GitHubIdentityVerificationCallbackResource.as_view( "github_verification"), )
from flask import blueprints auth = blueprints.Blueprint('auth', __name__) from app.auth import views
from urlparse import urlparse from flask import (blueprints, flash, g, jsonify, redirect, request, send_file, url_for) from patchserver.database import db from patchserver.exc import InvalidPatchDefinitionError, InvalidWebhook from patchserver.models import ApiToken, SoftwareTitle, WebhookUrls from patchserver.routes.api_operations import ( create_criteria_objects, create_extension_attributes, create_patch_objects, lookup_software_title, create_backup_archive, restore_backup_archive) from patchserver.routes.auth import api_auth from patchserver.routes.validator import validate_json from patchserver.routes.webhooks import webhook_event blueprint = blueprints.Blueprint('api', __name__, url_prefix='/api/v1') @blueprint.route('/token', methods=['POST']) def token_create(): """Create an API token for the server. .. :quickref: Token; Create the API token. **Example Request:** .. sourcecode:: http POST /api/v1/token HTTP/1.1 **Example Response:**
from flask import request from flask import blueprints from application.middles import testMiddle as m from application.controller import route bp = blueprints.Blueprint('test', __name__, url_prefix='/example') @route(bp, '/get_test_info', methods=['POST']) def get_test_info(): params = request.get_json(force=True) result = m.get_test(**params) return result
import asyncio import json import re import time from flask import blueprints, Response from common import config from database import Database from model import Channel from telegram_async import AsyncTelegramClient add_channel_endpoint = blueprints.Blueprint("add_channel", __name__) CHANNEL_NAME_PATTERN = re.compile(r"^[\w_\-]+$") telethon_api = AsyncTelegramClient() db = Database( "dbname='telegram' user='******' host='localhost' password='******'" % (config["db_password"], )) loop = asyncio.get_event_loop() def matches_channel_name(channel_name): return CHANNEL_NAME_PATTERN.match(channel_name) is not None @add_channel_endpoint.route("/add_channel/<string:channel>") def add_channel(channel): """ Suggest a channel
from flask import render_template, make_response, url_for, redirect, current_app, request, session from flask import blueprints as bp from flask_login import current_user, login_user, logout_user, login_required from flask_principal import identity_changed, identity_loaded, AnonymousIdentity, Identity from functools import wraps from genius.db.model import Book, User from genius.global_settings import NAV_TABS from genius.util.form_util import render_form from .forms import LoginForm from .errors import FormNotMatchException home_bp = bp.Blueprint('home', __name__, url_prefix='/') @home_bp.route('/') def send_home(): books = (Book.newly_books(), Book.most_copies(), Book.most_copies()) rank_types = (u'新书速递', u'畅销', u'最受关注') book_rank_map = {rank_type: target_books for rank_type, target_books in zip(rank_types, books)} return render_template('index.j2', book_rank_map=book_rank_map) @home_bp.route('/login', methods=['POST', 'GET']) @render_form(LoginForm, 'login.j2') def login(form: LoginForm): user = form.match_db() # will throws FormNotMatchException if not match login_user(user) identity = Identity(user.id)
def get_bp(name): """Return blueprint for Image management.""" bp = blueprints.Blueprint(name, __name__) @bp.route('<image_id>/', methods=['GET']) def show(image_id): """Present details page for single image object. Tries using both Glance and Nova services because they provide different info set about an image. """ glance_image = clients.admin_clients().glance.images.get(image_id) nova_image = clients.admin_clients().nova.images.get(image_id) return { 'glance_image': glance_image, 'nova_image': nova_image, 'title': bp.name.replace('global_', '').replace('_', ' ').capitalize(), 'subtitle': 'Image details', } def get_tenant_id(): return getattr(flask.g, 'tenant_id', clients.get_systenant_id()) @bp.route('') def index(): """List images. Admin (global visibility level) should see only images from systenant. Project members should see images for projects only. """ images = get_images_list() if not hasattr(flask.g, 'tenant_id'): images = filter(lambda x: getattr(x, 'is_public', False), images) p = pagination.Pagination(images) data = p.slice(images) return { 'images': data, 'pagination': p, 'delete_form': forms.DeleteForm(), 'title': bp.name.replace('global_', '').replace('_', ' ').capitalize(), 'subtitle': 'List of existing images' } @bp.route('new/', methods=['GET']) def new(): """Present image upload form. TODO(apugachev): remove from templ location images older then X hours """ images = get_images_list() check = lambda f: lambda x: getattr(x, 'container_format') == f kernels = filter(check('aki'), images) initrds = filter(check('ari'), images) dump = lambda d: json.dumps([{ 'name': x.name, 'container_format': x.container_format, 'id': x.id } for x in d]) return { 'kernel_list': dump(kernels), 'initrd_list': dump(initrds), 'title': bp.name.replace('global_', '').replace('_', ' ').capitalize(), 'subtitle': 'Add new image' } @bp.route('upload/', methods=['POST']) def upload(): """Save uploaded file. Handles AJAX call, saves file in temp location, returns filename. TODO(apugachev): remove from templ location images older then X hours """ storage = flask.request.files['file'] filename = focus.files_uploads.save(storage) flask.current_app.cache.set(os.path.basename(filename), {'transferred': -1}) return filename @bp.route('create/', methods=['POST']) def create(): """Create image via Glance API. - validates form - creates image via API - cleans up tmp file - returns successful message New image uploaded in tenant systenant publicly if blueprint is in admin context. Otherwise image uploaded in the tenant used for the project and is not public. With default Glance settings (owner means tenant) this would restrict access to the image for members of the project. During the process of upload ongoing progress is memcached. TODO(apugachev): remove from templ location images older then X hours """ def create_image(uploaded_filename, name, container, disk_format, kernel_id=None, ramdisk_id=None): tenant_id = get_tenant_id() properties = { 'image_state': 'available', 'project_id': tenant_id, 'architecture': 'x86_64', 'image_location': 'local' } if kernel_id is not None: properties['kernel_id'] = kernel_id if ramdisk_id is not None: properties['ramdisk_id'] = ramdisk_id uploaded_filename = focus.files_uploads.path(uploaded_filename) try: kwargs = { 'name': name, 'container_format': container, 'disk_format': disk_format, 'data': open(uploaded_filename), 'is_public': not hasattr(flask.g, 'tenant_id'), 'properties': properties, } except IOError, e: e.public_message = 'Uploaded file is missing' flask.current_app.logger.error(str(e)) raise try: user_clients = clients.user_clients(tenant_id) callback = ProgressRecorder( user_clients.http_client, os.path.basename(uploaded_filename), os.fstat(kwargs['data'].fileno()).st_size) with callback: img = user_clients.image.images.create(**kwargs) except RuntimeError as e: flask.flash(e.message, 'error') else: flask.flash('Image with name %s registered.' % img.name, 'success') return img.id finally: try: kwargs['data'].close() os.unlink(uploaded_filename) except OSError: # nothing to do, temporal file was removed by something pass # TODO(apugachev): validate thoroughly, do not rely on js to do it if flask.request.form['upload_type'] == 'solid': create_image(flask.request.form['uploaded_filename'], flask.request.form['name'], 'bare', flask.request.form['disk_format']) elif flask.request.form['upload_type'] == 'amazon_like': if flask.request.form['uploaded_kernel'] != u'null': kernel_id = create_image(flask.request.form['uploaded_kernel'], flask.request.form['kernel'], 'aki', 'aki') else: kernel_id = flask.request.form['kernel'] if flask.request.form['uploaded_initrd'] != u'null': ramdisk_id = create_image( flask.request.form['uploaded_initrd'], flask.request.form['initrd'], 'ari', 'ari') else: ramdisk_id = flask.request.form['initrd'] create_image(flask.request.form['uploaded_filesystem'], flask.request.form['name'], 'ami', 'ami', kernel_id, ramdisk_id) # NOTE(apugachev) for big this will fail to load and BrokenPipe # will be raised inside Flask return flask.jsonify({})
from flask import blueprints from .github_summary import PublishGitHubSummaryResource from .retweeter import TwitterPollingResource from .upcoming_events import PublishUpcomingEventsResource from .update_events import AddEventPollingResource from .youtube_post import YouTubePollingResource poller_bp = blueprints.Blueprint("poller", __name__) poller_bp.add_url_rule( "/github-summary", view_func=PublishGitHubSummaryResource.as_view("post_github_summary"), methods=["POST"], ) poller_bp.add_url_rule( "/twitter", view_func=TwitterPollingResource.as_view("twitter_poller"), methods=["POST"], ) poller_bp.add_url_rule( "/upcoming-events", view_func=PublishUpcomingEventsResource.as_view("post_upcoming_events"), methods=["POST"], ) poller_bp.add_url_rule( "/sync-event-database", view_func=AddEventPollingResource.as_view("meetup_poller"),
from confidant import authnz, settings from confidant.services import certificatemanager from confidant.schema.certificates import ( certificate_authority_response_schema, certificate_authorities_response_schema, certificate_expanded_response_schema, certificate_response_schema, CertificateAuthorityResponse, CertificateAuthoritiesResponse, CertificateResponse, ) from confidant.utils import misc logger = logging.getLogger(__name__) blueprint = blueprints.Blueprint('certificates', __name__) acl_module_check = misc.load_module(settings.ACL_MODULE) @blueprint.route('/v1/certificates/<ca>/<cn>', methods=['GET']) @authnz.require_auth def get_certificate(ca, cn): ''' Get a certificate from the provided CA, for the provided CN. .. :quickref: Certificate; Get certificate from the provided CA, for the provided CN. **Example request**:
# -*- coding: utf-8 -*- # @Time : 2021/1/5 下午2:46 # @Author : cyq # @File : __init__.py.py from flask import blueprints myBug = blueprints.Blueprint("myBug", __name__, url_prefix="/api") from . import users, product, bugs, search
from hashlib import sha256 from flask import redirect, render_template, json, request, blueprints from uuid import uuid4 from datetime import datetime, timedelta import db from user import User app = blueprints.Blueprint('app', __name__) @app.route('/oauth/authorize', methods=['GET']) def authorize_form(): response_type = request.args.get('response_type', None) client_id = request.args.get('client_id', None) state = request.args.get('state', None) if client_id is None: return 'missing client_id', 400 try: new_client_id = int(client_id) except: return 'invalid client_id', 400 if new_client_id not in db.client: print(client_id) return 'no id in database', 400 if response_type is None: return redirect(db.client[new_client_id]['redirect_uri'] +
from flask import blueprints lg = blueprints.Blueprint('login', __name__)
from flask import blueprints, current_app, jsonify, request from graphlite import V import logging from sqlalchemy.orm.exc import NoResultFound logger = logging.getLogger(__name__) logger.setLevel(logging.DEBUG) from family_tree.database import Address, Person blueprint = blueprints.Blueprint('person', __name__) @blueprint.route('/person/<person_id>', methods=['GET']) def get_person(person_id): db = current_app.config['db'] try: person = db.session.query(Person).filter_by(id=person_id).one() record = person.json address_id = record.pop('address_id') address = db.session.query(Address).filter_by(id=address_id).one() record['address'] = address.json except NoResultFound: return jsonify(False), 404 return jsonify(record) @blueprint.route('/person/add', methods=['POST']) def add_person(): record = request.get_json()
from flask import blueprints, current_app, flash, jsonify, redirect, request, url_for from sqlalchemy.exc import IntegrityError from ..exc import ( InvalidPatchDefinitionError, SoftwareTitleNotFound, Unauthorized ) blueprint = blueprints.Blueprint('error_handlers', __name__) @blueprint.app_errorhandler(Unauthorized) def unauthorized(err): current_app.logger.error(err.message) if request.args.get('redirect'): flash( { 'title': 'Unauthorized', 'message': err.message }, 'warning') return redirect(url_for('web_ui.index')) else: return jsonify({'unauthorized': err.message}), 401 @blueprint.app_errorhandler(InvalidPatchDefinitionError) def error_invalid_patch_definition(err): current_app.logger.error(err.message)
def get_bp(blueprint_name): """Return blueprint for Security_Group management.""" bp = blueprints.Blueprint(blueprint_name, __name__) @bp.route('<security_group_id>/', methods=['GET']) def show(security_group_id, add_form=None): """Present details page for single security group object. """ security_group = (clients.user_clients( flask.g.tenant_id).compute.security_groups.get(security_group_id)) return { 'security_group': security_group, 'add_form': add_form or forms.SecurityGroupRuleAdd(security_group_id=security_group_id), 'delete_form': forms.DeleteForm(), 'title': bp.name.replace('global_', '').replace('_', ' ').capitalize(), 'subtitle': 'Security group details', } @bp.route('') def index(): """List security groups. """ security_groups = (clients.user_clients( flask.g.tenant_id).compute.security_groups.list()) p = pagination.Pagination(security_groups) data = p.slice(security_groups) return { 'security_groups': data, 'pagination': p, 'delete_form': forms.DeleteForm(), 'title': bp.name.replace('global_', '').replace('_', ' ').capitalize(), 'subtitle': 'List of existing security groups' } @bp.route('new/', methods=['GET', 'POST']) def new(): """Create security_group. """ form = forms.SecurityGroupCreate() if form.validate_on_submit(): try: security_group = (clients.user_clients( flask.g.tenant_id).compute.security_groups.create( name=form.name.data, description=form.description.data)) except exceptions.HttpException as ex: flask.flash(ex.message, 'error') else: flask.flash('Security group %s created.' % form.name.data, 'success') return flask.redirect(flask.url_for('.index')) return { 'form': form, 'title': bp.name.replace('global_', '').replace('_', ' ').capitalize(), 'subtitle': 'Add new security group' } @bp.route('<security_group_id>/delete/', methods=['POST']) def delete(security_group_id): form = forms.DeleteForm() if form.validate_on_submit(): try: (clients.user_clients( flask.g.tenant_id).compute.security_groups.delete( security_group_id)) except exceptions.HttpException as ex: flask.flash(ex.message, 'error') else: flask.flash('Security group successfully deleted', 'success') else: flask.flash('Invalid form', 'error') return flask.redirect(flask.url_for('.index')) @bp.route('<security_group_id>/<rule_id>/delete', methods=['POST']) def delete_rule(security_group_id, rule_id): form = forms.DeleteForm() if form.validate_on_submit(): (clients.user_clients( flask.g.tenant_id).compute.security_group_rules.delete(rule_id) ) flask.flash('Security group rule successfully deleted', 'success') else: flask.flash('Invalid form', 'error') return flask.redirect( flask.url_for('.show', security_group_id=security_group_id)) @bp.route('<security_group_id>/add_rule', methods=['GET', 'POST']) def add_rule(security_group_id): form = forms.SecurityGroupRuleAdd(security_group_id=security_group_id) if form.validate_on_submit(): try: group_id = int(form.group_id.data) cidr = None except ValueError: group_id = None cidr = form.cidr.data try: (clients.user_clients( flask.g.tenant_id).compute.security_group_rules.create( security_group_id, form.ip_protocol.data, form.from_port.data, form.to_port.data, cidr, group_id)) except exceptions.HttpException as ex: flask.flash(ex.message, 'error') else: flask.flash('Security group rule successfully added', 'success') return flask.redirect( flask.url_for('.show', security_group_id=security_group_id)) return { 'form': form, 'security_group_id': security_group_id, 'title': bp.name.replace('global_', '').replace('_', ' ').capitalize(), 'subtitle': 'Add new rule' } return bp
# You should have received a copy of the GNU Lesser General Public # License along with this program. If not, see # <http://www.gnu.org/licenses/>. import flask from flask import blueprints from focus import clients from focus.views import environments from focus.views import forms from focus.views import pagination from openstackclient_base.exceptions import HttpException bp = environments.admin(blueprints.Blueprint('networks', __name__)) @bp.route('') def index(): try: networks = clients.admin_clients().compute.networks.list() except HttpException as ex: networks = [] tenants = clients.admin_clients().identity_admin.tenants.list() tenants = dict(((t.id, t.name) for t in tenants)) p = pagination.Pagination(len(networks)) offset = p.limit_offset() networks = [net._info for net in networks[offset[0]:offset[1]]] for net in networks: net["label"] = tenants.get(net["project_id"], net["label"])
from flask import current_app, blueprints, request, jsonify from marshmallow import Schema, fields, post_load from sqlalchemy.orm import sessionmaker from kv_store.controller.value import ValueController from kv_store.model.value import Value blueprint = blueprints.Blueprint('value', __name__) @blueprint.route('/value', methods=['POST']) @blueprint.route('/value/<key>', methods=['PUT']) def set(key=None): status_code = None controller = ValueController() schema = ValueAccessorSchema() value = schema.load(request.get_json()) if key: value.key = key new_value = controller.update(value) status_code = 200 else: new_value = controller.create(value) status_code = 201 return schema.dump(new_value), status_code @blueprint.route('/value/<key>', methods=['GET']) def get(key):
from flask import blueprints user = blueprints.Blueprint('user', __name__) from app.user import views
from flask import (blueprints, request, redirect, session, render_template, jsonify) import os from markupsafe import Markup, escape from ProcessaTicketAPI.ProcessaTicketClasses import TicketProcessor from settings import APP_1_HOME_URL, APP_3_HOME_URL ProcessaTicket_blueprint = blueprints.Blueprint('ProcessaTicket_blueprint', __name__) @ProcessaTicket_blueprint.route("/") def show_welcome_page(): return render_template('welcome_page.html', url='/process', home_url='//' + APP_1_HOME_URL, get_result_url='//' + APP_3_HOME_URL) @ProcessaTicket_blueprint.route('/process', methods=['POST']) def process_calculation_request_and_redirect(): tickprocs = TicketProcessor(jsonify(request.form).json) result = tickprocs.process() session['result'] = result return redirect('/process_result')
from ..models import db, Person, Address from flask import blueprints from flask import jsonify from faker import Faker fake = Faker() blueprint = blueprints.Blueprint('generate_data', __name__) # for testing purposes only. @blueprint.route('/generate_data', methods=['GET']) def generate_data(): db.drop_all() db.create_all() grandpa_1 = make_person() grandma_1 = make_person(last_name=grandpa_1.last_name) child_1 = make_person(last_name=grandpa_1.last_name, parents=[grandpa_1, grandma_1]) grandpa_2 = make_person() grandma_2 = make_person(last_name=grandpa_2.last_name) child_2 = make_person(last_name=child_1.last_name, parents=[grandpa_2, grandma_2]) grandchild_1 = make_person(last_name=child_1.last_name, parents=[child_1, child_2]) grandchild_2 = make_person(last_name=child_1.last_name, parents=[child_1, child_2]) db.session.commit() return jsonify('data created') def make_person(last_name=None, addresses=None, parents=None): person = Person( first_name = fake.first_name(),
from flask import blueprints, render_template, session, request, current_app, redirect from flask_directory_example import db from .. import models ac = blueprints.Blueprint('ac', __name__) @ac.route('/login', methods=['GET', 'POST']) def login(): if request.method == 'GET': return render_template('login.html') else: user = request.form.get('user') pwd = request.form.get('pwd') obj = db.session.query(models.Users).filter( models.Users.name == user, models.Users.pwd == pwd).first() db.session.remove() #在请求结束时删除数据库会话 if not obj: return render_template('login.html') current_app.auth_manage.login(user) #用户验证成功设置session return redirect('/index') @ac.route('/logout') def logout(): current_app.auth_manage.logout() return redirect('/login')