def addFeature():
name = request.json['name']
url = request.json['url']
description = request.json['description']
menu_public_id = request.json['menu_public_id']
feature_type = request.json['feature_type']
if name == "" or menu_public_id == "":
responseObject = {'message': 'Not all fields are provided'}
return make_response(jsonify(responseObject)), 200
else:
new_feature = Feature(public_id=str(uuid.uuid4())[:8],
name=name,
url=url,
description=description,
menu_public_id=menu_public_id,
feature_type=feature_type if feature_type else 1,
created_at=datetime.now())
db.session.add(new_feature)
try:
db.session.commit()
close(db)
clearCache()
responseObject = {
'message': 'Successfully added the {0} Feature'.format(name)
}
return make_response(jsonify(responseObject)), 200
except Exception as identifier:
db.session.rollback()
close(db)
responseObject = {
'status': str(identifier),
'message': 'Could not add the menu'
}
return make_response(jsonify(responseObject)), 500
def updateFeature(public_id):
name = request.json['name']
descsription = request.json['description']
menu_public_id = request.json['menu_public_id']
feature = db.session.query(Feature).filter_by(public_id=public_id,
status=5).first()
if not feature:
responseObject = {'message': 'No such Feature is Available'}
return make_response(jsonify(responseObject)), 200
else:
try:
feature.name = name
feature.description = descsription
feature.menu_public_id = menu_public_id
feature.updated_at = datetime.now()
db.session.commit()
close(db)
clearCache()
responseObject = {
'message': 'Successfully added the {0} Feature'.format(name)
}
return make_response(jsonify(responseObject)), 200
except Exception as identifier:
db.session.rollback()
close(db)
responseObject = {
'status': str(identifier),
'message': 'Could not add the feature'
}
return make_response(jsonify(responseObject)), 500
def updateMenu(public_id):
name = request.json['name']
rating = request.json['rating']
descsription = request.json['description']
menu = db.session.query(Menu).filter_by(public_id=public_id).first()
if not menu:
responseObject = {'message': 'No such Menu is Available'}
return make_response(jsonify(responseObject)), app.config['ERROR_CODE']
else:
try:
menu.name = name
menu.description = descsription
menu.rating = rating
menu.updated_at = datetime.now()
db.session.commit()
responseObject = {
'message': 'Successfully updated the {0} Menu'.format(name)
}
return make_response(jsonify(responseObject)), 200
except Exception as identifier:
db.session.rollback()
close(db)
clearCache()
responseObject = {
'status': str(identifier),
'message': 'Could not add the feature'
}
return make_response(jsonify(responseObject)), 500
def updateRole(public_id):
name = request.json['name']
descsription = request.json['description']
role = db.session.query(Usertype).filter_by(public_id=public_id).first()
if not role:
responseObject = {'message': 'No such Role is Available'}
return make_response(jsonify(responseObject)), app.config['ERROR_CODE']
else:
try:
role.name = name
role.description = descsription
role.updated_at = datetime.now()
db.session.commit()
close(db)
clearCache()
responseObject = {
'message': 'Successfully added the {0} Role'.format(name)
}
return make_response(jsonify(responseObject)), 200
except Exception as identifier:
db.session.rollback()
close(db)
responseObject = {
'status': str(identifier),
'message': 'Could not add the role'
}
return make_response(jsonify(responseObject)), 500
def addMenu():
name = request.json['name']
rating = request.json['rating']
description = request.json['description']
if name.strip() is None:
responseObject = {'message': 'Not all fields are provided'}
return make_response(jsonify(responseObject)), 200
else:
new_menu = Menu(public_id=str(uuid.uuid4())[:8],
name=name,
rating=rating,
description=description,
created_at=datetime.now())
db.session.add(new_menu)
try:
db.session.commit()
close(db)
clearCache()
responseObject = {
'message': 'Successfully added the {0} Menu'.format(name)
}
return make_response(jsonify(responseObject)), 200
except Exception as identifier:
db.session.rollback()
close(db)
responseObject = {
'status': str(identifier),
'message': 'Could not add the menu'
}
return make_response(jsonify(responseObject)), 500
def updateUser(public_id):
user = db.session.query(User).filter_by(public_id=public_id).first()
if not user:
return jsonify({'message': 'User Not Found'}), 412
else:
first_name = request.json['first_name']
last_name = request.json['last_name']
email = request.json['email']
phone_number = request.json['phone_number']
user_type = request.json['user_type']
user.first_name = first_name
user.last_name = last_name
user.email = email
user.phone_number = phone_number
user.user_type = user_type
try:
db.session.commit()
close(db)
clearCache()
responseObject = {'message': 'Successfully updated'}
return make_response(jsonify(responseObject)), 200
except Exception as identifier:
responseObject = {'error': str(identifier)}
return make_response(jsonify(responseObject)), 500
def updateUserType(public_id):
name = request.json['name']
desc = request.json['description']
if name == " " or desc == " ":
responseObject = {'message': 'not all fields have been provided'}
return make_response(jsonify(responseObject)), 201
else:
usertype = db.session.query(Usertype).filter_by(
public_id=public_id).first()
if not usertype:
responseObject = {'message': 'Could not find the user type'}
return make_response(jsonify(responseObject)), 404
else:
usertype.name = name
usertype.description = desc
updated_at = datetime.now()
try:
db.session.commit()
close(db)
clearCache()
responseObject = {'message': 'Successfully updated'}
return make_response(jsonify(responseObject)), 200
except Exception as identifier:
responseObject = {'error': str(identifier)}
return make_response(jsonify(responseObject)), 500
def deleteRole(public_id):
role = db.session.query(Usertype).filter_by(public_id=public_id).first()
if not role:
responseObject = {'message': 'Could not find the role'}
return make_response(jsonify(responseObject)), 200
else:
role.status = 10
role.updated_at = datetime.now()
db.session.commit()
close(db)
clearCache()
responseObject = {'message': 'Successfully deleted '}
return make_response(jsonify(responseObject)), 200
def unsuspendUser(public_id):
user = db.session.query(User).filter_by(public_id=public_id,
status=15).first()
if not user:
return jsonify('User Not Found')
else:
user.status = 5
user.updated_at = datetime.now()
try:
db.session.commit()
close(db)
clearCache()
responseObject = {'message': 'Successfully unsuspended'}
return make_response(jsonify(responseObject)), 200
except Exception as identifier:
responseObject = {'error': str(identifier)}
return make_response(jsonify(responseObject)), 500
def deleteUserType(public_id):
usertype = db.session.query(Usertype).filter_by(
public_id=public_id).first()
if not usertype:
responseObject = {'message': 'Could not find the user type'}
return make_response(jsonify(responseObject)), 404
else:
usertype.status = 10
usertype.deletion_marker = 1
try:
db.session.commit()
close(db)
clearCache()
responseObject = {'message': 'Successfully deleted'}
return make_response(jsonify(responseObject)), 200
except Exception as identifier:
responseObject = {'error': str(identifier)}
return make_response(jsonify(responseObject)), 500
def addUserType():
name = request.json['name']
desc = request.json['description']
if name == " " or desc == " ":
responseObject = {'message': 'not all fields have been provided'}
return make_response(jsonify(responseObject)), 201
else:
new_type = Usertype(public_id=str(uuid.uuid4())[:8],
name=name,
description=desc,
status=5,
created_at=datetime.now())
db.session.add(new_type)
try:
db.session.commit()
close(db)
clearCache()
responseObject = {'message': 'Successfully added'}
return make_response(jsonify(responseObject)), 200
except Exception as identifier:
responseObject = {'error': str(identifier)}
return make_response(jsonify(responseObject)), 500
def save_to_db(self): db.session.add(self) db.session.commit() clearCache() close(db)
def userSignup():
auth_header = request.headers.get('Authorization')
if auth_header:
try:
auth_token = auth_header.split(" ")[1]
except IndexError as identifier:
responseObject = {
'status': 'failed',
'message': 'Beared token malformed'
}
return make_response(jsonify(make_response)), 401
else:
auth_token = ''
responseObject = {'message': 'Token is missing'}
return make_response(jsonify(responseObject)), 404
if auth_token:
resp = User.decode_auth_token(auth_token)
if resp == "Signature expired. Please log in again":
return jsonify(
{"message": "Signature expired. Please log in again"}), 422
user = db.session.query(User).filter_by(
public_id=resp,
status=5).filter(User.instituition_id == None).first()
first_name = request.json['first_name']
last_name = request.json['last_name']
email = request.json['email']
phone_number = request.json['phone_number']
user_type = request.json['user_type']
password = str(uuid.uuid4())[:10]
# check if user exists
user = db.session.query(User).filter_by(
email=email, phone_number=phone_number).first()
if db.session.query(User).filter_by(email=email).filter(
User.deletion_marker == None).first():
responseObject = {
'status': 'fail',
'message': 'User already exists. Please Log in.',
}
return make_response(jsonify(responseObject)), 422
else:
try:
#continue with registration
u_ublic_id = str(uuid.uuid4())[:15]
user = User(
public_id=u_ublic_id,
first_name=first_name,
last_name=last_name,
email=email,
phone_number=phone_number,
user_type=user_type,
session_id=resp,
password=bcrypt.generate_password_hash(
password,
app.config['BCRYPT_LOG_ROUNDS']).decode('utf-8'),
created_at=datetime.now())
db.session.add(user)
# generate and auth token
payload = {
'exp': datetime.utcnow() + timedelta(days=1, seconds=5),
'iat': datetime.utcnow(),
'sub': u_ublic_id
}
auth_token = jwt.encode(payload,
app.config['SECRET_KEY'],
algorithm='HS256')
# auth_token = user.encode_auth_token(u_ublic_id)
token = Token(public_id=str(uuid.uuid4())[:8],
token=auth_token.decode('utf-8'),
user_public_id=u_ublic_id,
client_id=1,
scopes='[]',
created_at=datetime.now())
db.session.add(token)
try:
#commit to the database
db.session.commit()
close(db)
clearCache()
datenow = (datetime.now()).strftime("%B %Y")
#send email to partner user
recipients = email
sender = app.config['MAIL_ADDRESS']
sg = sendgrid.SendGridAPIClient(
apikey=app.config['SENDGRID_API_KEY'])
from_email = Email(sender)
to_email = Email(recipients)
subject = "User Registration"
full_name = first_name.strip().title(
) + " " + last_name.strip().title()
pass_data = {
'confirm_account_url': app.config['REGISTRATION_URL'],
'username': email,
'full_name': full_name,
'datenow': datenow,
'password': password,
'copyright_year': datetime.now().strftime("%Y")
}
content = Content(
"text/html",
render_template('account.html', data=pass_data))
mail = Mail(from_email, subject, to_email, content)
response = sg.client.mail.send.post(
request_body=mail.get())
responseObject = {
'message':
'Successfully Registered {0}'.format(full_name)
# 'access_token' : auth_token.decode()
}
return make_response(jsonify(responseObject)), 200
except Exception as identifier:
db.session.rollback()
close(db)
clearCache()
responseObject = {
'message': str(identifier),
'error': 'From commit try & catch'
}
return make_response(jsonify(responseObject)), 202
except Exception as identifier:
db.session.rollback()
close(db)
clearCache()
responseObject = {
'error':
str(identifier),
'message':
'Some error occurred. Please try again. under if not'
}
return make_response(jsonify(responseObject)), 401
def partnerSignup():
first_name = request.json['first_name']
last_name = request.json['last_name']
email = request.json['email']
phone_number = request.json['phone_number']
user_type = request.json['user_type']
session_id = request.json['session_id']
partner_public_id = request.json['partner_public_id']
empty_set = []
if not partner_public_id or not user_type:
empty_set.append("Not all fields are provided")
if empty_set:
responseObject = {'messages': empty_set}
return make_response(jsonify(responseObject)), 422
# check if user exists
user = db.session.query(User).filter_by(
email=email, phone_number=phone_number).filter(
User.deletion_marker == None).first()
if user:
responseObject = {
'status': 'fail',
'message': 'User already exists. Please Log in.',
}
return make_response(jsonify(responseObject)), 202
else:
try:
#continue with registration
u_ublic_id = str(uuid.uuid4())[:15]
generate_password = str(uuid.uuid4())[:8]
# generate_password = '******'
# check if an Admin exists
admin_exits = db.session.query(User).filter_by(
instituition_id=partner_public_id,
partner_admin_status=100).filter(
User.deletion_marker == None).first()
if admin_exits:
user = User(
public_id=u_ublic_id,
first_name=first_name,
last_name=last_name,
email=email,
phone_number=phone_number,
user_type=user_type,
session_id=session_id,
password=bcrypt.generate_password_hash(
generate_password,
app.config['BCRYPT_LOG_ROUNDS']).decode('utf-8'),
instituition_id=partner_public_id,
created_at=datetime.now())
else:
user = User(
public_id=u_ublic_id,
first_name=first_name,
last_name=last_name,
email=email,
phone_number=phone_number,
user_type=user_type,
session_id=session_id,
password=bcrypt.generate_password_hash(
generate_password,
app.config['BCRYPT_LOG_ROUNDS']).decode('utf-8'),
instituition_id=partner_public_id,
created_at=datetime.now(),
partner_admin_status=100)
db.session.add(user)
# generate and auth token
payload = {
'exp': datetime.utcnow() + timedelta(days=1, seconds=5),
'iat': datetime.utcnow(),
'sub': u_ublic_id
}
auth_token = jwt.encode(payload,
app.config['SECRET_KEY'],
algorithm='HS256')
# auth_token = user.encode_auth_token(u_ublic_id)
token = Token(public_id=str(uuid.uuid4())[:8],
token=auth_token.decode('utf-8'),
user_public_id=u_ublic_id,
client_id=1,
scopes='[]',
created_at=datetime.now())
db.session.add(token)
try:
#commit to the database
db.session.commit()
close(db)
clearCache()
datenow = (datetime.now()).strftime("%B %Y")
#send email to partner user
recipients = email
sender = app.config['MAIL_ADDRESS']
sg = sendgrid.SendGridAPIClient(
apikey=app.config['SENDGRID_API_KEY'])
from_email = Email(sender)
to_email = Email(recipients)
subject = "Partner User Registration"
pass_data = {
'confirm_account_url':
app.config['REGISTRATION_URL'],
'username':
email,
'full_name':
first_name.strip().title() + " " +
last_name.strip().title(),
'datenow':
datenow,
'password':
generate_password,
'copyright_year':
datetime.now().strftime("%Y")
}
content = Content(
"text/html",
render_template('user_registration.html', data=pass_data))
mail = Mail(from_email, subject, to_email, content)
response = sg.client.mail.send.post(request_body=mail.get())
full_name = first_name.strip().title() + " " + last_name.strip(
).title()
responseObject = {
'message': 'Successfully Registered {0}'.format(full_name)
}
return jsonify(responseObject), 200
except Exception as identifier:
db.session.rollback()
close(db)
clearCache()
print(str(identifier))
responseObject = {
'error_message': str(identifier),
'error': 'From commit try & catch'
}
return make_response(jsonify(responseObject)), 202
except Exception as identifier:
db.session.rollback()
close(db)
responseObject = {
'error': str(identifier),
'message':
'Some error occurred. Please try again. under if not'
}
return make_response(jsonify(responseObject)), 401
def clear_cache_url():
clearCache()
return jsonify({"message": "Cache cleared"})
