def login():
# return redirect(url_for('index'))
form = LoginForm()
# if form.validate_on_submit():
user = User.query.filter_by(username=form.username.data).first()
app.logger.warning("logging here: " + user.username)
if user is None or not user.check_password(form.password.data):
app.logger.warning("Oops here: " + user.username)
# # return redirect(url_for('login'))
return jsonify({
"message": "incorrect password",
"user": form.username.data,
"password": form.password.data
})
login_user(user, remember=form.remember_me.data)
app.logger.warning("logging here: " + current_user.username)
# return redirect(url_for(''))
if (current_user.prescriber_id):
user.prescriber = Prescriber.query \
.filter_by(id=current_user.prescriber_id).first()
user.dispenser = None
elif (current_user.dispenser_id):
user.dispenser = Dispenser.query \
.filter_by(id=current_user.dispenser_id).first()
user.prescriber = None
else:
return jsonify({
"user": UserSchema().dump(current_user).data,
"participantType": "superuser",
"participantId": None,
"participant": None
})
user_data = UserSchema().dump(user).data
return jsonify(user_data)
def add_user():
posted_user = UserSchema(only=("name", "email", "telegram",
"pw")).load(request.get_json())
user = User(**posted_user)
session = Session()
try:
session.add(user)
session.commit()
except Exception:
session.close()
return 'User with that name already exists', 500
new_user = UserSchema().dump(user)
session.close()
return jsonify(new_user), 200
def auth_schema(user_object):
'''
:param session:
:return:
'''
schema = UserSchema(many=True)
return schema.dump(user_object).data
def get_user(id):
session = Session()
user_object = session.query(User).filter(User.id == id).first()
schema = UserSchema()
user = schema.dump(user_object)
session.close()
return jsonify(user), 200
def get_user_schema(session):
'''
func ro deserialise the object uers
:param session:sqlachemy object
:return:list of json object
'''
schema = UserSchema(many=True)
user_object = fetch_users(session)
users = schema.dump(user_object)
return users.data
def get_users():
# Database
session = Session()
user_objects = session.query(User).all()
# Create serializable object
schema = UserSchema(many=True)
users = schema.dump(user_objects)
session.close()
return jsonify(users), 200
def login():
posted_creds = request.get_json()
username = posted_creds["name"]
session = Session()
user_object = session.query(User).filter(User.name == username).first()
schema = UserSchema()
user = schema.dump(user_object)
session.close()
if not user:
return jsonify({"error": "No user with that name"}), 200
if posted_creds["pw"] == user["pw"]:
return jsonify({"id": user["id"], "name": user["name"]}), 200
else:
return jsonify({"error": "Incorrect password"}), 200
def auth(session, json_data, secrete_key):
'''
:param session:
:param json_data:
:param secrete_key:
:return:
'''
user = session.query(User).filter(User.email == json_data['email']).first()
#print(user[0])
if user and check_password_hash(user.password, json_data['password']):
auth_token = encode_auth_token(user.role.name, secrete_key)
schema = UserSchema()
user_auth = schema.dump(user).data
user_auth["token"] = auth_token
return user_auth
else:
return {
'code': 401,
'message': 'login or password invalid. Please try again.'
}
def delete_users_schema(session):
schema = UserSchema(many=True)
schema.dump(delete_users(session))
def delete_user_schema(session, id):
schema = UserSchema(many=True)
schema.dump(delete_user(session, id))
from werkzeug.urls import url_parse
import logging
from src import app, db
from src.forms import LoginForm, ValidationError
from src.entities.dispenser import Dispenser, DispenserSchema
from src.entities.prescriber import Prescriber, PrescriberSchema, \
PrescriberStatistics, PrescriberStatisticsSchema
from src.entities.user import User, UserSchema
# from entities.dispenser import Dispenser
dispenser_schema = DispenserSchema()
dispensers_schema = DispenserSchema(many=True)
prescriber_schema = PrescriberSchema()
prescribers_schema = PrescriberSchema(many=True)
user_schema = UserSchema()
users_schema = UserSchema(many=True)
# routing from the request
@app.route('/')
def index():
return "Should not see this"
# handle dispensers routing
@app.route('/api/dispensers')
def get_dispensers():
all_dispensers = Dispenser.query.all()
dispensers_result = dispensers_schema.dump(all_dispensers)
return jsonify(dispensers_result.data)