def post(self):
raw_dict = request.get_json(force=True)
try:
schema.validate(raw_dict)
request_dict = raw_dict['data']['attributes']
payload = parse_token(request)
logged_user = Users.query.get(payload['sub'])
createdby = logged_user.name
updatedby = logged_user.name
password = generate_password_hash(request_dict['password'])
user = Users(
request_dict['email'],
password,
request_dict['name'],
createdby,
updatedby,
)
user.add(user)
# Should not return password hash
query = Users.query.get(user.id)
results = schema.dump(query).data
return results, 201
except ValidationError as err:
resp = jsonify({"error": err.messages})
resp.status_code = 403
return resp
except SQLAlchemyError as e:
db.session.rollback()
resp = jsonify({"error": str(e)})
resp.status_code = 403
return resp
def post(self):
raw_dict = request.get_json(force=True)
try:
schema.validate(raw_dict)
request_dict = raw_dict['data']['attributes']
role = None
active = 0
user = Users(request_dict['email'],
generate_password_hash(request_dict['password']),
request_dict['name'], active, role)
user.add(user)
# Should not return password hash
query = Users.query.get(user.id)
results = schema.dump(query).data
return results, 201
except ValidationError as err:
resp = jsonify({"error": err.messages})
resp.status_code = 403
return resp
except SQLAlchemyError as e:
db.session.rollback()
resp = jsonify({"error": str(e)})
resp.status_code = 403
return resp
def post(self):
raw_dict = request.get_json(force=True)
try:
schema.validate(raw_dict)
user_dict = raw_dict['data']['attributes']
user = Users(
user_dict['email'],
generate_password_hash(user_dict['password']),
user_dict['name'],
user_dict['is_active'])
user.add(user)
query = Users.query.get(user.id)
results = schema.dump(query).data
return results, 201
except ValidationError as err:
resp = jsonify({"error": err.messages})
resp.status_code = 403
return resp
except SQLAlchemyError as e:
db.session.rollback()
resp = jsonify({"error": str(e)})
resp.status_code = 403
return resp
def fetch_and_create_user(twitter_id):
user = Users.query.filter_by(twitter_id=twitter_id).first()
if user:
return user
else:
print('Fetching user from twitter with twitter_id:', twitter_id)
user_data = twitter_api.get_user(twitter_id)
user = Users(user_data)
user.add(user)
user = Users.query.get(user.id)
return user
def post(self):
raw_dict = request.get_json(force=True)
try:
schema.validate(raw_dict)
request_dict = raw_dict['data']['attributes']
role = None
active = 0
classified = 0
in_queue = 0
#Check for existing entry
userCheck = Users.query.filter_by(
email=request_dict['email']).first()
if userCheck is None:
user = Users(request_dict['email'],
generate_password_hash(request_dict['password']),
request_dict['name'], active, role, classified,
in_queue)
user.add(user)
query = Users.query.get(user.id)
# Should not return password hash
query.password = "******"
results = schema.dump(query).data
fp = os.getcwd()
fp = fp.rsplit('/', 1)[0] # go back one dir
direct = fp + "/GT_USERS/USER_" + str(query.id)
if not os.path.exists(direct):
os.makedirs(direct)
os.makedirs(direct + "/cropped")
os.makedirs(direct + "/images")
os.makedirs(direct + "/json")
os.makedirs(direct + "/labelled")
os.makedirs(direct + "/packaged")
os.makedirs(direct + "/segmented")
return results, 201
else:
resp = jsonify({"error": "Email already taken"})
resp.status_code = 403
return resp
except ValidationError as err:
resp = jsonify({"error": err.messages})
resp.status_code = 403
return resp
except SQLAlchemyError as e:
db.session.rollback()
resp = jsonify({"error": str(e)})
resp.status_code = 403
return resp
def post(self):
raw_dict = request.get_json(force=True)
try:
schema.validate(raw_dict)
user_dict = raw_dict["data"]["attributes"]
user = Users(user_dict["email"], user_dict["name"], user_dict["is_active"])
user.add(user)
query = Users.query.get(user.id)
results = schema.dump(query).data
return results, 201
except ValidationError as err:
resp = jsonify({"error": err.messages})
resp.status_code = 403
return resp
except SQLAlchemyError as e:
db.session.rollback()
resp = jsonify({"error": str(e)})
resp.status_code = 403
return resp
def post(self):
raw_dict = request.get_json(force=True)
try:
schema.validate(raw_dict)
request_dict = raw_dict['data']['attributes']
createdby = "Self Signup"
updatedby = "Self Signup"
password = generate_password_hash (request_dict['password'] )
user = Users(
request_dict['email'],
password,
request_dict['name'],
createdby,
updatedby ,
)
user.add(user)
# Should not return password hash
query = Users.query.get(user.id)
results = schema.dump(query).data
return results, 201
except ValidationError as err:
print(err.messages)
resp = jsonify({"error": err.messages})
resp.status_code = 403
return resp
except SQLAlchemyError as e:
db.session.rollback()
resp = jsonify({"error": str(e.orig.args)})
print(str(e))
resp.status_code = 403
return resp
def post(self):
raw_dict = request.get_json(force=True)
try:
schema.validate(raw_dict)
user_dict = raw_dict['data']['attributes']
user = Users(user_dict['firstname'], user_dict['lastname'],
user_dict['dob'], user_dict['zipcode'])
user.add(user)
query = Users.query.get(user.id)
results = schema.dump(query).data
return results, 201
except ValidationError as err:
resp = jsonify({"error": err.messages})
resp.status_code = 403
return resp
except SQLAlchemyError as e:
db.session.rollback()
resp = jsonify({"error": str(e)})
resp.status_code = 403
return resp
def post(self):
raw_dict = request.get_json(force=True)
try:
schema.validate(raw_dict)
request_dict = raw_dict['data']['attributes']
createdby = "Self Signup"
updatedby = "Self Signup"
password = generate_password_hash(request_dict['password'])
user = Users(
request_dict['email'],
password,
request_dict['name'],
createdby,
updatedby,
)
user.add(user)
# Should not return password hash
query = Users.query.get(user.id)
results = schema.dump(query).data
return results, 201
except ValidationError as err:
print(err.messages)
resp = jsonify({"error": err.messages})
resp.status_code = 403
return resp
except SQLAlchemyError as e:
db.session.rollback()
resp = jsonify({"error": str(e.orig.args)})
print(str(e))
resp.status_code = 403
return resp
def post(self):
raw_dict = request.get_json(force=True)
try:
schema.validate(raw_dict)
request_dict = raw_dict['data']['attributes']
payload = parse_token(request)
logged_user = Users.query.get(payload['sub'])
createdby = logged_user.name
updatedby = logged_user.name
password = generate_password_hash (request_dict['password'] )
user = Users(
request_dict['email'],
password,
request_dict['name'],
createdby,
updatedby ,
)
user.add(user)
# Should not return password hash
query = Users.query.get(user.id)
results = schema.dump(query).data
return results, 201
except ValidationError as err:
resp = jsonify({"error": err.messages})
resp.status_code = 403
return resp
except SQLAlchemyError as e:
db.session.rollback()
resp = jsonify({"error": str(e)})
resp.status_code = 403
return resp
def post(self):
raw_dict = request.get_json(force=True)
user_dict = raw_dict['data']['attributes']
try:
schema.validate(user_dict)
user = Users(user_dict['name'], user_dict['email'],
user_dict['address'], user_dict['website'],
user_dict['is_active'], user_dict['mobile'],
user_dict['Birthday'])
user.add(user)
query = Users.query.get(user.id)
results = schema.dump(query).data
return results, 201
except ValidationError as err:
resp = jsonify({"error": err.messages})
resp.status_code = 403
return resp
except SQLAlchemyError as e:
db.session.rollback()
resp = jsonify({"error": str(e)})
resp.status_code = 403
return resp
def post(self):
args_ = self.parser.parse_args()
password = args_['user_password']
hash_pw = bcrypt.hashpw(password.encode('utf-8'), bcrypt.gensalt())
user = Users(args_['user_id'], hash_pw, args_['user_email'])
return user.add(user, USERS_SCHEMA)
