def post(self):
parser = RequestParser()
parser.add_argument(arg_token)
parser.add_argument('file', type=FileStorage, location='files')
parser.add_argument('desc', type=unicode, location='form')
args = parser.parse_args()
f = args['file']
user = args['token']
if user:
user = User.query.filter_by(token=user).first()
if not user:
return error('wrongtoken'), 403
if not f:
return error('imagenotattached'), 400
upload = do_upload_image(user, f, args['desc'])
if isinstance(upload, str):
return error(upload), 403
else:
return success({
'url': {
'part': upload.url,
'page': BASE_URL % upload.url,
'direct': upload.direct_url
}
}), 201
def create_parser(self):
parser = RequestParser(bundle_errors=True)
parser.add_argument('username',
type=str,
required=True,
help='Name needs to be defined',
location='json')
parser.add_argument('password',
type=str,
required=False,
help='Password needs to be defined',
location='json')
parser.add_argument('email',
type=str,
required=True,
help='Email needs to be defined',
location='json')
parser.add_argument('firstName',
type=str,
required=False,
location='json')
parser.add_argument('lastName',
type=str,
required=False,
location='json')
parser.add_argument('phone', type=str, required=False, location='json')
return parser
def post(self):
parser = RequestParser()
parser.add_argument('X-VERIFY-CREDENTIALS-AUTHORIZATION',
type=str,
location='headers',
dest='authorization')
parser.add_argument('X-AUTH-SERVICE-PROVIDER',
type=str,
location='headers',
dest='authorization_url')
parser.add_argument('media', type=FileStorage, location='files')
parser.add_argument('message', type=unicode, location='form')
parser.add_argument('source', type=unicode, location='form')
args = parser.parse_args()
if args['source'] != 'Tweetbot for iOS':
return error('nottweetbot'), 403
f = args['media']
if not f:
return error('imagenotattached'), 400
headers = {'Authorization': args['authorization']}
r = requests.get(args['authorization_url'], headers=headers)
json = r.json()
user = User.query.filter_by(oauth_uid=json['id']).first()
message = '' if json['protected'] else args.get('message')
desc = "%svia Tweetbot for iOS" % (
('%s\r\n\r\n' % message) if message else '')
upload = do_upload_image(user, f, desc)
if isinstance(upload, str):
return error(upload), 403
else:
return {'url': BASE_URL % upload.url}, 201
def get(self):
parser = RequestParser()
parser.add_argument('token', type=str)
args = parser.parse_args()
if UserService.check_token(args['token']):
return {'message': 'success'}
return {'message': 'error'}
class SystemOptionsAPIView(APIView):
def get(self):
options = dict((o.name, o.value) for o in SystemOption.query.all())
for key, value in OPTION_DEFAULTS.iteritems():
options.setdefault(key, value)
return self.respond(options)
post_parser = RequestParser()
for option in OPTION_DEFAULTS.keys():
post_parser.add_argument(option)
@requires_admin
def post(self):
args = self.post_parser.parse_args()
for name, value in args.iteritems():
if value is None:
continue
create_or_update(SystemOption,
where={
'name': name,
},
values={
'value': value,
})
return '', 200
class UserOptionsAPIView(APIView):
# get is not implemented...add functionality to initial_index instead if
# needed
post_parser = RequestParser()
post_parser.add_argument('user.colorblind')
def post(self):
user = get_current_user()
if user is None:
return error("User not found", http_code=404)
args = self.post_parser.parse_args()
for name, value in args.iteritems():
if value is None:
continue
create_or_update(ItemOption,
where={
'item_id': user.id,
'name': name,
},
values={
'value': value,
})
return self.respond({})
def get(self):
parser = RequestParser()
parser.add_argument(arg_token)
parser.add_argument('with_uploads', type=int, location='args')
args = parser.parse_args()
if not args['token']:
return error('notoken'), 403
user = User.query.filter_by(token=args['token']).first()
if not user:
return error('wrongtoken'), 403
res = {
'name': user.name,
'email': user.email,
'profile_image_url': user.profile_image_url,
'uploads_count': user.uploads.count()
}
if args['with_uploads'] == 1:
uploads = []
for upload in user.uploads:
uploads.append({
'type': upload.object.__tablename__,
'url': {
'page': BASE_URL % upload.url,
'direct': upload.direct_url
},
'title': upload.title,
'desc': upload.desc,
'upload_at': upload.time.strftime('%s'),
'view_count': upload.view_count,
'properties': upload.object.prop
})
res['uploads'] = uploads
return success({'user': res})
def create_parser(self):
parser = RequestParser(bundle_errors=True)
parser.add_argument('tag',
type=str,
required=True,
help='Tag of event',
location='json')
parser.add_argument('name',
type=str,
required=True,
help='Name needs to be defined',
location='json')
parser.add_argument(
'date',
type=str,
required=True,
help='Date needs to be defined',
location='json') # Cambiar el type por lo que corresponde.
parser.add_argument(
'time',
type=str,
required=False,
help='Time of event',
location='json') # Cambiar el type por lo que corresponde.
parser.add_argument('venue',
type=dict,
required=True,
help='Venue needs to be defined',
location='json')
parser.add_argument('requirement',
type=list,
required=False,
location='json')
parser.add_argument('image',
type=str,
required=True,
help='Image needs to be defined',
location='json')
parser.add_argument('description',
type=str,
required=False,
help='Description of event',
location='json')
parser.add_argument('visibility',
type=str,
required=True,
help='Visibility of event',
location='json')
parser.add_argument('gests',
type=list,
required=False,
help='Gests of event',
location='json'),
parser.add_argument('capacity',
type=int,
required=True,
help='Capacity of event',
location='json')
return parser
def post(self):
parser = RequestParser()
parser.add_argument('email', type=str)
parser.add_argument('password', type=str)
parser.add_argument('re_password', type=str)
parser.add_argument('phone', type=str)
parser.add_argument('address', type=str)
parser.add_argument('description', type=str)
def concrete_backend():
parser = RequestParser()
for argument in arguments:
parser.args.append(argument)
user, created = func(parser.parse_args())
current_app.db.session.commit()
login_user(user)
return user, created
def get_one(self, id):
parser = RequestParser()
# Look only in the querystring
parser.add_argument('user', location='args', default=None)
args = parser.parse_args(request)
dao = TimerDAO()
timer = dao.get(id)
as_dict = TimerFormatter().model_to_dict(timer)
resp = jsonify(as_dict)
return resp
def post(self):
parser = RequestParser()
parser.add_argument('image', type=FileStorage, location='files')
parser.add_argument('file', type=FileStorage, location='files')
args = parser.parse_args()
file = args['image'] or args['file']
if not file:
return jsonify({'error': 'not file for upload'})
else:
filename = upload(file)
return jsonify({'href': '%s%s' % (request.url_root, filename)})
def create_parser(self):
parser = RequestParser(bundle_errors=True)
parser.add_argument('event',
type=str,
required=True,
help='Event needs to be defined',
location='json')
parser.add_argument('requirements',
type=list,
required=False,
help='Requirements (optional) needs to be defined',
location='json')
return parser
def delete(self, url):
parser = RequestParser()
parser.add_argument(arg_token)
args = parser.parse_args()
if not args['token']:
return error('notoken'), 403
user = User.query.filter_by(token=args['token']).first()
if not user:
return error('wrongtoken'), 403
res = do_delete_image(user, url)
if res == 'success':
return {'status': 'success'}
else:
return error(res), 403
def put(self, id):
reqparse = RequestParser()
reqparse.add_argument('text', type=str, location='json')
data = reqparse.parse_args()
if not data.text:
return self.argument_required('text')
self.cursor.execute(
"""
UPDATE {}
SET text = ?
WHERE id = ?
""".format(self.__table__), (data.text, id))
self.refresh_table()
return self.get(id)
def __init__(self):
self.reqparse = RequestParser()
self.reqparse.add_argument('user',
type=username,
required=True,
location='json')
self.reqparse.add_argument('key',
type=pubkey,
required=True,
location='json')
self.reqparse.add_argument('host',
type=str,
required=True,
location='json')
super(UserCreate, self).__init__()
def post(self):
parser = RequestParser()
parser.add_argument('email', type=str)
parser.add_argument('password', type=str)
args = parser.parse_args()
salted_string = (args['password'] + SALT)
hashed_pwd = hash_sha(salted_string)
if user_service.check_login(args['email'], hashed_pwd):
return {
'message': 'ok',
'token': user_service.get_token(args['email'], hashed_pwd)
}
else:
return {'message': 'error'}
def post(self):
try:
parser = RequestParser()
parser.add_argument('email', type=str)
parser.add_argument('token', type=str)
args = parser.parse_args()
pwd = ''.join(choice(ascii_uppercase) for i in range(8))
salted_string = (pwd + SALT)
hashed_pwd = hash_sha(salted_string)
UserService.create_user(args['email'], hashed_pwd, args['token'])
send_mail(
args['email'], "Account information",
"Hi, This is your temporary password for your account: " + pwd)
return {'message': 'ok'}
except:
return {'message': 'error'}
def post(self):
# parse incoming POST data
reqparse = RequestParser()
reqparse.add_argument('user', type=dict, location='json')
reqparse.add_argument('text', type=str, location='json')
reqparse.add_argument('image_ref', type=str, location='json')
data = reqparse.parse_args()
# check for required data
if not data.text:
return self.argument_required('text')
if not data.get('user', {}).get('location'):
return self.argument_required('location')
# generate a new time based UUID
post_id = str(uuid.uuid1())
# payload for querying Crate
values = dict(
id=post_id,
created=datetime.now().isoformat(),
user=data.user,
text=data.text,
image_ref=data.image_ref,
like_count=0,
)
k = list(values.keys())
v = list(values.values())
# compile and execute INSERT statement
self.cursor.execute(
"""INSERT INTO {} ({}) VALUES ({})""".format(
self.__table__, ', '.join(k), ', '.join('?' * len(v))), v)
# refresh table to make sure new record is immediately available
self.refresh_table()
# fetch new record
self.cursor.execute(
"""
SELECT p.*, c.name as country, c.geometry as area
FROM guestbook.posts AS p, guestbook.countries AS c
WHERE within(p.user['location'], c.geometry)
AND p.id = ?
""", (post_id, ))
# convert response from Crate into
# json-serializable object array
response = self.convert(self.cursor.description,
self.cursor.fetchall())
return response, 201
class PlanOptionsAPIView(APIView):
def get(self, plan_id):
plan = Plan.query.get(plan_id)
if plan is None:
return error("Plan not found", http_code=404)
options = dict(
(o.name, o.value)
for o in ItemOption.query.filter(ItemOption.item_id == plan.id, ))
for key, value in OPTION_DEFAULTS.iteritems():
options.setdefault(key, value)
return self.respond(options)
post_parser = RequestParser()
post_parser.add_argument('bazel.autogenerate')
post_parser.add_argument('build.expect-tests')
post_parser.add_argument('build.timeout')
post_parser.add_argument('snapshot.allow')
post_parser.add_argument('snapshot.require')
@requires_project_admin(get_project_slug_from_plan_id)
def post(self, plan_id):
plan = Plan.query.get(plan_id)
if plan is None:
return error("Plan not found", http_code=404)
args = self.post_parser.parse_args()
for name, value in args.iteritems():
if value is None:
continue
create_or_update(ItemOption,
where={
'item_id': plan.id,
'name': name,
},
values={
'value': value,
})
return self.respond({})
def post(self):
parser = RequestParser()
parser.add_argument('file', type=werkzeug.datastructures.FileStorage)
parser.add_argument('name', type=str)
parser.add_argument('price', type=str)
parser.add_argument('description', type=str)
parser.add_argument('type', type=int)
parser.add_argument('token', type=str)
args = parser.parse_args()
if UserService.check_token(args['token']):
if args['type'] == 0:
return {'message': 'success'}
ImageService.save_2d_image(args)
else:
ImageService.save_3d_image(args)
return {'message': 'success'}
return {'message': 'error'}, 403
class PlanOptionsAPIView(APIView):
def get(self, plan_id):
plan = Plan.query.get(plan_id)
if plan is None:
return '', 404
options = dict(
(o.name, o.value)
for o in ItemOption.query.filter(ItemOption.item_id == plan.id, ))
for key, value in OPTION_DEFAULTS.iteritems():
options.setdefault(key, value)
return self.respond(options)
post_parser = RequestParser()
post_parser.add_argument('build.expect-tests')
post_parser.add_argument('build.timeout')
post_parser.add_argument('snapshot.allow')
@requires_admin
def post(self, plan_id):
plan = Plan.query.get(plan_id)
if plan is None:
return '', 404
args = self.post_parser.parse_args()
for name, value in args.iteritems():
if value is None:
continue
create_or_update(ItemOption,
where={
'item_id': plan.id,
'name': name,
},
values={
'value': value,
})
return '', 200
def post(self):
# parse incoming POST data
reqparse = RequestParser()
reqparse.add_argument('query_string', type=str, location='json')
data = reqparse.parse_args()
# check for required data
if not data.query_string:
return self.argument_required('query_string')
self.cursor.execute(
"""
SELECT p.*, p._score AS _score,
c.name AS country, c.geometry AS area
FROM guestbook.posts AS p, guestbook.countries AS c
WHERE within(p.user['location'], c.geometry)
AND match(text, ?)
ORDER BY _score DESC
""", (data.query_string, ))
# convert response from Crate into
# json-serializable object array
response = self.convert(self.cursor.description,
self.cursor.fetchall())
return response, 200
def post(self):
# parse incoming POST data
reqparse = RequestParser()
reqparse.add_argument('blob', type=str, location='json')
data = reqparse.parse_args()
if not data.blob:
return self.argument_required('blob')
# encode content as bytestring
tmp = base64.b64decode(data.blob)
# calculate sha1 digest
digest = hashlib.sha1(tmp).hexdigest()
# write into temp file
f = TemporaryFile()
_ = f.write(tmp)
f.flush()
_ = f.seek(0)
# upload blob
created = self.blob_container.put(f, digest=digest)
# response json and status code
code = created and 201 or 409
response = dict(digest=digest, url='/image/{0}'.format(digest))
return response, code
def parse_with(*arguments, **kwargs):
"""This decorator allows you to easily augment any method (typically a
view method) to access reqparse based arguments, i.e.:
class Users(Resource):
@parse_with(Argument('profession'))
def post(self, params, username):
create_new_user(username, params.profession)
return 'CREATED', 201
api.add_resource(Users, '/<username>', endpoint='users')
"""
parser = kwargs.pop('parser', RequestParser())
if kwargs: # mimic py3k style named-arguments after *args, i.e., def f(a, *b, c=1)
raise TypeError("unexpected keyword argument '%s'" % (kwargs.popitem()[0],))
for argument in arguments:
parser.args.append(argument)
def decor(func):
@wraps(func)
def inner(self, *args, **kwargs):
return func(self, parser.parse_args(), *args, **kwargs)
return inner
return decor
__name__,
template_folder='templates',
static_folder='static',
static_url_path='/receita/static')
# Create the restful API
receita_api = restful.Api(receita, prefix="/api/v1")
class Date(fields.Raw):
def format(self, value):
return str(value)
# Parser for RevenueAPI arguments
revenue_list_parser = RequestParser()
revenue_list_parser.add_argument('page', type=int, default=0)
revenue_list_parser.add_argument('per_page_num', type=int, default=100)
revenue_list_parser.add_argument('years', type=int, action='append')
# Fields for RevenueAPI data marshal
revenue_fields = {
'id': fields.Integer(),
'date': Date,
'description': fields.String(),
'code': fields.String(),
'monthly_predicted': fields.Float(),
'monthly_outcome': fields.Float()
}
def _get_args(self, request):
parser = RequestParser()
parser.add_argument('user', location='args', default=None)
args = parser.parse_args(request)
return args
contratos = Blueprint('contratos',
__name__,
template_folder='templates',
static_folder='static',
static_url_path='/contrato/static')
# Create the restful API
contratos_api = restful.Api(contratos, prefix="/api/v1")
# receita_api.decorators = [cors.crossdomain(origin='*')]
# class Date(fields.Raw):
# def format(self, value):
# return str(value)
# Parser for RevenueAPI arguments
contratos_list_parser = RequestParser()
contratos_list_parser.add_argument('cnpj')
contratos_list_parser.add_argument('orgao')
contratos_list_parser.add_argument('modalidade')
contratos_list_parser.add_argument('evento')
contratos_list_parser.add_argument('objeto')
contratos_list_parser.add_argument('processo_administrativo')
contratos_list_parser.add_argument('nome_fornecedor')
contratos_list_parser.add_argument('licitacao')
contratos_list_parser.add_argument('group_by', default='')
contratos_list_parser.add_argument('order_by', 'id')
contratos_list_parser.add_argument('page', type=int, default=0)
contratos_list_parser.add_argument('per_page_num', type=int, default=100)
# Fields for ContratoAPI data marshal
contratos_fields = {
from flask.ext.restful.reqparse import RequestParser
from . import api
from .errors import BadRequest
from .helpers import Resource
from .index import index_links
from .jwt import generate_token, is_verified
parser = RequestParser(bundle_errors=True)
parser.add_argument("username", required=True)
parser.add_argument("password", required=True)
@api.route("/api/login")
@index_links.add("login", method="POST", condition=lambda x: not is_verified())
class Login(Resource):
method_decorators = []
def post(self):
args = parser.parse_args()
if args["username"] == "ssh" and args["password"] == "homework":
return {"token": generate_token(args["username"])}
raise BadRequest("Login failed")
from flask.ext.restful.reqparse import RequestParser
from flask_login import login_required, current_user
from sqlalchemy.orm import load_only
from sqlalchemy import exc, asc, or_
from . import dataformat
from .authorization import is_user_access_restricted, require, allow
from .core import db, event
from .util import new_restful_api, get_model_changes, pagination_parser
from .models import Users, UserTypesForSystem, Courses, UserTypesForCourse, PostsForQuestions, Posts
users_api = Blueprint('users_api', __name__)
user_types_api = Blueprint('user_types_api', __name__)
user_course_types_api = Blueprint('user_course_types_api', __name__)
new_user_parser = RequestParser()
new_user_parser.add_argument('username', type=str, required=True)
new_user_parser.add_argument('student_no', type=str)
new_user_parser.add_argument('usertypesforsystem_id', type=int, required=True)
new_user_parser.add_argument('firstname', type=str, required=True)
new_user_parser.add_argument('lastname', type=str, required=True)
new_user_parser.add_argument('displayname', type=str, required=True)
new_user_parser.add_argument('email', type=str)
new_user_parser.add_argument('password', type=str, required=True)
existing_user_parser = RequestParser()
existing_user_parser.add_argument('id', type=int, required=True)
existing_user_parser.add_argument('username', type=str, required=True)
existing_user_parser.add_argument('student_no', type=str)
existing_user_parser.add_argument('usertypesforsystem_id',
type=int,
