def post(self):
if 'photo' in request.files:
upload_type = 'photo'
upload_files = UploadSet('photos',IMAGES)
configure_uploads(app, upload_files)
filename = upload_files.save(request.files[upload_type])
splits = []
for item in filename.split('.'):
splits.append(item)
extension = filename.split('.')[len(splits) - 1]
else:
return {'status':'error',
'description':'No attached Files'}, 400
f = File(filename=filename, user_id=g.user.id, extension=extension, type=upload_type)
try:
db.session.add(f)
db.session.commit()
except:
return {'status':'error',
'description':'Something went wrong'}, 500
return {'status':'success',
'description':'Upload Succeeded',
'data':{'id':f.id,
'url':upload_files.url(f.name)}}, 201
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 __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 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 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 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)
class UploadManager(object):
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 save_image(self, image):
filename = self.images.save(image)
return {
'url': self.images.url(filename),
'path': self.images.path(filename)
}
def save_video(self, video):
filename = self.videos.save(video)
return filename
def lookup_video(self, filename):
url = self.videos.url(filename)
path = self.videos.path(filename)
return url, path
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)
class UploadManager(object):
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 save_image(self, image):
filename = self.images.save(image)
return {
'url': self.images.url(filename),
'path': self.images.path(filename)
}
def save_video(self, video):
filename = self.videos.save(video)
return filename
def lookup_video(self, filename):
url = self.videos.url(filename)
path = self.videos.path(filename)
return url, path
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)
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'
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():
def post(self, id):
u = User.query.filter_by(id=id).first()
if u.id != g.user.id:
return {'status':'error',
'description':'Unauthorized'}, 401
if request.json:
params = request.json
elif request.form:
params = {}
for key in request.form:
params[key] = request.form[key]
else:
return {'status':'error','description':'Request Failed'}, 400
# Replace blank value to None(null) in params
for key in params:
params[key] = None if params[key] == "" else params[key]
if key in ['id', 'user_id', 'reg_dt', 'language']:
return {'error': key + ' cannot be entered manually.'}, 401
# Bucket Title required
if not 'title' in params:
return {'error':'Bucket title required'}, 401
# Check ParentID is Valid & set level based on ParentID
if not 'parent_id' in params or params['parent_id'] == None:
level = 0
else:
b = Bucket.query.filter_by(id=params['parent_id']).first()
if b is None:
return {'error':'Invalid ParentID'}, 401
elif b.user_id != g.user.id:
return {'error':'Cannot make sub_bucket with other user\'s Bucket'}, 401
else:
level = int(b.level) + 1
if 'rpt_cndt' in params:
dayOfWeek = datetime.date.today().weekday()
if params['rpt_type'] == 'WKRP':
if params['rpt_cndt'][dayOfWeek] == '1':
p = Plan(date=datetime.date.today().strftime("%Y%m%d"),
user_id=g.user.id,
bucket_id=None,
status=0,
lst_mod_dt=datetime.datetime.now())
db.session.add(p)
if 'photo' in request.files:
upload_type = 'photo'
if len(request.files[upload_type].filename) > 64:
return {'status':'error','description':'Filename is too long (Max 64bytes include extensions)'}, 403
upload_files = UploadSet('photos',IMAGES)
configure_uploads(app, upload_files)
filename = upload_files.save(request.files[upload_type])
splits = []
for item in filename.split('.'):
splits.append(item)
extension = filename.split('.')[len(splits) -1]
f = File(filename=filename, user_id=g.user.id, extension=extension, type=upload_type)
db.session.add(f)
db.session.flush()
db.session.refresh(f)
bkt = Bucket(title=params['title'],
user_id=g.user.id,
level=str(level),
status= params['status'] if 'status' in params else True,
private=params['private'] if 'private' in params else False,
reg_dt=datetime.datetime.now(),
lst_mod_dt=datetime.datetime.now(),
deadline=datetime.datetime.strptime(params['deadline'],'%Y-%m-%d').date() if 'deadline' in params \
else datetime.datetime.now(),
description=params['description'] if 'description' in params else None,
parent_id=params['parent_id'] if 'parent_id' in params else None,
scope=params['scope'] if 'scope' in params else None,
range=params['range'] if 'range' in params else None,
rpt_type=params['rpt_type'] if 'rpt_type' in params else None,
rpt_cndt=params['rpt_cndt'] if 'rpt_cndt' in params else None,
cvr_img_id=f.id if 'photo' in request.files else None)
# cvr_img_id=f.id if 'cvr_img' in params and params['cvr_img'] == 'true' else None)
db.session.add(bkt)
db.session.flush()
db.session.refresh(bkt)
if 'rpt_cndt' in params:
if params['rpt_type'] == 'WKRP' and params['rpt_cndt'][dayOfWeek] == '1':
p.bucket_id = bkt.id
if 'fb_share' in params:
social_user = UserSocial.query.filter_by(user_id=u.id).first()
graph = facebook.GraphAPI(social_user.access_token)
resp = graph.put_object("me","feed",
message= g.user.username + " Posted " + params['title'].encode('utf-8'),
link="http://masunghoon.iptime.org:5001",
picture=photos.url(File.query.filter_by(id=bkt.cvr_img_id).first().name) if 'photo' in request.files else None,
caption="Dream Proj.",
description=None if bkt.description is None else bkt.description.encode('utf-8'),
name=bkt.title.encode('utf-8'),
privacy={'value':params['fb_share'].encode('utf-8')})
bkt.fb_feed_id = resp['id']
db.session.commit()
data={
'id': bkt.id,
'user_id': bkt.user_id,
'title': bkt.title,
'description': bkt.description,
'level': bkt.level,
'status': bkt.status,
'private': bkt.private,
'parent_id': bkt.parent_id,
'reg_dt': bkt.reg_dt.strftime("%Y-%m-%d %H:%M:%S"),
'deadline': bkt.deadline.strftime("%Y-%m-%d"),
'scope': bkt.scope,
'range': bkt.range,
'rpt_type': bkt.rpt_type,
'rpt_cndt': bkt.rpt_cndt,
'lst_mod_dt': None if bkt.lst_mod_dt is None else bkt.lst_mod_dt.strftime("%Y-%m-%d %H:%M:%S"),
'cvr_img_url': None if bkt.cvr_img_id is None else photos.url(File.query.filter_by(id=bkt.cvr_img_id).first().name),
'fb_feed_id':None if bkt.fb_feed_id is None else bkt.fb_feed_id
}
return {'status':'success',
'description':'Bucket posted successfully.',
'data':data}, 201
def put(self, id):
if request.json:
params = request.json
elif request.form:
params = {}
for key in request.form:
params[key] = request.form[key]
else:
return {'status':'error','description':'Request Failed'}, 500
b = Bucket.query.filter_by(id=id).first()
if b.user_id != g.user.id:
return {'status':'error','description':'Unauthorized'}, 401
for key in params:
value = None if params[key]=="" else params[key]
# Editable Fields
if key not in ['title','status','private','deadline','description','parent_id','scope','range','rpt_type','rpt_cndt']:
return {'status':'error','description':'Invalid key: '+key}, 403
# Nobody can modify id, user_id, reg_dt
# if key in ['id','user_id','reg_dt']:
# return {'status':'error','description':'Cannot change '+key}, 403
# Just ROLE_ADMIN user can change 'language', 'level'
if key in ['language','level'] and g.user.role == ROLE_USER:
return {'status':'error','description':'Only Admin can change' + key}, 401
# When modify user's parent_id adjusts its level
if key == 'parent_id':
if value == None:
params['level'] = '0'
else:
pb = Bucket.query.filter_by(id=int(value)).first() # pb = parent bucket
if pb == None:
return {'status':'error','description':'Parent does not exists'}, 400
else:
params['level'] = str(int(pb.level)+1)
# Set other key's validation
if key == 'title' and len(value) > 128:
return {'status':'error','description':'Title length must be under 128'}, 400
if key == 'description' and len(value) > 512:
return {'status':'error','description':'Description too long (512)'}, 400
if key == 'deadline':
value = datetime.datetime.strptime(value,'%Y-%m-%d')
if key == 'scope' and value not in ['DECADE','YEARLY','MONTHLY']:
return {'status':'error','description':'Invalid scope value'}, 400
if key == 'rpt_type' and value not in ['WKRP','WEEK','MNTH']:
return {'status':'error','description':'Invalid repeat-type value'}, 400
if key == 'rpt_cndt':
dayOfWeek = datetime.date.today().weekday()
if b.rpt_type == 'WKRP' and b.rpt_cndt[dayOfWeek] != value[dayOfWeek]:
if value[dayOfWeek] == '1':
p = Plan(date=datetime.date.today().strftime("%Y%m%d"),
user_id=b.user_id,
bucket_id=id,
status=0,
lst_mod_dt=datetime.datetime.now())
db.session.add(p)
else:
p = Plan.query.filter_by(date=datetime.date.today().strftime("%Y%m%d"),bucket_id=id).first()
db.session.delete(p)
setattr(b, key, value)
if 'photo' in request.files:
upload_type = 'photo'
if len(request.files[upload_type].filename) > 64:
return {'status':'error',
'description':'Filename is too long (Max 64bytes include extensions)'}, 403
upload_files = UploadSet('photos',IMAGES)
configure_uploads(app, upload_files)
filename = upload_files.save(request.files[upload_type])
splits = []
for item in filename.split('.'):
splits.append(item)
extension = filename.split('.')[len(splits) -1]
f = File(filename=filename, user_id=g.user.id, extension=extension, type=upload_type)
db.session.add(f)
db.session.flush()
db.session.refresh(f)
setattr(b, 'cvr_img_id', f.id)
b.lst_mod_dt = datetime.datetime.now()
try:
db.session.commit()
except:
db.session.rollback()
return {'error':'Something went wrong'}, 500
data={'id': b.id,
'user_id': b.user_id,
'title': b.title,
'description': b.description,
'level': b.level,
'status': b.status,
'private': b.private,
'parent_id': b.parent_id,
'reg_dt': b.reg_dt.strftime("%Y-%m-%d %H:%M:%S"),
'deadline': b.deadline.strftime("%Y-%m-%d"),
'scope': b.scope,
'range': b.range,
'rpt_type': b.rpt_type,
'rpt_cndt': b.rpt_cndt,
'lst_mod_dt': None if b.lst_mod_dt is None else b.lst_mod_dt.strftime("%Y-%m-%d %H:%M:%S"),
'cvr_img_url': None if b.cvr_img_id is None else photos.url(File.query.filter_by(id=b.cvr_img_id).first().name)}
return {'status':'success',
'description':'Bucket put success.',
'data':data}, 201
#! /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)
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)
'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)
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 file(self, file_content):
uploader = UploadSet('surveyimg', IMAGES)
configure_uploads(app, (uploader))
patch_request_class(app, 16 * 1024 * 1024) #: 16 MB limit.
self.filename = uploader.save(file_content,
name = "{0}.".format(str(self)))
def post(self, bucket_id):
b = Bucket.query.filter_by(id=bucket_id).first()
if b is None:
return {'status':'error',
'description':'There\'s no bucket with id: '+id}, 403
if g.user.id != b.user_id:
return {'status':'error',
'description':'Unauthorized'}, 401
if request.json:
params = request.json
elif request.form:
params = {}
for key in request.form:
params[key] = request.form[key]
else:
return {'status':'error','description':'Request Failed'}, 400
# Replace blank value to None(null) in params
for key in params:
params[key] = None if params[key] == "" else params[key]
if key in ['id', 'user_id', 'bucket_id', 'language', 'body', 'timestamp', 'reg_dt', 'lst_mod_dt']:
return {'error': key + ' cannot be entered manually.'}, 401
contents = []
if 'text' in params and params['text'] is not None:
contents.append('text')
if 'url1' in params and params['url1'] is not None:
contents.append('url1')
if 'url2' in params and params['url2'] is not None:
contents.append('url2')
if 'url3' in params and params['url3'] is not None:
contents.append('url3')
if 'photo' in request.files:
upload_type = 'photo'
if len(request.files[upload_type].filename) > 64:
return {'status':'error',
'description':'Filename is too long (Max 64bytes include extensions)'}, 403
upload_files = UploadSet('photos',IMAGES)
configure_uploads(app, upload_files)
filename = upload_files.save(request.files[upload_type])
splits = []
for item in filename.split('.'):
splits.append(item)
extension = filename.split('.')[len(splits) -1]
f = File(filename=filename, user_id=g.user.id, extension=extension, type=upload_type)
db.session.add(f)
db.session.flush()
db.session.refresh(f)
else:
if len(contents) == 0:
return {'status':'error',
'description':'Nothing to Post'}, 403
p = Plan.query.filter_by(bucket_id=b.id).first()
if p is None:
plan = Plan(date=datetime.datetime.now().strftime('%Y%m%d'),
user_id=g.user.id,
bucket_id=b.id,
status=0,
lst_mod_dt=datetime.datetime.now())
db.session.add(plan)
post = Post(body=None,
date=params['date'] if 'date' in params else datetime.datetime.now().strftime('%Y%m%d'),
user_id=b.user_id,
language=None,
bucket_id=bucket_id,
text=params['text'] if 'text' in params else None,
img_id=f.id if 'photo' in request.files else None,
url1=params['url1'] if 'url1' in params else None,
url2=params['url2'] if 'url2' in params else None,
url3=params['url3'] if 'url3' in params else None,
reg_dt=datetime.datetime.now(),
lst_mod_dt=datetime.datetime.now())
db.session.add(post)
db.session.flush()
db.session.refresh(post)
db.session.commit()
data = {'id':post.id,
'user_id':post.user_id,
'bucket_id':post.bucket_id,
'text':None if post.text is None else post.text,
'img_url':None if post.img_id is None else photos.url(File.query.filter_by(id=post.img_id).first().name),
'urls':[{'url1':None if post.url1 is None else post.url1},
{'url2':None if post.url2 is None else post.url2},
{'url3':None if post.url3 is None else post.url3},],
'reg_dt':post.reg_dt.strftime("%Y-%m-%d %H:%M:%S"),
'lst_mod_dt': None if post.lst_mod_dt is None else post.lst_mod_dt.strftime("%Y-%m-%d %H:%M:%S")}
return {'status':'success',
'description':'Successfully posted.',
'data':data}, 201
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)
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():
keys = services.get_data_keys()
return render_template('admin.html', data_keys=keys, labels=services.get_labels())
@app.route('/admin/labels_rename', methods=['POST', ])
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
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):
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
# -*- 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>')
# -*- 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)
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: 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])
def put(self,content_id):
if request.json:
params = request.json
elif request.form:
params = {}
for key in request.form:
params[key] = request.form[key]
else:
return {'status':'error','description':'Request Failed'}, 500
post = Post.query.filter_by(id=content_id).first()
if post.user_id != g.user.id:
return {'status':'error',
'description':'Unauthorized'}, 401
for key in params:
value = None if params[key] == "" else params[key]
# Editable Fields
if key not in ['text','url1','url2','url3']:
return {'status':'error',
'description':key + ' field is not editable'}, 403
# Just ROLE_ADMIN user can change 'language', 'level'
if key in ['language'] and g.user.role == ROLE_USER:
return {'status':'error','description':'Only Admin can change' + key}, 401
# Set Key validataion
# TODO: Make long url to shortened url
if key in ['url1','url2','url3'] and len(value) > 512:
return {'status':'error',
'description': key + ' is too long. (max 256 bytes)'}
setattr(post, key, value)
if 'photo' in request.files:
upload_type = 'photo'
if len(request.files[upload_type].filename) > 64:
return {'status':'error',
'description':'Filename is too long (Max 64bytes include extensions)'}, 403
upload_files = UploadSet('photos',IMAGES)
configure_uploads(app, upload_files)
filename = upload_files.save(request.files[upload_type])
splits = []
for item in filename.split('.'):
splits.append(item)
extension = filename.split('.')[len(splits) -1]
f = File(filename=filename, user_id=g.user.id, extension=extension, type=upload_type)
db.session.add(f)
db.session.flush()
db.session.refresh(f)
setattr(post, 'img_id', f.id)
post.lst_mod_dt = datetime.datetime.now()
try:
db.session.commit()
except:
db.session.rollback()
return {'status':'error',
'description':'DB write error'}, 500
data = {'id':post.id,
'user_id':post.user_id,
'date':post.date,
'bucket_id':post.bucket_id,
'text':None if post.text is None else post.text,
'img_url':None if post.img_id is None else photos.url(File.query.filter_by(id=post.img_id).first().name),
'urls':[{'url1':None if post.url1 is None else post.url1},
{'url2':None if post.url2 is None else post.url2},
{'url3':None if post.url3 is None else post.url3},],
'reg_dt':post.reg_dt.strftime("%Y-%m-%d %H:%M:%S"),
'lst_mod_dt': None if post.lst_mod_dt is None else post.lst_mod_dt.strftime("%Y-%m-%d %H:%M:%S")}
return {'status':'success',
'description':'Post PUT success',
'data':data}, 201
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)
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)
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.
"""
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)])
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
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')
