def create_user_endpoint():
data = request.get_json()
if data is None:
return '', 400
message = UserSchema().validate(data)
if len(message) > 0:
return jsonify(message), 400
user = User(**data)
db.session.add(user)
db.session.commit()
schema = UserSchema(only=('uid', 'name', 'avatar', 'identity',
'subscription', 'createdAt'))
return jsonify(schema.dump(user)), 201
def show(user_id):
schema = UserSchema()
user = User.get(id=user_id)
if not user:
abort(404)
return schema.dumps(user)
def post(self):
email = request.authorization.username
password = request.authorization.password
user = UserModel.query.filter(UserModel.user_email == email).filter(UserModel.user_pass == password).first()
if user:
user_schema = UserSchema()
result = user_schema.dump(user)
return jsonify(result.data)
return {}, 404
def get_user_endpoint(uid):
# get user's checksum
user = User.query.get(uid)
# evaluate if matches given checksum
if user is None:
return jsonify(message=f'User {uid} does not exist!'), 404
schema = UserSchema(only=('uid', 'name', 'avatar', 'title', 'identity',
'mnemonic', 'subscription', 'createdAt'))
user = schema.dump(user)
if user['identity'] == 0: # artist
releases = Media.query \
.filter_by(uid=user['uid'], dist_type=False) \
.order_by(Media.title) \
.all()
releases = MediaSchema(exclude=('uid', 'full_audio', 'demo_segment',
'dist_type')).dump(releases, many=True)
for release in releases:
release['artist'] = user['name']
user['releases'] = releases
auctions = Auction.query \
.filter_by(uid=user['uid']) \
.order_by(Auction.start.desc()) \
.all()
auctions = AuctionSchema(only=('aid', 'assetId', 'amount', 'start',
'end', 'sold', 'earnings', 'mid',
'media.title',
'media.cover')).dump(auctions,
many=True)
for auction in auctions:
auction['cover'] = auction['media']['cover']
auction['title'] = auction['media']['title']
auction['artist'] = user['name']
del auction['media']
user['auctions'] = auctions
else: # listener
owns = Ownership.query.filter_by(uid=user['uid']).all()
owns = OwnershipSchema(only=('aid', 'auction.assetId', 'auction.sold',
'auction.earnings', 'mid', 'media.uid',
'media.title',
'media.cover')).dump(owns, many=True)
for own in owns:
own['assetId'] = own['auction']['assetId']
own['sold'] = own['auction']['sold']
own['earnings'] = own['auction']['earnings']
own['title'] = own['media']['title']
own['cover'] = own['media']['cover']
own['artist'] = User.query.get(own['media']['uid']).name
del own['auction']
del own['media']
user['owns'] = owns
return jsonify(user), 200
def show(user_id):
# This will serialize our data
schema = UserSchema()
# This gets a user by ID
user = User.get(id=user_id)
# If we can't find a user, send a 404 response
if not user:
abort(404)
# otherwise, send back the user data as JSON
return schema.dumps(user)
def register():
schema = UserSchema()
try:
data = schema.load(request.get_json())
user = User(**data)
db.commit()
except ValidationError as error:
return jsonify({'error': error.messages}), 422
return jsonify({
'message': 'Registation successful',
'token': user.generate_token()
})
def update(user_id):
schema = UserSchema()
user = User.get(id=user_id)
if not user:
abort(404)
try:
data = schema.load(request.get_json())
user.set(**data)
db.commit()
except ValidationError as err:
return jsonify({'message': 'Validation failed', 'errors': err.messages}), 422
return schema.dumps(user)
def create():
schema = UserSchema()
try:
data = schema.load(request.get_json())
user = User(**data)
db.commit()
except ValidationError as err:
return jsonify({'message': 'Validation failed', 'errors': err.messages}), 422
return schema.dumps(user), 201
def edit_profile():
schema = UserSchema()
data = request.get_json()
if data.get('concession'):
data['concession'] = data['concession'] == 'true'
if data.get('keyword_ids'):
print(g.current_user.keywords)
previousKeywords = []
for keyword in g.current_user.keywords:
previousKeywords.append(keyword)
data['keywords'] = [
Keyword.get(id=keyword_id) for keyword_id in data['keyword_ids']
] + previousKeywords
del data['keyword_ids']
g.current_user.set(**data)
db.commit()
user_info = g.current_user
return schema.dumps(user_info)
def create():
# This will deserialize the JSON from insomnia
schema = UserSchema()
try:
# attempt to convert the JSON into a dict
data = schema.load(request.get_json())
# Use that to create a user object
user = User(**data)
# store it in the database
db.commit()
except ValidationError as err:
# if the validation fails, send back a 422 response
return jsonify({
'message': 'Validation failed',
'errors': err.messages
}), 422
# otherwise, send back the user data as JSON
return schema.dumps(user), 201
from pony.orm import db_session
from app import db
from models.Category import Category
from models.Listing import Listing
from models.User import User, UserSchema
from models.CartItem import CartItem
db.drop_all_tables(with_all_data=True)
db.create_tables()
with db_session():
user_schema = UserSchema()
user1 = User(username='******',
email='*****@*****.**',
password_hash=user_schema.generate_hash('pass'))
user2 = User(username='******',
email='*****@*****.**',
password_hash=user_schema.generate_hash('pass'))
user3 = User(username='******',
email='*****@*****.**',
password_hash=user_schema.generate_hash('pass'))
user4 = User(username='******',
email='*****@*****.**',
password_hash=user_schema.generate_hash('pass'))
user5 = User(username='******',
from pony.orm import db_session
from app import db
from models.Building import Building
from models.Construction import Construction
from models.Style import Style
from models.User import User, UserSchema
db.drop_all_tables(with_all_data=True)
db.create_tables()
with db_session():
schema = UserSchema()
char = User(username='******',
email='*****@*****.**',
password_hash=schema.generate_hash('pass'))
schema = UserSchema()
arj = User(username='******',
email='*****@*****.**',
password_hash=schema.generate_hash('pass'))
brick = Construction(name='Brick')
london_stock_brick = Construction(name='London Stock Brick')
stone = Construction(name='Stone')
timber_frame = Construction(name='Timber frame')
rcf = Construction(name='Concrete frame')
steel_frame = Construction(name='Steel frame')
metal_frame = Construction(name='Metal frame')
aluminium_clad = Construction(name='Aluminium')
modern_panel_cladding = Construction(name='Modern panel cladding')
rendered_masonry = Construction(name='Rendered masonry')
def user_index():
# This will serialize our data
schema = UserSchema() #many=True
user = User.get(id=g.current_user.id)
return schema.dumps(user) # 'schema.dumps' converts the list to JSON
def index():
# This will serialize our data
# `many=True` because there are many users, ie we expect a list
schema = UserSchema(many=True)
users = User.select() # get all the users
return schema.dumps(users) # `schema.dumps` converts the list to JSON
def profile():
schema = UserSchema()
return schema.dumps(g.current_user)
from models.User import User, UserSchema
from flask import request, Response, jsonify
from flask_restful import Resource
from flask_jwt_extended import (create_access_token, set_access_cookies,
create_refresh_token, get_csrf_token,
set_refresh_cookies, jwt_required,
get_jwt_identity)
from helpers.api import custom_json_response
from helpers.database import save_to_database
from sqlalchemy import exc, or_
from helpers.distance import distance
from controllers.meal import create_meal, become_chef
import json
user_schema = UserSchema()
user_schema_private = UserSchema(
exclude=['password', 'email', 'isChef', 'address'])
class ChefResource(Resource):
def get(self, id=None):
q_params = request.args
if id:
user = User.get_by_id(id)
return user_schema_private.dump(user)
applied_filters = []
sql_filters = []
if q_params.get("userCuisines"):
chosen_cuisines = q_params.get("userCuisines").split(",")
def get(self,user_id):
user = UserModel.query.filter(UserModel.ID==user_id).first()
user_schema = UserSchema()
result = user_schema.dump(user)
return jsonify(result.data)
from flask import Blueprint, request, jsonify
from models.User import User, UserSchema
from marshmallow import ValidationError
from lib.secure_route import secure_route
user_schema = UserSchema()
users_schema = UserSchema(many=True)
api = Blueprint('users', __name__)
@api.route('/users/<int:id>', methods=['GET'])
def show(id):
user = User.query.get(id)
if not user:
return jsonify({'message': 'Not found'}), 404
return user_schema.jsonify(user)
@api.route('/users/<int:id>', methods=['PUT', 'PATCH'])
@secure_route
def update(id):
user = User.query.get(id)
if not user:
return jsonify({'message': 'Not found'}), 404
req_data = request.get_json()
def get(self):
all_users = UserModel.query.all()
user_schema = UserSchema(many=True)
result = user_schema.dump(all_users)
return jsonify(result.data)
def index():
schema = UserSchema(many=True)
users = User.select()
print(users)
return schema.dumps(users)
def retrieve_all_users():
users = User.query.all()
schema = UserSchema(exclude=('password', 'mnemonic'))
return jsonify(*map(schema.dump, users)), 200