def checkout():
try:
user = g.user
if not user.country:
raise Exception('Some thing went wrong')
payment_repo = PaymentRepo()
client_token = payment_repo.bt_generate_client_token()
if 'error' in client_token:
raise Exception('Some thing went wrong')
membership_plan = {
'id': str(user.country.id),
'amount': float(round(user.country.monthlyAmount)),
'currency': user.country.countryCurrency,
'frequency': 'Monthly'
}
return build_response.build_json({
'status':
True,
'braintree_token':
client_token['client_token'],
'membership_plan':
membership_plan
})
except Exception as e:
return build_response.build_json({"status": False, "error": str(e)})
def read_emojis():
"""
find list of emojis for the agent
:return:
"""
emojis = Emoji.objects()
if request.args.get('name'):
emojis = emojis.filter(name__iexact=request.args.get('name'))
if request.args.get('category'):
category = Category.objects(
name__iexact=request.args.get('category')).get()
emojis = emojis.filter(category=category)
if request.args.get('q'):
emojis = emojis.filter(tags__icontains=request.args.get('q'))
if request.args.get('isPaid'):
emojis = emojis.filter(isPaid=True) if request.args.get(
'isPaid').lower() == 'true' else emojis.filter(isPaid=False)
if not emojis:
return build_response.build_json([])
response_emojis = []
for emoji in emojis:
obj_emoji = transpose_emoji(emoji)
response_emojis.append(obj_emoji)
return build_response.build_json(response_emojis)
def find_countries():
"""
find list of countries for the agent
:return:
"""
page_nb = int(request.args.get('pageNumber'))
items_per_page = int(request.args.get('pageSize'))
offset = (page_nb - 1) * items_per_page if page_nb > 0 else 0
countries = Country.objects()
if request.args.get('name'):
countries = countries.filter(
CountryName__iexact=request.args.get('name'))
if not countries:
return build_response.build_json([])
countries = countries.order_by('displayOrder', 'CountryName')
#countries = skip( offset ).limit( items_per_page )
response_countries = []
for country in countries:
obj_country = transpose_country(country)
response_countries.append(obj_country)
return build_response.build_json({"payload": response_countries})
def find_vouchers():
"""
find list of vouchers for the agent
:return:
"""
page_nb = int(request.args.get('pageNumber'))
items_per_page = int(request.args.get('pageSize'))
offset = (page_nb - 1) * items_per_page if page_nb > 0 else 0
vouchers = Voucher.objects()
if request.args.get('name'):
vouchers = vouchers.filter(name__iexact=request.args.get('name'))
if request.args.get('code'):
vouchers = vouchers.filter(code__icontains=request.args.get('code'))
if not vouchers:
return build_response.build_json([])
vouchers = vouchers.order_by('-date_modified')
#vouchers = skip( offset ).limit( items_per_page )
response_vouchers = []
for voucher in vouchers:
obj_voucher = transpose_voucher(voucher)
response_vouchers.append(obj_voucher)
return build_response.build_json({"payload": response_vouchers})
def get_categories():
'''
For inserting the categories
'''
'''categories = ['Bollywood', 'Hollywood', 'Modern']
for cat in categories:
category = Category()
category.name = cat
category.save()
return build_response.sent_ok()'''
categories = Category.objects().order_by('name')
if not categories:
return build_response.build_json([])
#return build_response.sent_json(emojis.to_json())
response_categories = []
for category in categories:
obj_category = {
'id': str(category.id),
'name': category.name,
'date_created': category.date_created.isoformat(),
'date_modified': category.date_modified.isoformat()
}
response_categories.append(obj_category)
return build_response.build_json(response_categories)
def read_users():
"""
find list of users
:return:
"""
'''
users = User.objects().order_by('lastName')
return build_response.sent_json(users.to_json())
'''
users = User.objects()
if request.args.get('firstName'):
users = users.filter(
firstName__istartswith=request.args.get('firstName'))
if request.args.get('lastName'):
users = users.filter(
lastName__istartswith=request.args.get('lastName'))
if request.args.get('email'):
users = users.filter(email__istartswith=request.args.get('email'))
if not users:
return build_response.build_json([])
response_users = []
for user in users:
obj_user = transpose_user(user)
response_users.append(obj_user)
return build_response.build_json(response_users)
def login():
"""
Login to user and return a token
"""
content = request.get_json(silent=True)
email = content.get("email")
password = content.get("password")
user = User.objects(email=email).first()
if not user:
return build_response.build_json({"status":False, "error": 'User is not found.'})
if not check_password_hash(user.password, password):
return build_response.build_json({"status":False, "error": 'Password is incorrect.'})
return build_response.build_json(
{
'status':True,
'membership': 'Free' if user.membershipPlan == 0 else 'Paid',
'auth_token': create_jwttoken(1,user.email)[1]
}
)
def soical_signup():
"""
Social SignUp and return a token
"""
content = request.get_json(silent=True)
#Signup Type and Social Id is required
if not (content.get("socialId") or content.get("signupType")):
return build_response.build_json({"status":False, "error": 'Social Id or SignUp Type is missing.'})
#check for valid signup type value
if content.get("signupType") not in [2,3,4,5]:
return build_response.build_json({"status":False, "error": 'SignUp Type is not a valid value.'})
signupType = content.get("signupType")
socialId = content.get("socialId")
#check of alreay exist user
#First By Email
if content.get("email"):
email = content.get("email")
user = User.objects(email=email).first()
#If no user By email then try By Social Id
try:
user
except NameError:
user = getUserBySoicalId(signupType, socialId)
else:
if not user:
user = getUserBySoicalId(signupType, socialId)
#If no user exist, try to register as new
if not user:
#No address info not provided
#return the response and ask for address info along with all signup info
if not (content.get("countryCode") and content.get("state")):
return build_response.build_json({"status":False, "error": 'Country code and State are required.'})
else:
#Register new user return the token
user = User()
try:
save_response = save_user(user)
if 'error' in save_response:
raise Exception(save_response['error'])
else:
return build_response.build_json(
{
'status':True,
'membership': 'Free' if user.membershipPlan == 0 else 'Paid',
'auth_token': create_jwttoken(signupType,socialId)[1]
}
)
except Exception as e:
return build_response.build_json({"status":False, "error": str(e)})
def create_login():
content = request.get_json(silent=True)
username = content["username"]
password = content["password"]
if username == "test" and password == "p":
return build_response.build_json({"status": "ok"})
else:
return build_response.build_json({"status": "error"})
def update_emoji(id):
emoji = Emoji.objects.get(id=ObjectId(id))
try:
save_response = save_emoji(emoji)
if 'error' in save_response:
raise Exception(save_response['error'])
else:
return build_response.build_json(
{"_id": str(save_response['emoji_id'])})
except Exception as e:
return build_response.build_json({"error": str(e)})
def update_voucher(id):
voucher = Voucher.objects.get(id=ObjectId(id))
try:
save_response = save_voucher(voucher)
if 'error' in save_response:
raise Exception(save_response['error'])
else:
return build_response.build_json(
{"_id": str(save_response['voucher_id'])})
except Exception as e:
return build_response.build_json({"error": str(e)})
def update_country(id):
country = Country.objects.get(id=ObjectId(id))
try:
save_response = save_country(country)
if 'error' in save_response:
raise Exception(save_response['error'])
else:
return build_response.build_json(
{"_id": str(save_response['country_id'])})
except Exception as e:
return build_response.build_json({"error": str(e)})
def read_voucher(id):
"""
Find details for the given voucher id
:param id:
:return:
"""
try:
voucher = Voucher.objects.get(id=ObjectId(id))
except Exception as e:
return build_response.build_json({"error": str(e)})
return build_response.build_json(transpose_voucher(voucher))
def read_emoji(id):
"""
Find details for the given emoji id
:param id:
:return:
"""
try:
emoji = Emoji.objects.get(id=ObjectId(id))
except Exception as e:
return build_response.build_json({"error": str(e)})
return build_response.build_json(transpose_emoji(emoji))
def read_country(id):
"""
Find details for the given country id
:param id:
:return:
"""
try:
country = Country.objects.get(id=ObjectId(id))
except Exception as e:
return build_response.build_json({"error": str(e)})
return build_response.build_json(transpose_country(country))
def user_category_download():
"""
user download a category
"""
try:
save_response = category_download()
if 'error' in save_response:
raise Exception(save_response['error'])
else:
return build_response.build_json(
{"_id": str(save_response['category_download_id'])})
except Exception as e:
return build_response.build_json({"error": str(e)})
def copy_emoji():
"""
user download a emoji
"""
try:
content = request.get_json(silent=True)
emoji_ids = content.get("emoji_ids")
save_responses = []
for emoji_id in emoji_ids:
save_response = emoji_download(emoji_id, g.user)
save_responses.append(save_response)
return build_response.build_json({'status': True})
except Exception as e:
return build_response.build_json({'status': False, "error": str(e)})
def find_categories():
"""
find list of categories for the agent
:return:
"""
categories = Category.objects(status=1).order_by('name')
if not categories:
return build_response.build_json([])
response_categories = []
for category in categories:
obj_category = transpose_category(category)
response_categories.append(obj_category)
return build_response.build_json(response_categories)
def create_voucher():
"""
Create a story from the provided json
:param json:
:return:
"""
voucher = Voucher()
try:
save_response = save_voucher(voucher)
if 'error' in save_response:
raise Exception(save_response['error'])
else:
return build_response.build_json(
{"_id": str(save_response['voucher_id'])})
except Exception as e:
return build_response.build_json({"error": str(e)})
def create_emoji():
"""
Create a story from the provided json
:param json:
:return:
"""
emoji = Emoji()
try:
save_response = save_emoji(emoji)
if 'error' in save_response:
raise Exception(save_response['error'])
else:
return build_response.build_json(
{"_id": str(save_response['emoji_id'])})
except Exception as e:
return build_response.build_json({"error": str(e)})
def create_country():
"""
Create a story from the provided json
:param json:
:return:
"""
country = Country()
try:
save_response = save_country(country)
if 'error' in save_response:
raise Exception(save_response['error'])
else:
return build_response.build_json(
{"_id": str(save_response['country_id'])})
except Exception as e:
return build_response.build_json({"error": str(e)})
def read_countries():
"""
find list of categories for the agent
:return:
"""
countries = Country.objects.order_by('displayOrder', 'CountryName')
if not countries:
return build_response.build_json([])
response_countries = []
for country in countries:
obj_country = transpose_country(country)
response_countries.append(obj_country)
return build_response.build_json(response_countries)
def profile():
user = g.user
return build_response.build_json(
{
'status':True,
'profile':transpose_user(user)
}
)
def get_config(bot_name):
"""
Update bot config
:return:
"""
bot = Bot.objects.get(name=bot_name)
return build_response.build_json(bot.config)
def get_training_data(story_id):
"""
retrieve training data for a given story
:param story_id:
:return:
"""
story = Intent.objects.get(id=ObjectId(story_id))
return build_response.build_json(story.trainingData)
def create_entity():
"""
Create a story from the provided json
:return:
"""
content = request.get_json(silent=True)
entity = Entity()
entity.name = content.get("name")
entity.entity_values = []
try:
entity_id = entity.save()
except Exception as e:
return build_response.build_json({"error": str(e)})
return build_response.build_json({"_id": str(entity_id.id)})
def get_training_data(story_id):
"""
retrive training data for a given story
:param story_id:
:return:
"""
story = Intent.objects.get(id=ObjectId(story_id))
return build_response.build_json(story.trainingData)
def post_checkout():
#Insert to Subscription
'''
{
"payment_method_payload": {
"nonce":"tokencc_bj_t68pp6_8h2y94_xfc3mm_j53prf_ph7",
"details":{
"cardType":"Visa",
"lastFour":"1111",
"lastTwo":"11"
},
"type":"CreditCard",
"description":"ending in 11",
"binData":{
}
},
"amount": 150,
"voucher_code": "GET50", #leave blank if not applied,
"gateway": "Braintree"
}
'''
try:
content = request.get_json(silent=True)
payment_repo = PaymentRepo()
subscription = payment_repo.create_subscription()
if 'error' in subscription:
raise Exception(subscription['error'])
if not subscription['success']:
raise Exception('Payment Failed: ' + subscription['error'])
response = {
'status': True,
'subscription_id': subscription['subscription_id'],
'message': 'Payment Successful'
}
return build_response.build_json(response)
except Exception as e:
return build_response.build_json({
"status": False,
"error": 'Payment Failed'
})
def apply_voucher():
'''
{
"voucher_code": "GET25"
}
'''
content = request.get_json(silent=True)
user = g.user
membershipPlan = user.country
try:
voucher = Voucher.objects(code__exact=content.get('voucher_code'))
if not voucher:
raise Exception('Invalid Voucher')
voucher = voucher.get()
if (voucher.uselimit - voucher.usedNum) <= 0:
raise Exception('Invalid Voucher')
'''
if voucher.expireDate and voucher.expireDate < datetime.datetime.utcnow:
raise Exception('Invalid Token')
'''
if membershipPlan not in voucher.membershipPlan:
raise Exception('Invalid Voucher')
amount = Decimal(membershipPlan.monthlyAmount -
(membershipPlan.monthlyAmount * voucher.discount) /
100)
response = {
'status': True,
'voucher_code': voucher.code,
'voucher_discount': str(round(voucher.discount)) + '%',
'voucher_title': voucher.name,
'amount': float(round(amount, 2)),
'currency': membershipPlan.countryCurrency,
'frequency': 'Monthly'
}
return build_response.build_json(response)
except Exception as e:
return build_response.build_json({"status": False, "error": str(e)})
def list_countries():
countries = Countries.objects.order_by('Name')
response_countries = []
for country in countries:
obj_country = transpose_countries(country)
response_countries.append(obj_country)
return build_response.build_json(response_countries)
def get_config(bot_name):
"""
Update bot config
:param json:
:return:
"""
bot = Bot.objects.get(name=bot_name)
return build_response.build_json(bot.config)
def list_states(countryCode):
states = States.objects().filter(
countryCode__iexact=countryCode).order_by('stateName')
response_states = []
for state in states:
obj_country = transpose_states(state)
response_states.append(obj_country)
return build_response.build_json(response_states)
def create_entity():
"""
Create a story from the provided json
:param json:
:return:
"""
content = request.get_json(silent=True)
entity = Entity()
entity.name = content.get("name")
entity.entity_values = []
try:
entity_id = entity.save()
except Exception as e:
return build_response.build_json({"error": str(e)})
return build_response.build_json({
"_id": str(entity_id.id)
})
def api():
"""
Endpoint to converse with chatbot.
Chat context is maintained by exchanging the payload between client and bot.
sample input/output payload =>
{
"currentNode": "",
"complete": false,
"parameters": [],
"extractedParameters": {},
"missingParameters": [],
"intent": {
},
"context": {},
"input": "hello",
"speechResponse": [
]
}
:param json:
:return json:
"""
request_json = request.get_json(silent=True)
result_json = request_json
if request_json:
context = {}
context["context"] = request_json["context"]
if app.config["DEFAULT_WELCOME_INTENT_NAME"] in request_json.get(
"input"):
intent = Intent.objects(
intentId=app.config["DEFAULT_WELCOME_INTENT_NAME"]).first()
result_json["complete"] = True
result_json["intent"]["object_id"] = str(intent.id)
result_json["intent"]["id"] = str(intent.intentId)
result_json["input"] = request_json.get("input")
template = Template(
intent.speechResponse,
undefined=SilentUndefined)
result_json["speechResponse"] = split_sentence(template.render(**context))
logger.info(request_json.get("input"), extra=result_json)
return build_response.build_json(result_json)
intent_id, confidence,suggetions = predict(request_json.get("input"))
app.logger.info("intent_id => %s"%intent_id)
intent = Intent.objects.get(intentId=intent_id)
if intent.parameters:
parameters = intent.parameters
else:
parameters = []
if ((request_json.get("complete") is None) or (
request_json.get("complete") is True)):
result_json["intent"] = {
"object_id": str(intent.id),
"confidence": confidence,
"id": str(intent.intentId)
}
if parameters:
# Extract NER entities
extracted_parameters = entity_extraction.predict(
intent_id, request_json.get("input"))
missing_parameters = []
result_json["missingParameters"] = []
result_json["extractedParameters"] = {}
result_json["parameters"] = []
for parameter in parameters:
result_json["parameters"].append({
"name": parameter.name,
"type": parameter.type,
"required": parameter.required
})
if parameter.required:
if parameter.name not in extracted_parameters.keys():
result_json["missingParameters"].append(
parameter.name)
missing_parameters.append(parameter)
result_json["extractedParameters"] = extracted_parameters
if missing_parameters:
result_json["complete"] = False
current_node = missing_parameters[0]
result_json["currentNode"] = current_node["name"]
result_json["speechResponse"] = split_sentence(current_node["prompt"])
else:
result_json["complete"] = True
context["parameters"] = extracted_parameters
else:
result_json["complete"] = True
elif request_json.get("complete") is False:
if "cancel" not in intent.name:
intent_id = request_json["intent"]["id"]
intent = Intent.objects.get(intentId=intent_id)
extracted_parameter = entity_extraction.replace_synonyms({
request_json.get("currentNode"): request_json.get("input")
})
# replace synonyms for entity values
result_json["extractedParameters"].update(extracted_parameter)
result_json["missingParameters"].remove(
request_json.get("currentNode"))
if len(result_json["missingParameters"]) == 0:
result_json["complete"] = True
context = {}
context["parameters"] = result_json["extractedParameters"]
context["context"] = request_json["context"]
else:
missing_parameter = result_json["missingParameters"][0]
result_json["complete"] = False
current_node = [
node for node in intent.parameters if missing_parameter in node.name][0]
result_json["currentNode"] = current_node.name
result_json["speechResponse"] = split_sentence(current_node.prompt)
else:
result_json["currentNode"] = None
result_json["missingParameters"] = []
result_json["parameters"] = {}
result_json["intent"] = {}
result_json["complete"] = True
if result_json["complete"]:
if intent.apiTrigger:
isJson = False
parameters = result_json["extractedParameters"]
headers = intent.apiDetails.get_headers()
app.logger.info("headers %s"%headers)
url_template = Template(
intent.apiDetails.url, undefined=SilentUndefined)
rendered_url = url_template.render(**context)
if intent.apiDetails.isJson:
isJson = True
request_template = Template(
intent.apiDetails.jsonData, undefined=SilentUndefined)
parameters = json.loads(request_template.render(**context))
try:
result = call_api(rendered_url,
intent.apiDetails.requestType,headers,
parameters, isJson)
except Exception as e:
app.logger.warn("API call failed", e)
result_json["speechResponse"] = ["Service is not available. Please try again later."]
else:
context["result"] = result
template = Template(
intent.speechResponse, undefined=SilentUndefined)
result_json["speechResponse"] = split_sentence(template.render(**context))
else:
context["result"] = {}
template = Template(intent.speechResponse,
undefined=SilentUndefined)
result_json["speechResponse"] = split_sentence(template.render(**context))
logger.info(request_json.get("input"), extra=result_json)
return build_response.build_json(result_json)
else:
return abort(400)
