def profile_handler(form, insti, req):
insti.name = form.name.data
insti.intro = form.intro.data
logo = request.files.get('logo')
if not (logo.filename is None or logo.filename == ''):
logo_upload = UploadSet('logos', ('jpg', 'png'))
configure_uploads(current_app, (logo_upload))
try:
filename = logo_upload.save(logo)
logo_url = logo_upload.url(filename)
insti.logo_url = logo_url
except UploadNotAllowed:
return (False, '上传LOGO时出错')
poster = request.files.get('poster')
if not (poster.filename is None or poster.filename == ''):
poster_upload = UploadSet('posters', ('jpg', 'png'))
configure_uploads(current_app, (poster_upload))
try:
filename = poster_upload.save(poster)
poster_url = poster_upload.url(filename)
insti.poster_url = poster_url
except UploadNotAllowed:
return (False, '上传海报时出错')
db.session.add(insti)
return (True, '资料更新成功')
def member_edit():
edit_form = EditForm()
if request.method == 'POST' and edit_form.validate_on_submit():
user = User.query.get(current_user.id)
user.name = edit_form.username.data
avatar = request.files.get('avatar')
# print(avatar) # <FileStorage: '' ('application/octet-stream')>
# print(avatar.filename)
if avatar.filename is not None: # and avatar.filename!=''
avatar_upload = UploadSet(name='avatars',
extensions=('jpg', 'jpeg', 'png', 'bmp'))
configure_uploads(current_app, (avatar_upload)) #加载上传集配置
try:
filename = avatar_upload.save(avatar)
# avatar_upload.resolve_conflict(avatar_upload, fname) #解决可能存在的文件名冲突问题
user.avatar_url = avatar_upload.url(filename)
except UploadNotAllowed:
pass
else:
flash('头像上传失败', 'alert-warning')
portrait = request.files.get('portrait')
if portrait.filename is not None:
portrait_upload = UploadSet(name='portraits',
extensions=('jpg', 'jpeg', 'png',
'bmp'))
configure_uploads(current_app, (portrait_upload)) #加载上传集配置
try:
filename = portrait_upload.save(portrait)
# portrait_upload.resolve_conflict(portrait_upload, fname) #解决可能存在的文件名冲突问题
user.portrait_url = portrait_upload.url(filename)
except UploadNotAllowed:
pass
else:
flash('半身像上传失败', 'alert-warning')
user.signature = edit_form.signature.data
user.intro = edit_form.intro.data
password = edit_form.password.data
if password is not None and password != '': #更改密码
if user.verify_password(edit_form.old_password.data):
if len(password) > 6 and len(password) < 24:
if password == edit_form.password2.data:
user.password = password
flash('密码更改成功！', 'alert-success')
else:
flash('两次密码输入不一致，密码未更改', 'alert-warning')
else:
flash('密码长度必须 6-24 位，密码未更改', 'alert-warning')
else:
flash('当前密码错误，密码未更改', 'alert-danger')
db.session.add(user)
flash('个人资料更新成功！', 'alert-success')
return redirect(url_for('member.member_page', userid=user.id))
edit_form.username.data = current_user.name
edit_form.signature.data = current_user.signature
edit_form.intro.data = current_user.intro
return render_template('member/edit.html', form=edit_form)
def __init__(self, app):
self.videos = UploadSet('videos', (
'mp4',
'webm',
'wmv',
'avi',
'mov',
))
self.images = UploadSet('images', ('jpeg', ))
configure_uploads(app, (
self.videos,
self.images,
))
def init_uploads():
global docs
global TEMP_DIR
logger.info("Uploads will be written to %s", TEMP_DIR)
databasic.app.config['UPLOADED_DOCS_DEST'] = TEMP_DIR
docs = UploadSet(name='docs', extensions=('txt', 'docx', 'rtf', 'csv', 'xlsx', 'xls'))
configure_uploads(databasic.app, (docs))
def edit_event(uurl, eid):
event = Event.query.get_or_404(int(eid))
edit_form = EditForm()
if request.method == 'POST' and edit_form.validate_on_submit():
event.detail = edit_form.detail.data
poster = request.files.get('poster')
if poster.filename is not None:
poster_upload = UploadSet(name='posters',
extensions=('jpg', 'jpeg', 'png', 'bmp'))
configure_uploads(current_app, (poster_upload)) #加载上传集配置
try:
filename = poster_upload.save(poster)
event.poster_url = poster_upload.url(filename)
except UploadNotAllowed:
pass
else:
flash('海报上传失败……', 'alert-warning')
db.session.add(event)
flash('更新成功', 'alert-success')
return redirect(url_for('event.event_page', eid=event.id))
edit_form.detail.data = event.detail
return render_template('institution/event_edit.html',
insti=current_insti(),
event=event,
edit_form=edit_form)
def group_new():
group_form = GroupForm()
if request.method == 'POST' and group_form.validate_on_submit():
name = group_form.name.data
intro = group_form.intro.data
icon = request.files.get('icon')
if not (icon is None or icon == ''):
icon_upload = UploadSet('icons', ('jpg', 'png'))
configure_uploads(current_app, (icon_upload))
try:
filename = icon_upload.save(icon)
icon_url = icon_upload.url(filename) #得到icon的URL
except UploadNotAllowed:
flash('请上传小组图标', 'alert-danger')
return render_template('group/new.html', form=group_form)
else:
flash('小组图标没上传', 'alert-danger')
return render_template('group/new.html', form=group_form)
group = Group(name=name,
icon_url=icon_url,
intro=intro,
owner_id=current_user.id) #_get_current_object()
db.session.add(group)
flash('新建小组 %s 成功！' % name, 'alert-success')
return redirect(url_for('group.group_index'))
return render_template('group/new.html', form=group_form)
def create_app(conf_module):
app = Flask(__name__,
static_url_path='/static',
static_folder='../static/{}'.format(CURRENT_SITE),
template_folder='../templates/{}'.format(CURRENT_SITE))
app.config.from_object(conf_module)
# Cache(app)
Mail(app)
MongoSet(app)
# SQLAlchemy(app)
app.extensions['celery'] = celery
images = UploadSet('image')
configure_uploads(app, (images))
patch_request_class(app)
# setup local assets
try:
from city_lang.assets_local import setup_assets
setup_assets(app)
except ImportError, e:
print "No module assets_local: {}".format(e)
import sqlite3 as sql
from flask import Flask, request, session, g, redirect,\
url_for, abort, render_template, flash
from flask_bootstrap import Bootstrap
from flask.ext.uploads import configure_uploads
from flask.ext.uploads import UploadSet, AllExcept, SCRIPTS, EXECUTABLES
# Setup Upload folder
documents = UploadSet('documents', AllExcept(SCRIPTS + EXECUTABLES))
# configuration
DATABASE = 'tmp/explorer.db'
DEBUG = True
SECRET_KEY = 'development key'
USERNAME = '******'
PASSWORD = '******'
# Create flask application
app = Flask(__name__)
app.config.from_object(__name__)
app.config['UPLOADS_DEFAULT_DEST'] = ''
# Setup Database, bootstrap, login, analytics
Bootstrap(app)
configure_uploads(app, documents)
# Setup Database, bootstrap, login, analytics
def connect_db():
return sqlite3.connect(app.config['DATABASE'])
@app.route('/')
# -*- coding: utf-8 -*-
from __future__ import unicode_literals, print_function
from flask import Flask, render_template, send_from_directory, abort
from flask.ext.uploads import UploadSet, ALL, configure_uploads, patch_request_class
from werkzeug import secure_filename
from memes import get_memes
# Flask
app = Flask(__name__)
app.config.from_pyfile('config.py')
# Flask-Uploads
memes_up = UploadSet('memes', ALL)
configure_uploads(app, memes_up)
patch_request_class(app, app.config['MAX_CONTENT_LENGTH'])
@app.route('/')
@app.route('/<filter>')
def index(filter=None):
"""Hall of memes"""
if filter not in [None, 'audio', 'video']:
abort(404)
return render_template('index.html', memes=get_memes(filter))
@app.route('/meme/<filename>')
class RegistrationForm(Form):
full_name = TextField('Full name', [validators.Length(min=4, max=25)])
email = TextField('Email Address', [validators.Length(min=5, max=35),
validators.Email(),
UserExists('User already exists')])
password = PasswordField('New Password', [
validators.Required(),
validators.EqualTo('confirm', message='Passwords must match')
])
confirm = PasswordField('Repeat Password')
recaptcha = RecaptchaField()
images = UploadSet("images", IMAGES)
class ConfigurationForm(Form):
name = TextField('Institution name', [validators.Length(min=4, max=100)], description = "Example: My institution")
# logo = FileField('Institution logo', validators=[ file_allowed(images, "Images only")])
logo = FileField('Institution logo', validators=[])
base_url = TextField('Base url', [validators.Length(min=4, max=100),
validators.Regexp('^[\w-]+$'),
BaseURLExists('Base url already exists')],
description = "Example: myinstitution. The final URL will be: https://cloud.weblab.deusto.es/w/myinstitution/")
link_url = TextField('Link url', [validators.Length(min=4, max=100),
validators.Regexp('^http:\/\/(\w|-|\.|\/)+$')],
description ="Example: http://www.myinstitution.com/")
google_analytics_number = TextField('Google analytics number', description="Optional. Example: UA-12576838-6")
class DisabledConfigurationForm(Form):
#! /usr/bin/env python
import os
from werkzeug import FileStorage
from StringIO import StringIO
from flask import current_app
from flask.ext.uploads import (UploadSet, configure_uploads, IMAGES,
UploadNotAllowed)
thumbnails = UploadSet(
'thumbnails',
IMAGES,
default_dest=lambda app: os.path.join(app.static_folder, 'thumbnails'))
def configure(app):
thumbnails_dir = os.path.join(app.static_folder, 'thumbnails')
if not os.path.isdir(thumbnails_dir):
os.mkdir(thumbnails_dir)
configure_uploads(app, thumbnails)
def return_werkzeug_filestorage(request, filename, maxsize=(320, 240)):
extension = request.headers['content-type'].split('/')[-1]
if extension not in current_app.config['ALLOWED_EXTENSIONS']:
raise UploadNotAllowed("Unsupported file format")
new_filename = filename + '.' + extension
tempfile = StringIO(buf=request.content)
tempfile.name = new_filename
filestorage = FileStorage(tempfile,
filename=new_filename,
from db import app
from flask.ext.uploads import UploadSet, configure_uploads, ARCHIVES, DOCUMENTS
PRESENTATIONS = ('ppt', 'pptx', 'odp')
PDF = ('pdf', )
print(app.config)
submissions = UploadSet('submissions', ARCHIVES)
presentations = UploadSet('presentations', PRESENTATIONS)
syllabi = UploadSet('syllabi', PDF)
assignment_descs = UploadSet('assignments', DOCUMENTS + PDF)
configure_uploads(app, (submissions, presentations, syllabi, assignment_descs))
# coding: utf-8
from flask.ext.uploads import UploadSet, IMAGES
# UploadSets
workimages = UploadSet('workimages', IMAGES)
app.config.update(
dict(
DEBUG=False,
ALLOWED_EXTENSIONS=set(['jpg', 'gif', 'png']),
MAX_CONTENT_LENGTH=1024 * 1024 * 16,
UPLOADED_IMAGES_DEST="images",
))
app.config.from_envvar('PIKYAK_SETTINGS', silent=True)
app.config[
"SQLALCHEMY_DATABASE_URI"] = "mysql://*****:*****@localhost/dbname"
db = SQLAlchemy(app)
auth = HTTPBasicAuth()
images = UploadSet('images',
IMAGES,
default_dest=lambda app: app.instance_root)
configure_uploads(app, (images, ))
# Models
maxIDlength = 255
class AsDictMixin(object):
# Exportables are members that can be safely serialized to a client
_exportables = []
def asdict(self):
result = {}
for key in self._exportables_:
result[key] = getattr(self, key)
# coding=utf-8
import os, traceback
from flask import current_app
from flask.ext.uploads import UploadSet, DEFAULTS, ARCHIVES, UploadNotAllowed
from sqlalchemy.exc import IntegrityError
from datetime import datetime
from . import db
resource_uploader = UploadSet('resource',
DEFAULTS + ARCHIVES,
default_dest=lambda app: app.instance_root)
class Resource(db.Model):
id = db.Column(db.Integer, primary_key=True)
filename = db.Column(db.Unicode(1024), nullable=False)
upload_time = db.Column(db.DateTime)
awards_id = db.Column(db.String(128),
db.ForeignKey('awards.awards_id',
ondelete='CASCADE'),
nullable=False)
awards = db.relationship('Awards',
backref=db.backref('resources',
cascade="all, delete-orphan",
passive_deletes=True,
lazy='dynamic'))
def __repr__(self):
return '<Resource %s>' % self.filename
from flask.ext.uploads import UploadSet, configure_uploads
app = Flask(__name__, instance_relative_config=True)
app.config.from_object('settings')
app.config.from_pyfile('settings.py')
# Setup debugtoolbar, if we're in debug mode.
if app.debug:
from flask.ext.debugtoolbar import DebugToolbarExtension
toolbar = DebugToolbarExtension(app)
# Flask extensions
db = SQLAlchemy(app)
# Flask uploads
tournament_exports = UploadSet('tournamentExports', ('json', 'txt'))
configure_uploads(app, [tournament_exports])
# Views
import views
# Blueprints
from .user.views import user_bp as user_blueprint
app.register_blueprint(user_blueprint)
from .tournament.views import tournament_bp as tournament_blueprint
app.register_blueprint(tournament_blueprint)
from .netrunner.views import nr_bp as nr_blueprint
app.register_blueprint(nr_blueprint)
import steam
app = Flask(__name__, instance_relative_config=True)
app.config.from_object('settings')
app.config.from_pyfile('settings.py')
# Setup debugtoolbar, if we're in debug mode.
if app.debug:
from flask.ext.debugtoolbar import DebugToolbarExtension
toolbar = DebugToolbarExtension(app)
# Flask extensions
db = SQLAlchemy(app)
login_manager = LoginManager(app)
oid = OpenID(app)
workshopzips = UploadSet('workshopZips', 'zip')
modimages = UploadSet('modImages', IMAGES)
markdown = Misaka(app, escape=True, wrap=True)
sentry = Sentry(app)
# Setup steamodd
steam.api.key.set(app.config['STEAM_API_KEY'])
steam.api.socket_timeout.set(5)
# Setup Flask-Uploads
configure_uploads(app, [workshopzips, modimages])
# Views
import views
# Blueprints
from __future__ import with_statement
from StringIO import StringIO
from flask import render_template, request
from flask.ext.uploads import UploadSet, IMAGES, TEXT, configure_uploads
from flask.ext.wtf import Form, TextField, FileField, FieldList, \
file_required, file_allowed
from base import TestCase
images = UploadSet("images", IMAGES)
text = UploadSet("text", TEXT)
class FileUploadForm(Form):
upload = FileField("Upload file")
class MultipleFileUploadForm(Form):
uploads = FieldList(FileField("upload"), min_entries=3)
class ImageUploadForm(Form):
upload = FileField("Upload file",
validators=[file_required(),
file_allowed(images)])
from flask import Flask
from flask.ext.sqlalchemy import SQLAlchemy
from flask.ext.login import LoginManager
from flask.ext.uploads import UploadSet, IMAGES, configure_uploads
app = Flask(__name__)
app.config.from_object('config')
db = SQLAlchemy(app)
lm = LoginManager()
lm.init_app(app)
lm.login_view = 'login'
category_img = UploadSet('category', IMAGES)
configure_uploads(app, (category_img))
from app import views, models
from datetime import datetime
from flask import g
from flask.ext import wtf
from flask.ext.mongoengine.wtf import model_form
from flask.ext.uploads import UploadSet, AllExcept, SCRIPTS, EXECUTABLES
from sanap.models import Survey
from sanap.forms.fields import *
from sanap.model_data import *
files = UploadSet('files', AllExcept(SCRIPTS + EXECUTABLES))
_SurveyForm = model_form(Survey)
FILE_FIELDS = (
'assessment_subnational_files',
'action_plan_files',
'part4_files',
'part2_files',
'part1_files',
'part3_files',
)
class SectorsForm(wtf.Form):
adaptation_national = MultiTextField('Adaptation at national level')
adaptation_sub_national = MultiTextField(
'Adaptation at sub-national level (e.g. provinces, regions)')
adaptation_local = MultiTextField('Adaptation at local or city-level')
# -*- coding: utf-8 -*-
import os
from flask import Flask
from flask.ext.mysql import MySQL
from flask.ext.login import LoginManager
from flask.ext.uploads import UploadSet, IMAGES, configure_uploads
app = Flask('project')
app.debug = True
app.secret_key = 'd0ntW4tch'
# gallery configurations
app.config['UPLOADED_GALLERY_DEST'] = os.path.join(os.path.dirname(__file__),
'static', 'gallery')
gallery = UploadSet('gallery', IMAGES)
configure_uploads(app, gallery)
# login configurations
login_manager = LoginManager()
login_manager.init_app(app)
login_manager.login_view = 'login'
login_manager.login_message = u'Veuillez vous connecter pour accéder à cette page.'
# MySQL configurations
mysql = MySQL()
app.config['MYSQL_DATABASE_USER'] = '******'
app.config['MYSQL_DATABASE_PASSWORD'] = '******'
app.config['MYSQL_DATABASE_DB'] = 're7'
app.config['MYSQL_DATABASE_HOST'] = 'localhost'
mysql.init_app(app)
from flask.ext.socketio import SocketIO, emit
from flask.ext.uploads import UploadSet, configure_uploads
import os
import services
app = Flask(__name__)
app.config['SECRET_KEY'] = 'secret'
DEFAULT_PORT = 5000
socketio = SocketIO(app)
log = logging.getLogger('run')
log.setLevel(logging.DEBUG)
log.addHandler(logging.StreamHandler())
photos = UploadSet()
photos.file_allowed = lambda a, b: True
app.config['UPLOADS_DEFAULT_DEST'] = '/tmp'
configure_uploads(app, photos)
@app.route('/')
def index_demo():
return render_template('app.html',
label_names=','.join(
sorted(services.get_labels().keys())))
@app.route('/admin')
def admin():
# -*- coding: cp1252 -*-
from flask.ext.wtf import Form
from wtforms import TextField
from wtforms.validators import Required
from flask.ext.uploads import UploadSet, IMAGES
from flask_wtf.file import FileField, FileAllowed, FileRequired
images = UploadSet('images', IMAGES)
req = Required(
'Campo Necessário'.decode('utf-8')) # generaliza msgs de campo requerido
class CadastroBarForm(Form):
id = TextField('id')
nome = TextField('nome', validators=[req])
descricao = TextField('descricao', validators=[req])
endereco = TextField('endereco', validators=[req])
telefone = TextField('telefone', validators=[req])
especialidade = TextField('especialidade', validators=[req])
foto = FileField('foto',
validators=[
FileAllowed(['jpg', 'png'],
'Somente imagens! (JPG, PNG)')
])
class ConsultaForm(Form):
consulta = TextField('consulta', validators=[req])
import forms as fm
import json
import os
import boto
import boto3
import boto.s3
from boto.s3.connection import S3Connection
from boto3.s3.transfer import S3Transfer
from boto.s3.key import Key
import time
app = Flask(__name__)
photos = UploadSet('photos', DATA)
PATH = 'static/csv/data/data99.json'
app.config['UPLOADED_PHOTOS_DEST'] = 'static/csv/data'
app.config['SECRET_KEY'] = 'abcdefghijkl'
configure_uploads(app, photos)
#s3 = boto3.client( "s3", aws_access_key_id= AWS_ACCESS_KEY_ID , aws_secret_access_key = AWS_SECRET_ACCESS_KEY)
AWS_ACCESS_KEY_ID =
AWS_SECRET_ACCESS_KEY =
END_POINT = 'us-east-1' # eg. us-east-1
S3_HOST = 's3.us-east-1.amazonaws.com' # eg. s3.us-east-1.amazonaws.com
BUCKET_NAME = 'polishbank'
FILENAME = 'data.json'
PATH_FILE = 'static/csv/'
UPLOADED_FILENAME = 'data12.json'
mail = Mail()
admin = Admin(template_mode='bootstrap3', index_view=MyHomeView())
admin.add_view(AnalyticsView(name="Analytics", endpoint='analytics'))
admin.add_view(EmailRenderView(name="Email Renders", endpoint='email-renders'))
security = Security()
api_manager = APIManager()
compress = Compress()
gravatar = Gravatar(size=42,
rating='g',
default='mm',
force_default=False,
use_ssl=True,
base_url=None)
user_images = UploadSet('userimages', IMAGES)
review_images = UploadSet('reviewimages', IMAGES)
shop_images = UploadSet('shopimages', IMAGES)
resize = Resize()
assets = Environment()
js_assets = Bundle('js/main.js', filters='rjsmin', output='js/main.min.js')
css_assets = Bundle('css/global.css',
filters='cssmin',
output='css/global.min.css')
def create_app(option):
app = FlaskOpinewExt(__name__)
config = config_factory.get(option)
app.config.from_object(config)
from flask import Flask, render_template, request
from flask.ext.uploads import UploadSet, configure_uploads, ALL
app = Flask(__name__)
files = UploadSet('files', ALL)
app.config['UPLOADED_FILES_DEST'] = 'uploads'
configure_uploads(app, files)
@app.route('/upload', methods=['GET', 'POST'])
def upload():
if request.method == 'POST' and 'media' in request.files:
filename = files.save(request.files['media'])
return render_template('upload.html')
if __name__ == '__main__':
app.run(debug=True)
from flask import Flask, render_template, request, jsonify
import pickle
from flask.ext.uploads import UploadSet, configure_uploads, IMAGES
from make_image import make_image
from make_model import make_model
from flask_bootstrap import Bootstrap
app = Flask(__name__)
photos = UploadSet('photos', IMAGES)
app.config['UPLOADED_PHOTOS_DEST'] = 'static/img'
configure_uploads(app, photos)
@app.route('/')
def index():
return render_template('index.html')
@app.route('/upload', methods=['GET', 'POST'])
def upload():
if request.method == 'POST' and 'photo' in request.files:
filename = photos.save(request.files['photo'])
return predict(filename)
return render_template('upload.html')
@app.route('/predict', methods=['GET', 'POST'])
def predict(filename = False):
"""Recieve the article to be classified from an input form and use the
model to classify.
"""
'facebook': {
'id': '317459725322708',
'secret': 'bf3d86ffca84ce6aebcc043a027f0779'
},
'github': {
'id': '9aaca0d24c3774c51b9f',
'secret': '214d1a2afc0f728ddba2c085f38827754f11922b'
}
}
commandbase = 'cf_sol.py'
commandtestfile = 'cf_sol_test.py'
trainingfile = 'tinyTraining.txt'
#stuff for uploading
photos = UploadSet('photos', ALL)
app.config[
'UPLOADED_PHOTOS_DEST'] = 'newuploads' # in current flow, this shouldn't get used
configure_uploads(app, photos)
#end stuff for uploading
db = SQLAlchemy(app)
lm = LoginManager(app)
lm.login_view = 'index'
myPath = '/Users/morgan/oauth-example/homework/'
class User(UserMixin, db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
import os
from flask import Flask
from flask.ext.sqlalchemy import SQLAlchemy
from flask.ext.login import LoginManager
from flask.ext.bootstrap import Bootstrap
from flask.ext.pagedown import PageDown
from flask.ext.uploads import UploadSet, IMAGES, configure_uploads
app = Flask(__name__)
app.config.from_object('config')
db = SQLAlchemy(app)
lm = LoginManager(app)
bootstrap = Bootstrap(app)
pagedown = PageDown(app)
avatars = UploadSet('avatars', IMAGES)
configure_uploads(app, avatars)
from app.main import main, auth, user, book, comment, library, log
from app.api import api_bp
for blueprint in [main, auth, user, book, comment, library, log, api_bp]:
app.register_blueprint(blueprint)
from app import models
exists_db = os.path.isfile(app.config['DATABASE'])
if not exists_db:
from . import db_fill
class CRUDView(MethodView):
model = None
form = None
list_template = None
item_form_template = 'admin/form_model.html'
object_template = None
decorators = [login_required]
upload_set = UploadSet('image')
def extra_context(self, origin):
return origin
def get(self, id=None):
if 'data' in request.args:
instance = self.model.query.get_or_404(id)
item_url = url_for('.{}'.format(self.__class__.__name__),
id=instance.id)
form = self.form(obj=instance)
return jsonify_status_code({
'form':
render_template(self.item_form_template,
form=form,
item_url=item_url),
'id':
instance.id,
'title':
'Editing {}'.format(self.__class__.__name__)
})
elif id is None:
context = {'models': self.get_objects()}
template = self.list_template
else:
context = {'model': self.model.query.get_or_404(ObjectId(id))}
template = self.list_template
context['form'] = self.form()
return render_template(template, **self.extra_context(context))
def post(self, id=None):
form = self.form(request.form)
instance = self.model()
if id is not None:
instance = self.model.query.get_or_404(id)
if request.form and form.validate():
instance_data = form.data.copy()
# processing uploaded files if any
if 'image' in request.files:
try:
filename = self.upload_set.save(request.files['image'])
instance_data['image'] = self.upload_set.url(filename)
except UploadNotAllowed:
del instance_data['image']
instance.update(upsert=True, **instance_data)
return redirect(url_for('.{}'.format(self.__class__.__name__)))
context = {'models': self.get_objects(), 'form': form}
return render_template(self.list_template,
**self.extra_context(context))
def delete(self, id):
self.model.query.remove({'_id': ObjectId(id)})
return jsonify_status_code({}, http.NO_CONTENT)
def get_objects(self, query_args=None):
return self.model.query.find(query_args)
