def post(self):
if request.content_type == 'application/json':
post_data = request.get_json()
email = post_data.get('email')
name = post_data.get('name')
username = post_data.get('username')
password = post_data.get('password')
if re.match(r"[^@]+@[^@]+\.[^@]+", email) and len(password) > 4:
user = User.query.filter_by(email=email).first()
if not user:
try:
user = User(email=email,
password=password,
username=username,
name=name)
db.session.add(user)
db.session.commit()
token = user.encode_auth_token(user.id)
return response_token('success',
'Successfully registered', token,
201)
except Exception as e:
return response('failed', 'Error occured, try again',
401)
else:
return response(
'failed', 'Failed, User already exists, Plese sign in',
400)
return response(
'failed',
'Missing or wrong email format or password is less than four chars',
400)
return response('failed', 'Content-type must be json', 400)
def update(current_user, workspaceId, projectId):
"""
Update a playground
Playground ID Is mandatory
:return: Http Json response
"""
if request.content_type == 'application/json':
playgroundId = request.get_json(force=True).get('playgroundId')
update_obj = request.get_json(force=True).get('updateObj')
if playgroundId:
playground = Playground.get_by_id(playgroundId)
if playground:
playground.update(update_obj)
playgroundObj = {
'playgroundType': playground.playgroundType,
'id': playground._id,
'createdBy': playground.createdBy,
'lastModified': playground.lastModified,
'playgroundMeta': playground.playgroundMeta
}
return response_with_obj('success',
'Playground updated successfully',
playgroundObj, 200)
else:
return response('failed', 'playground not found', 404)
else:
return response(
'failed', 'Playground ID is required in the request payload.',
402)
else:
return response('failed', 'Content-type must be json', 402)
def deactivate(current_user, workspaceId, projectId):
"""
Deactivate a service
Service ID Is mandatory
:return: Http Json response
"""
if request.content_type == 'application/json':
serviceId = request.get_json(force=True).get('serviceId')
if serviceId:
service = Service.get_by_id(serviceId)
if service:
service.deactivate()
res_payload = {
'serviceType': service.serviceType,
'id': service._id,
'createdBy': service.createdBy,
'createdOn': service.createdOn,
'isActive': service.isActive,
'serviceMeta': service.serviceMeta
}
return response_with_obj('success', 'Service deactivated successfully', res_payload, 200)
else:
return response('failed', 'service not found', 404)
else:
return response('failed', 'Service ID is required in the request payload.', 402)
else:
return response('failed', 'Content-type must be json', 402)
def delete(current_user, workspaceId, projectId):
"""
Delete a playground if playground is unpublished else does nothing
Playground ID Is mandatory
:return: Http Json response
"""
if request.content_type == 'application/json':
playgroundId = request.get_json(force=True).get('playgroundId')
if playgroundId:
playground = Playground.get_by_id(playgroundId)
if playground:
if playground.isPublished:
return response(
'failed',
'Cannot delete a playground that has been published',
400)
else:
playground.isRemoved = True
playground.save()
return response('success', 'Playground deleted.', 200)
else:
return response('failed', 'playground not found', 404)
else:
return response(
'failed', 'Playground ID is required in the request payload.',
402)
else:
return response('failed', 'Content-type must be json', 402)
def post(self):
"""
Register a user, generate their token and add them to the database
:return: Json Response with the user`s token
"""
if request.content_type == 'application/json':
post_data = request.get_json()
email = post_data.get('email')
password = post_data.get('password')
username = post_data.get('username')
if re.match(r"[^@]+@[^@]+\.[^@]+",
email) and len(password) > 4 and len(username) > 3:
user = User.get_by_email(email)
if not user:
token = User(email=email,
password=password,
username=username).save()
return response_auth('success', 'Successfully registered',
token, 201)
else:
return response(
'failed',
'Failed, User already exists, Please sign In', 400)
return response(
'failed',
'Missing or wrong email format or password is less than four characters',
400)
return response('failed', 'Content-type must be json', 400)
def update(current_user, workspaceId, projectId):
"""
Update Appointments
"""
if request.content_type == 'application/json':
post_data = request.get_json()
if 'id' not in post_data:
return response('failed', 'Appointment Id required', 402)
else:
app = Appointment.get_by_id(post_data.get('id'))
if app:
app.update_appointment(post_data)
res_payload = {
'id':app._id,
'start': app.startDate,
'end': app.endDate,
'title': app.participantName,
'phone': app.participantPhone,
'email': app.participantEmail,
'isActive': app.isActive,
'provider': app.provider,
'location': app.location,
'cssClass': 'ACTIVE' if app.isActive else 'DELETED'
}
return response_with_obj('success', 'Appointment updated successfully', res_payload, 200)
else:
response('failed', 'Appointment not found', 402)
else:
return response('failed', 'Content-type must be json', 402)
def post(self):
"""
Login a user if the supplied credentials are correct.
:return: Http Json response
"""
if 'application/json' in request.content_type:
post_data = request.get_json()
email = post_data.get('email')
password = post_data.get('password')
if re.match(r"[^@]+@[^@]+\.[^@]+", email) and len(password) > 4:
user = User.query.filter_by(email=email).first()
if user and bcrypt.check_password_hash(user.password,
password):
return response_auth('success',
'Successfully logged In',
user.encode_auth_token(user.id),
200,
user=user)
return response(
'failed', 'User does not exist or password is incorrect',
401)
return response(
'failed',
'Missing or wrong email format or password is less than four characters',
401)
return response('failed', 'Content-type must be json', 202)
def reset(current_user, workspaceId, projectId):
"""
Publish a playground
Playground ID Is mandatory
:return: Http Json response
"""
if request.content_type == 'application/json':
playgroundId = request.get_json(force=True).get('playgroundId')
if playgroundId:
playground = Playground.get_by_id(playgroundId)
if playground:
bot = Bot.get_by_id(playground.parentMarketplaceBot)
playgroundMeta = bot.botMeta
playgroundMeta["mediaUrl"] = bot.marketplaceCardMediaUrl
playgroundMeta["name"] = playground.playgroundMeta.get("name")
playground.playgroundMeta = playgroundMeta
playground.save()
return response('success', 'playground reset successful', 200)
else:
return response('failed', 'playground not found', 404)
else:
return response(
'failed', 'Playground ID is required in the request payload.',
402)
else:
return response('failed', 'Content-type must be json', 402)
def create(current_user, workspaceId, projectId):
"""
Create a service. Reuires login
"""
if request.content_type == 'application/json':
post_data = request.get_json(force=True)
required_keys = ['serviceType', 'serviceMeta']
if all(name in post_data for name in required_keys):
service = Service(serviceType=post_data.get('serviceType'),
serviceMeta=post_data.get('serviceMeta'),
projectId=projectId,
createdBy=current_user.email_id)
service.create()
# add to project
project = Project.get_by_id(projectId)
project.services.append(service._id)
project.save()
# Replcing _id with id
service_obj = json.loads(service.to_json())
service_obj['id'] = service_obj['_id']
service_obj.pop('_id', None)
return response_with_obj('success', 'Service created successfully', service_obj, 200)
else:
return response('failed', 'Required data not found in POST body.', 402)
return response('failed', 'Content-type must be json', 402)
def remove(current_user, workspaceId, projectId):
"""
Remove Ticket By Id
"""
if request.content_type == 'application/json':
post_data = request.get_json()
if 'id' not in post_data:
return response('failed', 'Ticket Id required', 402)
else:
ticket = Ticket.get_by_id(post_data.get('id'))
if ticket:
ticket.delete_ticket(current_user)
res_payload = {
'id': ticket._id,
'firstName': ticket.firstName,
'lastName': ticket.lastName,
'category': ticket.category,
'status': ticket.status,
'notes': ticket.notes,
'channel': ticket.channel,
'createdOn': ticket.createdOn,
'phone': ticket.phone,
'email': ticket.email
}
return response_with_obj('success',
'Ticket deleted successfully',
res_payload, 200)
else:
response('failed', 'Ticket not found', 402)
else:
return response('failed', 'Content-type must be json', 402)
def remove(current_user, workspaceId, projectId):
"""
Remove Lead By Id
"""
if request.content_type == 'application/json':
post_data = request.get_json()
if 'id' not in post_data:
return response('failed', 'Lead Id required', 402)
else:
lead = Lead.get_by_id(post_data.get('id'))
if lead:
lead.delete_lead(current_user)
res_payload = {
'id':lead._id,
'firstName': lead.firstName,
'lastName': lead.lastName,
'country': lead.country,
'address': lead.address,
'age': lead.age,
'dob': lead.dateOfBirth,
'sex': lead.sex,
'channel': lead.channel,
'createdOn': lead.createdOn,
'city': lead.city,
'phone': lead.phone,
'email': lead.email
}
return response_with_obj('success', 'Lead deleted successfully', res_payload, 200)
else:
response('failed', 'Lead not found', 402)
else:
return response('failed', 'Content-type must be json', 402)
def get(current_user):
"""
Get a workspace by workspace id
:return: Http Json response
"""
wsp_id = request.args.get('workspaceId')
if wsp_id in current_user.workspaces:
workspace = Workspace.get_by_id(wsp_id)
if workspace:
projects = workspace.projects
prj_payload = []
for pid in projects:
prj = Project.get_by_id(pid)
if prj:
prj_name = prj.name
prj_obj = {'id': pid, 'name': prj_name}
prj_payload.append(prj_obj)
return {
'name': workspace.name,
'id': workspace._id,
'createdBy': workspace.createdBy,
'createdOn': workspace.createdOn,
'isActive': workspace.isActive,
'projects': prj_payload
}
else:
return response('failed', 'workspace not found', 404)
else:
return response('failed', 'user not authorized to access workspace',
403)
def signup():
"""
Signup a user using name, email, password.
:return: Http Json response
"""
if request.content_type == 'application/json':
post_data = request.get_json(force=True)
email = post_data.get('email')
password = User.encode_password(post_data.get('password'))
name = post_data.get('name')
if re.match(r"[^@]+@[^@]+\.[^@]+", email):
user = User.get_by_email(email)
if user and user.isActive and user.isEmailVerified:
return response(
'failed',
'Email already registered. Use the Sign-in option', 401)
if user and user.isActive and not user.isEmailVerified:
token = user.get_auth_token()
confirm_url = url_for('auth.verify',
token=token,
_external=True)
html = render_template('activate.html',
confirm_url=confirm_url)
subject = "Fronteous Arena - Confirm your email address"
send_email(user.email_id, subject, html)
logger.bind(userId=user._id)
return response_auth('success', 'Successfully signed up.',
None, None, 200)
else:
user = User(email_id=email, name=name, password=password)
user.sign_up(userObj=post_data)
if not user.isEmailVerified: #If email is not verified. Not email at this stage wil be verified only for invited users coming through invitation token
token = user.get_auth_token()
confirm_url = url_for('auth.verify',
token=token,
_external=True)
html = render_template('activate.html',
confirm_url=confirm_url)
subject = "Fronteous Arena - Confirm your email address"
send_email(user.email_id, subject, html)
logger.bind(userId=user._id)
return response_auth('success', 'Successfully signed up.',
None, None, 200)
return response(
'failed',
'Missing or wrong email format or password is less than four characters',
400)
return response('failed', 'Content-type must be json', 402)
def verify():
verifyToken = request.args.get('token')
email = User.decode_verify_token(verifyToken)
user = User.get_by_email(email)
if user and not user.isEmailVerified:
user.modify(isEmailVerified=True)
return response('success', 'Email has been verified.', 200)
if user and user.isEmailVerified:
return response('success', 'Account already confirmed. Please login.',
200)
else:
return response('failed', 'Invalid Token. Email not found', 401)
def add(current_user, workspaceId, projectId):
"""
Create Appointments
"""
if request.content_type == 'application/json':
post_data = request.get_json()
app = Appointment(
participantName=post_data.get('participantName'),
startDate=post_data.get('startDate'),
endDate=post_data.get('endDate'),
participant=post_data.get('participant'),
appointmentChannel=post_data.get('appointmentChannel'),
participantPhone=post_data.get('participantPhone'),
projectId=projectId
)
app.create()
res_payload = {
'id':app._id,
'start': app.startDate,
'end': app.endDate,
'title': app.participantName,
'phone': app.participantPhone,
'email': app.participantEmail,
'isActive': app.isActive,
'provider': app.provider,
'location': app.location,
'cssClass': 'ACTIVE' if app.isActive else 'DELETED'
}
return response_with_obj('success', 'Appointment created successfully', res_payload, 200)
else:
return response('failed', 'Content-type must be json', 402)
def route_not_found(e):
"""
Return a custom 404 Http response message for missing or not found routes.
:param e: Exception
:return: Http Response
"""
return response('failed', 'Endpoint not found', 404)
def internal_server_error(e):
"""
Return a custom message for a 500 internal error
:param e: Exception
:return:
"""
return response('failed', 'Internal server error', 500)
def get(current_user, workspaceId, projectId):
"""
Get a project by project id
:return: Http Json response
"""
project = Project.get_by_id(projectId)
if project:
services = project.services
srv_payload = []
for sid in services:
srv = Service.get_by_id(sid)
if srv:
srv_obj = {
'id': srv._id,
'serviceType': srv.serviceType,
'serviceMeta': srv.serviceMeta,
'isActive': srv.isActive
}
srv_payload.append(srv_obj)
return {
'name': project.name,
'id': project._id,
'createdBy': project.createdBy,
'createdOn': project.createdOn,
'isActive': project.isActive,
'services': srv_payload,
'timezone': project.timezone
}
else:
return response('failed', 'project not found', 404)
def get(current_user, workspaceId, projectId):
"""
Get a service by service id or project id
:return: Http Json response
"""
serviceId = request.args.get('serviceId')
if serviceId:
# Get by Service ID
service = Service.get_by_id(serviceId)
if service:
return {
'serviceType': service.serviceType,
'id': service._id,
'createdBy': service.createdBy,
'createdOn': service.createdOn,
'isActive': service.isActive,
'serviceMeta': service.serviceMeta
}
else:
return response('failed', 'service not found', 404)
else:
# Get by Project ID
project = Project.get_by_id(projectId)
services = project.services
payload = []
for service_id in services:
service = Service.get_by_id(service_id)
payload.append({"id": service_id,
"serviceType": service.serviceType,
"isActive": service.isActive,
"serviceMeta": service.serviceMeta})
return {'services': payload}
def get(current_user):
"""
Get a project by workspace id, projectId
:return: Http Json response
"""
if current_user:
workspaces = current_user.workspaces
wsp_payload=[]
for wspid in workspaces:
print (wspid)
wsp = Workspace.get_by_id(wspid)
if wsp:
wsp_name = wsp.name
wsp_obj = {'id': wspid, 'name': wsp_name}
wsp_payload.append(wsp_obj)
return {
'name': current_user.name,
'id': current_user._id,
'email': current_user.email_id,
'registeredOn' : current_user.registeredOn,
'isActive' : current_user.isActive,
'isEmailVerified' : current_user.isEmailVerified,
'isRemoved' : current_user.isRemoved,
'workspaces' : wsp_payload
}
else:
return response('failed', 'user not found', 404)
def create(current_user, workspaceId, projectId):
"""
Create a playground. Reuires login
"""
if request.content_type == 'application/json':
post_data = request.get_json(force=True)
required_keys = ['botId', 'name']
if all(name in post_data for name in required_keys):
bot = Bot.get_by_id(
post_data.get('botId')
) # bot id is fronteous generated. bot is is for a specific
# version of agent from dialogflow
if not bot:
return response('failed', 'Bot not found in the marketplace',
404)
playgroundMeta = bot.botMeta
playgroundMeta["mediaUrl"] = bot.marketplaceCardMediaUrl
playgroundMeta["name"] = post_data.get("name")
playground = Playground(playgroundType='bot',
playgroundMeta=playgroundMeta,
projectId=projectId,
parentMarketplaceBot=bot._id,
publishedServiceId=post_data.get(
"name", None),
createdBy=current_user.email_id)
playground.create()
# add to project
# project = Project.get_by_id(projectId)
# project.services.append(playground._id)
# project.save()
# Replcing _id with id
playground_obj = json.loads(playground.to_json())
playground_obj['id'] = playground_obj['_id']
playground_obj.pop('_id', None)
return response_with_obj('success',
'Playground created successfully',
playground_obj, 200)
else:
return response('failed', 'Required data not found in POST body.',
402)
return response('failed', 'Content-type must be json', 402)
def method_not_found(e):
"""
Custom response for methods not allowed for the requested URLs
:param e: Exception
:return:
"""
return response('failed',
'The method is not allowed for the requested URL', 405)
def post(self):
"""
Register a user, generate their token and add them to the database
:return: Json Response with the user`s token
"""
if request.content_type == 'application/json':
post_data = request.get_json()
email = post_data.get('email')
password = post_data.get('password')
name = post_data.get('name')
surname = post_data.get('surname')
birthday_value = post_data.get('birthday')
if not email:
return response('failed', 'Missing email attribute', 400)
if not password:
return response('failed', 'Missing password attribute', 400)
if not name:
return response('failed', 'Missing name attribute', 400)
if not surname:
return response('failed', 'Missing surname attribute', 400)
if not birthday_value:
return response('failed', 'Missing birthday attribute', 400)
try:
birthday = isoparse(str(birthday_value))
except ValueError:
return response('failed', 'Wrong birthday attribute type', 400)
if re.match(r"[^@]+@[^@]+\.[^@]+", email) and len(password) > 4:
user = User.get_by_email(email)
if not user:
token = User(email, password, name, surname,
birthday).save()
return response_auth('success', token, 201)
else:
return response(
'failed',
'Failed, User already exists, Please sign In', 400)
return response(
'failed',
'Missing or wrong email format or password is less than four characters',
400)
return response('failed', 'Content-type must be json', 400)
def logout():
"""
Try to logout a user using a token
:return:
"""
auth_header = request.headers.get('Authorization')
if auth_header:
try:
auth_token = auth_header.split(" ")[1]
except IndexError:
return response('failed', 'Provide a valid auth token', 401)
else:
# decoded_token_response = User.decode_auth_token(auth_token)
token = BlackListToken(auth_token)
token.blacklist()
return response('success', 'Successfully logged out', 200)
return response('failed', 'Provide an authorization header', 403)
def create(current_user):
"""
Create a workspace. Reuires login
"""
if request.content_type == 'application/json':
post_data = request.get_json(force=True)
if 'name' in post_data.keys():
workspace = Workspace(name=post_data.get('name'))
workspace.createdBy = current_user.email_id
workspace.create()
current_user.workspaces.append(workspace._id)
current_user.save()
return response_with_id('success',
'Workspace created successfully',
workspace._id, 200)
else:
return response('failed', 'name field required in json body', 402)
return response('failed', 'Content-type must be json', 402)
def post(self):
if request.content_type == 'application/json':
post_data = request.get_json()
email = post_data.get('email')
password = post_data.get('password')
if re.match(r"[^@]+@[^@]+\.[^@]+", email) and len(password) > 4:
user = User.get_by_email(email)
if user and bcrypt.check_password_hash(user.password,
password):
return response_auth('success', 'Successfully logged in',
user.encode_auth_token(user.id), 200,
user.id, email)
return response(
'failed', 'User does not exist or password is incorrect',
401)
return response(
'failed',
'Missing or wrong email format or password is less than four chars',
401)
return response('failed', 'Content-type must be json', 202)
def get(current_user, workspaceId, projectId):
"""
Get Appointments
"""
start = request.args.get('start')
end = request.args.get('end')
if start == None or end == None:
return response('failed', 'Start and End Timestamp required.', 402)
else:
appointment_list = Appointment.get_appointments(start, end, projectId)
return {"appointments":appointment_list}
def login():
"""
Login a user if the supplied credentials are correct.
:return: Http Json response
"""
if request.content_type == 'application/json':
post_data = request.get_json(force=True)
email = post_data.get('email')
password = User.encode_password(post_data.get('password'))
if re.match(r"[^@]+@[^@]+\.[^@]+", email) and password:
user = User.get_by_email(email)
# password = User.encode_password(password)
if user and not user.isEmailVerified:
return response(
'failed',
'Email not verified. Sign-up again to verify email.', 400)
if user and not user.isRemoved:
if not (user.registeredOn or user.isActive):
user.password = password
user.sign_up(userObj=post_data)
if password == user.password:
logger.bind(userId=user._id)
accessToken = user.get_auth_token()
return response_auth(
'success', 'Successfully logged In', accessToken,
os.getenv('AUTH_TOKEN_EXPIRY_SECONDS'), 200)
else:
return response('failed', 'Wrong Password', 403)
else:
logger.error('USER_NOT_FOUND', email=email)
return response('failed', 'User not found', 401)
return response(
'failed',
'Missing or wrong email format or password is less than four characters',
400)
return response('failed', 'Content-type must be json', 402)
def get(current_user, workspaceId, projectId):
"""
Get Chats for a conversation
"""
conversationId = request.args.get('conversationId')
if not conversationId:
return response('failed', 'Need conversation Id in query params.', 402)
chatLogObj = ChatLog.get_by_id(conversationId)
return response_with_obj("success", "Chat Log retrieved", chatLogObj, 200)
def publish(current_user, workspaceId, projectId):
"""
Publish a playground
Playground ID Is mandatory
:return: Http Json response
"""
if request.content_type == 'application/json':
playgroundId = request.get_json(force=True).get('playgroundId')
priceContract = request.get_json(force=True).get('priceContract')
if playgroundId:
playground = Playground.get_by_id(playgroundId)
if playground:
srv_id = playground.publish(projectId, current_user,
priceContract)
return response('success', srv_id, 200)
else:
return response('failed', 'playground not found', 404)
else:
return response(
'failed', 'Playground ID is required in the request payload.',
402)
else:
return response('failed', 'Content-type must be json', 402)
