def get(self, request):
totalMenu = navbar(request.user)
user_id = request.user.id
client_id = client_user.objects.get(
user_id_id=request.user.id).client_id_id
bots_collection = 'client{}_bots'.format(client_id)
db[bots_collection].remove({'group_ids': {'$exists': False}})
bots1 = db[bots_collection].find({'user_id': user_id})
user_bots = []
for bot in bots1:
bot['id'] = bot['_id']
user_bots.append(bot)
user_bots.reverse()
totalMenu = navbar(request.user)
return render(
request, 'bots/create-bot.html', {
'Menudata': totalMenu,
'username': request.user.username,
'bots': user_bots
})
def get(self, request, bot_id):
user_id = request.user.id
client_id = client_user.objects.get(
user_id_id=request.user.id).client_id_id
public_collection = 'client{}_public_groups'.format(client_id)
private_collection = 'client{}_private_groups'.format(client_id)
public_groups = db[public_collection].find()
private_groups = db[private_collection].find({'user_id': user_id})
u_public_g = []
for group in public_groups:
group['id'] = group['_id']
u_public_g.append(group)
u_private_g = []
for group in private_groups:
group['id'] = group['_id']
u_private_g.append(group)
totalMenu = navbar(request.user)
return render(
request, 'bots/bot-group.html', {
'Menudata': totalMenu,
'username': request.user.username,
"public_groups": u_public_g,
"private_groups": u_private_g
})
def get(self, request):
totalMenu = navbar(request.user)
return render(request, 'bots/create-intent-form.html', {
'Menudata': totalMenu,
'username': request.user.username
})
def post(self, request):
edited = request.POST['edited']
print(edited)
totalMenu = navbar(request.user)
user_id = request.user.id
client_id = client_user.objects.get(
user_id_id=request.user.id).client_id_id
bot_id = request.POST['bot_id']
bots_collection = 'client{}_bots'.format(client_id)
if edited == 'false':
bot_find = db[bots_collection].find_one({
'_id': ObjectId(bot_id),
'user_id': user_id
})
print(bot_find)
bot_find['id'] = bot_find['_id']
if bot_find is not None:
return render(
request, 'edit/create-bot-form.html', {
'Menudata': totalMenu,
'username': request.user.username,
'bot': bot_find
})
if edited == 'true':
bot_name = request.POST['BotName']
bot_description = request.POST['BotDescription']
bot_welcome_message = request.POST['BotWelcomeMessage']
bot_goodbye_message = request.POST['BotGoodByeMessage']
bot_typing_name = request.POST['BotTypingName']
bot_message_failed_scenario = request.POST[
'BotMessageFailedScenario']
bot_message_connection_error = request.POST[
'BotMessageConnectionError']
db[bots_collection].update_one({'_id': ObjectId(bot_id)}, {
'$set': {
'bot_name': bot_name,
'bot_description': bot_description,
'bot_welcome_message': bot_welcome_message,
'bot_goodbye_message': bot_goodbye_message,
'bot_typing_name': bot_typing_name,
'bot_message_failed_scenario': bot_message_failed_scenario,
'bot_message_connection_error':
bot_message_connection_error,
'updated_on': datetime.now()
}
})
url = '/edit/edit_bot_group/%s' % bot_id
print(url)
return HttpResponseRedirect(url)
def get(self, request, group_id):
print(group_id)
user_id = request.user.id
client_id = client_user.objects.get(
user_id_id=request.user.id).client_id_id
public_collection = 'client{}_public_intents'.format(client_id)
private_collection = 'client{}_private_intents'.format(client_id)
public_intents = db[public_collection].find()
private_intents = db[private_collection].find({'user_id': user_id})
u_public_i = []
for intent in public_intents:
intent['id'] = intent['_id']
u_public_i.append(intent)
u_private_i = []
for intent in private_intents:
intent['id'] = intent['_id']
u_private_i.append(intent)
totalMenu = navbar(request.user)
return render(
request, 'bots/group-intent.html', {
'Menudata': totalMenu,
'username': request.user.username,
"public_intents": u_public_i,
"private_intents": u_private_i
})
def post(self, request):
totalMenu = navbar(request.user)
bot_name = request.POST['BotName']
bot_description = request.POST['BotDescription']
bot_welcome_message = request.POST['BotWelcomeMessage']
bot_goodbye_message = request.POST['BotGoodByeMessage']
bot_typing_name = request.POST['BotTypingName']
bot_message_failed_scenario = request.POST['BotMessageFailedScenario']
bot_message_connection_error = request.POST[
'BotMessageConnectionError']
user_id = request.user.id
client_id = client_user.objects.get(
user_id_id=request.user.id).client_id_id
collection = 'client{}_bots'.format(client_id)
bot = db[collection].find_one({
'bot_name': bot_name,
"user_id": user_id
})
if bot is not None:
return render(
request, 'bots/create-bot-form.html', {
'username': request.user.username,
'Menudata': totalMenu,
'message': 'Bot already exists'
})
db[collection].insert_one({
'bot_name': bot_name,
'bot_description': bot_description,
'bot_welcome_message': bot_welcome_message,
'bot_goodbye_message': bot_goodbye_message,
'bot_typing_name': bot_typing_name,
'bot_message_failed_scenario': bot_message_failed_scenario,
'bot_message_connection_error': bot_message_connection_error,
'user_id': user_id,
'client_id': client_id,
'created_by': request.user.username,
'created_on': datetime.now(),
'update_on': ''
})
fetch_bot_id = db[collection].find_one({
'bot_name': bot_name,
'user_id': user_id
})
print(fetch_bot_id['_id'])
bot_id = fetch_bot_id['_id']
url = '/bot-group/%s' % bot_id
print(url)
return HttpResponseRedirect(url)
def get(self, request, intent_id):
user_id = request.user.id
client_id = client_user.objects.get(
user_id_id=request.user.id).client_id_id
public_collection = 'client{}_public_intents'.format(client_id)
private_collection = 'client{}_private_intents'.format(client_id)
find_intent1 = db[public_collection].find_one(
{'_id': ObjectId(intent_id)})
find_intent2 = db[private_collection].find_one(
{'_id': ObjectId(intent_id)})
public_groups = 'client{}_public_groups'.format(client_id)
private_groups = 'client{}_private_groups'.format(client_id)
public_total_groups = db[public_groups].find()
private_total_groups = db[private_groups].find({'user_id': user_id})
total_groups = []
for group in public_total_groups:
total_groups.append(group)
for group in private_total_groups:
total_groups.append(group)
public_total_intents = db[public_collection].find()
private_total_intents = db[private_collection].find(
{'user_id': user_id})
total_intents = []
for intent in private_total_intents:
intent['id'] = intent['_id']
total_intents.append(intent)
for intent in public_total_intents:
intent['id'] = intent['_id']
total_intents.append(intent)
if find_intent1 is not None or find_intent2 is not None:
totalMenu = navbar(request.user)
return render(
request, 'bots/response-form.html', {
'Menudata': totalMenu,
'username': request.user.username,
'intents': total_intents,
'groups': total_groups
})
def get(self, request, bot_id):
user_id = request.user.id
totalMenu = navbar(request.user)
client_id = client_user.objects.get(
user_id_id=request.user.id).client_id_id
bots_collection = 'client{}_bots'.format(client_id)
bot_find = db[bots_collection].find_one({'_id': ObjectId(bot_id)})
# getting all the groups
####################################
public_groups_collection = 'client{}_public_groups'.format(client_id)
private_groups_collection = 'client{}_private_groups'.format(client_id)
u_public_g = db[public_groups_collection].find()
u_private_g = db[private_groups_collection].find({'user_id': user_id})
groups = []
for group in u_public_g:
group['id'] = group['_id']
groups.append(group)
for group in u_private_g:
group['id'] = group['_id']
groups.append(group)
if bot_find is not None:
bot_groups = bot_find['groups']
for group in bot_groups:
for actual_group in groups:
if group['group_name'] == actual_group['group_name']:
groups.remove(actual_group)
return render(
request, 'edit/bot-group.html', {
'Menudata': totalMenu,
'username': request.user.username,
'final_groups': groups,
'groups': bot_groups
})
def get(self, request):
totalMenu = navbar(request.user)
user_id = request.user.id
client_id = client_user.objects.get(
user_id_id=request.user.id).client_id_id
public_collection = 'client{}_public_groups'.format(client_id)
private_collection = 'client{}_private_groups'.format(client_id)
db[public_collection].remove({'intent_ids': {'$exists': False}})
db[private_collection].remove({'intent_ids': {'$exists': False}})
user_public_groups = db[public_collection].find()
u_public_g = []
for intent in user_public_groups:
intent['id'] = intent['_id']
u_public_g.append(intent)
user_private_groups = db[private_collection].find({'user_id': user_id})
u_private_g = []
for intent in user_private_groups:
intent['id'] = intent['_id']
u_private_g.append(intent)
u_private_g.reverse()
u_public_g.reverse()
# for group in u_public_g:
# for intent in group['intents']:
# print(intent)
return render(
request, 'bots/create-group.html', {
'Menudata': totalMenu,
'username': request.user.username,
'public_groups': u_public_g,
'private_groups': u_private_g
})
def get(self, request, intent_id):
totalMenu = navbar(request.user)
user_id = request.user.id
client_id = client_user.objects.get(user_id_id=user_id).client_id_id
public_collection = 'client{}_public_intents'.format(client_id)
private_collection = 'client{}_private_intents'.format(client_id)
intent_in_public_collection = db[public_collection].find_one(
{'_id': ObjectId(intent_id)})
intent_in_private_collection = db[private_collection].find_one(
{'_id': ObjectId(intent_id)})
if intent_in_public_collection is not None:
response_type = intent_in_public_collection['response_type']
intent_responses = intent_in_public_collection['intent_response']
return render(
request, 'edit/response-form.html', {
'response_type': response_type,
'intent_responses': intent_responses,
'Menudata': totalMenu,
'username': request.user.username
})
print(response_type)
if intent_in_private_collection is not None:
response_type = intent_in_private_collection['response_type']
intent_responses = intent_in_private_collection['intent_response']
print(response_type)
return render(
request, 'edit/response-form.html', {
'response_type': response_type,
'intent_responses': intent_responses,
'Menudata': totalMenu,
'username': request.user.username
})
def get(self, request):
user_id = request.user.id
client_id = client_user.objects.get(
user_id_id=request.user.id).client_id_id
public_collection = 'client{}_public_intents'.format(client_id)
private_collection = 'client{}_private_intents'.format(client_id)
db[public_collection].remove({'response_type': {'$exists': False}})
db[private_collection].remove({'response_type': {'$exists': False}})
user_public_intents = db[public_collection].find()
u_public_i = []
for intent in user_public_intents:
intent['id'] = intent['_id']
u_public_i.append(intent)
user_private_intents = db[private_collection].find(
{'user_id': user_id})
u_private_i = []
for intent in user_private_intents:
intent['id'] = intent['_id']
u_private_i.append(intent)
u_private_i.reverse()
u_public_i.reverse()
totalMenu = navbar(request.user)
return render(
request, 'bots/intents.html', {
'Menudata': totalMenu,
'username': request.user.username,
'public_intents': u_public_i,
'private_intents': u_private_i
})
def post(self, request):
user_id = request.user.id
totalMenu = navbar(request.user)
client_id = client_user.objects.get(
user_id_id=request.user.id).client_id_id
intent_name = request.POST['IntentName']
intent_description = request.POST['IntentDescription']
# checking whether the intent with that name already exists in the db
if intent_name == '':
return render(
request, 'bots/create-intent-form.html', {
'Menudata': totalMenu,
'username': request.user.username,
'message': 'Intent Name should not be Empty'
})
if intent_description == '':
return render(
request, 'bots/create-intent-form.html', {
'Menudata': totalMenu,
'username': request.user.username,
'message': 'Intent Description should not be Empty'
})
# check it in both private and public collections
public_collection = 'client{}_public_intents'.format(client_id)
private_collection = 'client{}_private_intents'.format(client_id)
intent_find1 = db[public_collection].find_one({
'intent_name': intent_name,
"user_id": user_id
})
intent_find2 = db[private_collection].find_one({
'intent_name': intent_name,
"user_id": user_id
})
# check wether the intent present if it presents
if intent_find1 is not None or intent_find2 is not None:
return render(
request, 'bots/create-intent-form.html', {
'Menudata': totalMenu,
'username': request.user.username,
'message': 'Intent already exists'
})
privacy = request.POST['privacy']
phrases = []
for key in request.POST.keys():
if 'Phrase' in key:
phrases.append(request.POST[key])
collection = 'client{}_{}_intents'.format(client_id, privacy)
keys = request.POST.keys()
db[collection].insert_one({
'intent_name': intent_name,
'intent_description': intent_description,
'intent_phrases': phrases,
'created_on': datetime.now(),
'created_by': request.user.username,
'user_id': user_id,
'client_id': client_id,
'intent_response': []
})
fetch_intent_id = db[collection].find_one({
'intent_name': intent_name,
'user_id': user_id
})
intent_id = fetch_intent_id['_id']
url = '/intents/response-form/%s' % intent_id
return HttpResponseRedirect(url)
def post(self, request, bot_id):
user_id = request.user.id
client_id = client_user.objects.get(
user_id_id=request.user.id).client_id_id
print("from post request", bot_id)
print("Post request data", request.POST)
groups = []
group_ids = []
for key in request.POST.keys():
if 'group' in key:
group_ids.append(request.POST[key])
print('group_ids', group_ids)
# get request code to display the groups added to the bot when no groups are added
public_collection = 'client{}_public_groups'.format(client_id)
private_collection = 'client{}_private_groups'.format(client_id)
public_groups = db[public_collection].find()
private_groups = db[private_collection].find({'user_id': user_id})
u_public_g = []
for group in public_groups:
group['id'] = group['_id']
u_public_g.append(group)
u_private_g = []
for group in private_groups:
group['id'] = group['_id']
u_private_g.append(group)
totalMenu = navbar(request.user)
#################################################################################
if len(group_ids) <= 0:
return render(
request, 'bots/bot-group.html', {
'Menudata': totalMenu,
'username': request.user.username,
"public_groups": u_public_g,
"private_intents": u_private_g,
"message": 'U should add Atleast one group'
})
group_names = []
public_groups = 'client{}_public_groups'.format(client_id)
private_groups = 'client{}_private_groups'.format(client_id)
for group_id in group_ids:
group_name = db[public_groups].find_one(
{'_id': ObjectId(group_id)})
if group_name is not None:
group_names.append(group_name['group_name'])
for group_id in group_ids:
group_name = db[private_groups].find_one(
{'_id': ObjectId(group_id)})
if group_name is not None:
group_names.append(group_name['group_name'])
bots = 'client{}_bots'.format(client_id)
for group_id, group_name in zip(group_ids, group_names):
groups.append({'group_id': group_id, 'group_name': group_name})
for group in groups:
print('selected groups', group)
check_bot = db[bots].find_one({'_id': ObjectId(bot_id)})
print(check_bot)
if check_bot is not None:
db[bots].update_one(
{'_id': ObjectId(bot_id)},
{"$set": {
"groups": groups,
"group_ids": group_ids
}})
print('updated successfully')
return redirect('/bot-console/bots')
else:
return redirect('/bot-console/bots')
def post(self, request):
totalMenu = navbar(request.user)
user_id = request.user.id
client_id = client_user.objects.get(
user_id_id=request.user.id).client_id_id
private_collection = 'client{}_private_groups'.format(client_id)
public_collection = 'client{}_public_groups'.format(client_id)
edited = request.POST['edited']
if edited == 'false':
group_id = request.POST['group_id']
group_private_find = db[private_collection].find_one({
'_id':
ObjectId(group_id),
'user_id':
user_id
})
group_public_find = db[public_collection].find_one({
'_id':
ObjectId(group_id),
'user_id':
user_id,
'clinet_id':
client_id
})
if group_private_find is not None:
group_private_find['id'] = group_private_find['_id']
return render(
request, 'edit/create-group-form.html', {
'Menudata': totalMenu,
'username': request.user.username,
'group': group_private_find
})
if group_public_find is not None:
group_public_find['id'] = group_public_find['_id']
return render(
request, 'edit/create-group-form.html', {
'Menudata': totalMenu,
'username': request.user.username,
'group': group_public_find
})
if edited == 'true':
group_id = request.POST['group_id']
privacy = request.POST['privacy']
group_name = request.POST['GroupName']
group_description = request.POST['GroupDescription']
print(group_name)
if privacy == 'private':
group_find_private = db[private_collection].find_one(
{'_id': ObjectId(group_id)})
if group_find_private is not None:
db[private_collection].update_one(
{'_id': ObjectId(group_id)}, {
'$set': {
'group_name': group_name,
'group_description': group_description,
}
},
upsert=True)
print('updated successfully in private groups')
url = '/edit/edit_group_intent/%s' % group_id
return HttpResponseRedirect(url)
if group_find_private is None:
public_group = db[public_collection].find(
{'_id': ObjectId(group_id)})
db[private_collection].insert_one({
'group_name':
group_name,
'group_description':
group_description,
'created_on':
datetime.now(),
'created_by':
request.user.username,
'user_id':
user_id,
'client_id':
client_id,
'intent_ids':
public_group['intent_ids'],
'intents':
public_group['intents']
})
db[public_collection].remove({'_id': ObjectId(group_id)})
fetch_group_id = db[private_collection].find_one({
'group_name':
group_name,
'user_id':
user_id
})
new_group_id = fetch_group_id['_id']
url = '/edit/edit_group_intent/%s' % new_group_id
return HttpResponseRedirect(url)
if privacy == 'public':
intent_find_public = db[public_collection].find(
{'_id': ObjectId(group_id)})
if intent_find_public is not None:
db[public_collection].update_one(
{'_id': ObjectId(group_id)}, {
'$set': {
'group_name': group_name,
'group_description': group_description
}
})
url = '/edit/edit_group_intent/%s' % group_id
return HttpResponseRedirect(url)
if intent_find_public is None:
db[public_collection].insert_one({
'group_name':
group_name,
'group_description':
group_description,
'created_on':
datetime.now(),
'created_by':
request.user.username,
'user_id':
user_id,
'client_id':
client_id,
})
db[private_collection].remove({'_id': ObjectId(group_id)})
fetch_intent_id = db[public_collection].find_one({
'group_name':
group_name,
'user_id':
user_id
})
new_group_id = fetch_group_id['_id']
url = '/edit/edit_group_intent/%s' % new_group_id
return HttpResponseRedirect(url)
def get(self, request, group_id):
totalMenu = navbar(request.user)
user_id = request.user.id
client_id = client_user.objects.get(
user_id_id=request.user.id).client_id_id
public_collection = 'client{}_public_groups'.format(client_id)
private_collection = 'client{}_private_groups'.format(client_id)
private_group_find = db[private_collection].find_one(
{'_id': ObjectId(group_id)})
public_group_find = db[public_collection].find_one(
{'_id': ObjectId(group_id)})
# getting all intent of the user
##################################################################
public_intent_collection = 'client{}_public_intents'.format(client_id)
private_intent_collection = 'client{}_private_intents'.format(
client_id)
public_intents = db[public_intent_collection].find()
private_intents = db[private_intent_collection].find(
{'user_id': user_id})
u_public_i = []
for intent in public_intents:
intent['id'] = intent['_id']
u_public_i.append(intent)
u_private_i = []
for intent in private_intents:
intent['id'] = intent['_id']
u_private_i.append(intent)
if private_group_find is not None:
private_group_intents = private_group_find['intents']
for g_intent in private_group_intents:
for intent in u_private_i:
if g_intent['intent_name'] == intent['intent_name']:
print('intent matched')
u_private_i.remove(intent)
return render(
request, 'edit/group-intent.html', {
'Menudata': totalMenu,
'username': request.user.username,
'intents': private_group_intents,
'final_intents': u_private_i
})
if public_group_find is not None:
public_group_intents = public_group_find['intents']
for intent in u_public_i:
for g_intent in public_group_intents:
if g_intent['id'] == intent['id']:
u_public_i.remove(intent['id'])
continue
return render(
request, 'edit/group-intent.html', {
'Menudata': totalMenu,
'username': request.user.username,
'intents': public_group_intents,
'final_intents': u_public_i
})
def post(self, request, group_id):
print(request.POST)
# Get request code to display the intents to add them in the group
user_id = request.user.id
client_id = client_user.objects.get(
user_id_id=request.user.id).client_id_id
public_collection = 'client{}_public_intents'.format(client_id)
private_collection = 'client{}_private_intents'.format(client_id)
public_intents = db[public_collection].find()
private_intents = db[private_collection].find({'user_id': user_id})
u_public_i = []
for intent in public_intents:
intent['id'] = intent['_id']
u_public_i.append(intent)
u_private_i = []
for intent in private_intents:
intent['id'] = intent['_id']
u_private_i.append(intent)
totalMenu = navbar(request.user)
#######################################################
intents = []
intent_ids = []
for key in request.POST.keys():
if 'intent' in key:
intent_ids.append(request.POST[key])
if len(intent_ids) <= 0:
return render(
request, 'bots/group-intent.html', {
'Menudata': totalMenu,
'username': request.user.username,
"public_intents": u_public_i,
"private_intents": u_private_i,
'message': 'Please add the intents to the group'
})
intent_names = []
user_id = request.user.id
client_id = client_user.objects.get(
user_id_id=request.user.id).client_id_id
public_intents = 'client{}_public_intents'.format(client_id)
private_intents = 'client{}_private_intents'.format(client_id)
for intent_id in intent_ids:
print(intent_id)
intent_name = db[public_intents].find_one(
{'_id': ObjectId(intent_id)})
if intent_name is not None:
intent_names.append(intent_name['intent_name'])
for intent_id in intent_ids:
intent_name = db[private_intents].find_one(
{'_id': ObjectId(intent_id)})
if intent_name is not None:
intent_names.append(intent_name['intent_name'])
public_collection = 'client{}_public_groups'.format(client_id)
private_collection = 'client{}_private_groups'.format(client_id)
for intent_id, intent_name in zip(intent_ids, intent_names):
intents.append({
'intent_id': intent_id,
'intent_name': intent_name
})
check_public_group = db[public_collection].find_one(
{'_id': ObjectId(group_id)})
check_private_group = db[private_collection].find_one(
{'_id': ObjectId(group_id)})
for intent in intents:
print('final after sorting', intent)
if check_public_group is not None:
db[public_collection].update_one(
{'_id': ObjectId(group_id)},
{"$set": {
"intents": intents,
"intent_ids": intent_ids
}})
print('updated successfully in public groups')
return redirect('/bot-console/groups/')
else:
db[private_collection].update_one(
{'_id': ObjectId(group_id)},
{"$set": {
"intents": intents,
"intent_ids": intent_ids
}})
print('updated successfully in private groups')
return redirect('/bot-console/groups/')
def post(self, request):
totalMenu = navbar(request.user)
user_id = request.user.id
client_id = client_user.objects.get(
user_id_id=request.user.id).client_id_id
private_collection = 'client{}_private_intents'.format(client_id)
public_collection = 'client{}_public_intents'.format(client_id)
edited = request.POST['edited']
if edited == 'false':
intent_id = request.POST['intent_id']
i_private_find = db[private_collection].find_one({
'_id':
ObjectId(intent_id),
'user_id':
user_id,
'client_id':
client_id
})
i_public_find = db[public_collection].find_one({
'_id':
ObjectId(intent_id),
'user_id':
user_id,
'client_id':
client_id
})
print(i_private_find)
if i_private_find is not None:
i_private_find['id'] = i_private_find['_id']
# for intent in i_private_find:
# intent['id'] = intent['_id']
# u_private_i.append(intent)
return render(
request, 'edit/create-intent-form.html', {
'Menudata': totalMenu,
'username': request.user.username,
'intent': i_private_find
})
else:
i_public_find['id'] = i_public_find['_id']
# for intent in i_public_find:
# intent['id'] = intent['_id']
# u_public_i.append(intent)
return render(
request, 'edit/create-intent-form.html', {
'Menudata': totalMenu,
'username': request.user.username,
'intent': i_public_find
})
return render(request, 'edit/create-intent-form.html', {
'Menudata': totalMenu,
'username': request.user.username
})
if edited == 'true':
intent_id = request.POST['intent_id']
privacy = request.POST['privacy']
intent_name = request.POST['IntentName']
intent_description = request.POST['IntentDescription']
print(intent_name)
phrases = []
for key in request.POST.keys():
if 'Phrase' in key:
phrases.append(request.POST[key])
if privacy == 'private':
intent_find_private = db[private_collection].find_one(
{'_id': ObjectId(intent_id)})
if intent_find_private is not None:
db[private_collection].update_one(
{'_id': ObjectId(intent_id)}, {
'$set': {
'intent_name': intent_name,
'intent_description': intent_description,
'intent_phrases': phrases
}
},
upsert=True)
print('updated successfully in private intents')
url = '/edit/edit_response/%s' % intent_id
return HttpResponseRedirect(url)
if intent_find_private is None:
public_intent = db[public_collection].find_one(
{'_id': ObjectId(intent_id)})
db[private_collection].insert_one({
'intent_name':
intent_name,
'intent_description':
intent_description,
'intent_phrases':
phrases,
'created_on':
datetime.now(),
'created_by':
request.user.username,
'user_id':
user_id,
'client_id':
client_id,
'intent_response':
public_intent['intent_response'],
'response_type':
public_intent['response_type']
})
db[public_collection].remove({'_id': ObjectId(intent_id)})
fetch_intent_id = db[private_collection].find_one({
'intent_name':
intent_name,
'user_id':
user_id
})
new_intent_id = fetch_intent_id['_id']
url = '/edit/edit_response/%s' % new_intent_id
return HttpResponseRedirect(url)
if privacy == 'public':
intent_find_public = db[public_collection].find(
{'_id': intent_id})
if intent_find_public is not None:
db[public_collection].update_one(
{'_id': ObjectId(intent_id)}, {
'$set': {
'intent_name': intent_name,
'intent_description': intent_description,
'intent_phrases': phrases
}
})
url = '/edit/edit_response/%s' % intent_id
return HttpResponseRedirect(url)
if intent_find_public is None:
db[public_collection].insert_one({
'intent_name':
intent_name,
'intent_description':
intent_description,
'intent_phrases':
phrases,
'created_on':
datetime.now(),
'created_by':
request.user.username,
'user_id':
user_id,
'client_id':
client_id,
'intent_response': []
})
db[private_collection].remove({'_id': ObjectId(intent_id)})
fetch_intent_id = db[public_collection].find_one({
'intent_name':
intent_name,
'user_id':
user_id
})
new_intent_id = fetch_intent_id['_id']
url = '/edit/edit_response/%s' % new_intent_id
return HttpResponseRedirect(url)
def post(self, request):
totalMenu = navbar(request.user)
group_data = request.POST
group_name = request.POST['GroupName']
group_description = request.POST['GroupDescription']
group_privacy = request.POST['privacy']
if group_name == '':
return render(
request, 'bots/create-group-form.html', {
'Menudata': totalMenu,
'username': request.user.username,
'message': 'Group Name Should Not Be Empty'
})
if group_description == '':
return render(
request, 'bots/create-group-form.html', {
'Menudata': totalMenu,
'username': request.user.username,
'message': 'Group Description Should Not Be Empty'
})
user_id = request.user.id
client_id = client_user.objects.get(
user_id_id=request.user.id).client_id_id
public_collection = 'client{}_public_groups'.format(client_id)
private_collection = 'client{}_private_groups'.format(client_id)
group_find1 = db[public_collection].find_one({
'group_name': group_name,
"user_id": user_id
})
group_find2 = db[private_collection].find_one({
'group_name': group_name,
"user_id": user_id
})
if group_find1 is not None or group_find2 is not None:
return render(
request, 'bots/create-group-form.html', {
'Menudata': totalMenu,
'username': request.user.username,
'message': 'group already exists'
})
collection = 'client{}_{}_groups'.format(client_id, group_privacy)
db[collection].insert_one({
'group_name': group_name,
"group_description": group_description,
"user_id": user_id,
"created_by": request.user.username,
"created_on": datetime.now()
})
fetch_group_id = db[collection].find_one({
'group_name': group_name,
'user_id': user_id
})
print(fetch_group_id['_id'])
group_id = fetch_group_id['_id']
url = '/group-intent/%s' % group_id
print(url)
return HttpResponseRedirect(url)