def logic(interaction, message):
# We can also use the command number detected before
user_id = message['user_id']
user_data = user.get(user_id)
agent_name = user_data.get('name')
user_context = conversation.context(user_id)
current_p_conversation_id = user_context.get(
'current_pending_conversation')
if current_p_conversation_id is None:
list_pending_conversations.logic(interaction, message)
return None
p_convo_data = pending_conversations.get(current_p_conversation_id)
client_id = p_convo_data.get('user_id')
client_data = user.get(client_id)
client_name = client_data.get('name')
conversation.update_context(client_id, 'is_closing', True)
s_msg = f"Se ha invitado confirmar al usuari@ {client_name}({current_p_conversation_id}) a confirmar el cierre de su caso."
chat_api.reply(s_msg, message)
message_client = {'user_id': client_id}
c_msg = f"{agent_name} ha informado que ya tu caso ya no requiere seguimiento ¿Puedes confirmar? Responde si o no."
chat_api.reply(c_msg, message_client)
return True
def logic(interaction, message):
context = conversation.context(message['user_id'])
interaction_text= interaction['text']
for key in context:
key_store = '${' + key + '}'
if key_store in interaction_text:
interaction_text = interaction_text.replace(key_store, context[key])
chat_api.reply(interaction_text, message)
return True
def alert_admins_pending(pending_conversation):
print('Alerting Admins of new message')
if len(pending_conversation['owners']) == 0:
agents = [u['id'] for u in user.find(user_type='agent')]
else:
agents = pending_conversation['owners']
for agent in agents:
text = pending_conversations_agent_indicator(agent)
message = {'text': text, 'user_id': agent}
chat_api.reply(text, message)
return None
def logic(interaction, message):
agent_id = message['user_id']
user_id = conversation.get_current_redirect_user(agent_id)
label = interaction.get('label')
current_thread = thread.current_open_thread(user_id, label=label)
if current_thread:
text_message = f"Advertencia: Hay un caso pendiente por cerrar con est@ usuari@"
chat_api.reply(text_message, message)
thread.create(user_id, label=label, label_set_by='agent')
text_message = f"Caso creado satisfactoriamente"
chat_api.reply(text_message, message)
return True
def logic(interaction, message):
user_id = message['user_id']
chat_api.reply(interaction['text'], message)
users_owned = user.find(owner=user_id) #message['user_id']
for user_owned in users_owned:
for thread_owned in user_owned['threads']:
user_name = user_owned['name']
user_phone = user_owned['phone']
thread_label = thread.printable_label(thread_owned['label'])
thread_status = thread.printable_status(thread_owned['label'])
last_message = conversation.get_canonical_message(user_owned['id'],thread_owned['last_canonical_message_id'])
text_message = f"👤{user_name}\n☎️{user_phone}\n⚠️{thread_label}/{thread_status}\n🗣️Último mensaje:('{last_message['text']}')"
chat_api.reply(text_message, message)
return True
def logic(interaction, message):
user_id = message['user_id']
user_context = context(message['user_id'])
# TODO(ricalanis): Change to broadcast
agent_phones = [key for key in user.agents().keys()]
last_message = get_last_message(user_id)
user_new_message = user.get(user_context['id'])
if user_new_message.get('owner') is not None:
message_redirect = f"Mensaje de {user_context['name']}({user_context['phone']}):{last_message}"
message = {'user_id': user.get('owner')}
chat_api.reply(message_redirect, message)
return True
for phone in agent_phones:
agent_user_id = user.phone_to_id(phone)
if user.get(agent_user_id) is None: continue
message = {'user_id': user.phone_to_id(phone)}
agent_name = user.agents()[phone]['name']
text_alert = f"Acaba de llegar un mensaje de: {user_context['name']}({user_context['phone']})"
chat_api.reply(text_alert, message)
text_alert = f"*Ultimo mensaje: {last_message}*"
chat_api.reply(text_alert, message)
update_context(agent_user_id, 'last_message_user', user_context['id'])
update_context(agent_user_id, 'last_message_name',
user_context['name'])
update_context(agent_user_id, 'last_message_phone',
user_context['phone'])
text_alert = f"Escribe 'p' para poner un timer de 5 min a esta conversación y entrar en la conversación con {user_context['name']}({user_context['phone']}). Por lo contrario sigue escribiendo."
chat_api.reply(text_alert, message)
return True
def logic(interaction, message):
user_id = message['user_id']
text = message['text']
users_list = list(user.users.find({'type': 'agent'})) #message['user_id']
if len(users_list) == 0:
chat_api.reply("No hay agentes dados de alta", message)
return True
agent_uuid = text.split(' ')[0].lower()
agent_data_uuid = user.find(uuid = agent_uuid)
if len(agent_data_uuid) == 0:
r_text = 'No se encontro ningún agente con dicho identificador'
chat_api.reply(r_text, message)
return True
agent_data = agent_data_uuid[0]
user_context = conversation.context(user_id)
redirect_user_id = user_context.get('redirect_user')
if redirect_user_id is None:
r_text = 'No tienes ninguna conversación seleccionada'
chat_api.reply(r_text, message)
return True
user_data = user.get(redirect_user_id)
current_p_results = pending_conversations.find(user_id = redirect_user_id, closed = False)
current_p = current_p_results[0].get('id') if len(current_p_results)>0 else None
if current_p is None:
pending_conversations.create(redirect_user_id, [agent_uuid])
current_p_results = pending_conversations.find(user_id = redirect_user_id, closed = False)
current_p = current_p_results[0].get('id') if len(current_p_results)>0 else None
else:
pending_conversations.switch_owner(current_p, user_id, agent_uuid)
conversation.update_context(user_id, 'redirect_user', None)
conversation.update_context(user_id, 'redirect_name', None)
conversation.update_context(user_id, 'redirect_phone', None)
conversation.update_context(user_id, 'conversational_level', 'user')
conversation.update_context(user_id, 'current_pending_conversation', None)
r_text = f"{agent_uuid} ha recibido al usuario {user_data['uuid']}"
chat_api.reply(r_text, message)
a_text = f"Has recibido al usuario {user_data['uuid']} de {user_id}"
chat_api.reply(a_text, {'user_id': agent_uuid, 'text': a_text})
return True
def logic(interaction, message):
agent_id = message['user_id']
user_id = conversation.get_current_redirect_user(agent_id)
label = interaction.get('label')
user_open_threads = thread.find_all(user_id, label = label, solved = False)
# Not sure if im going to check array size
if len(user_open_threads)>=0:
closed_thread = thread.close(user_id)
if closed_thread == True:
text_message = f"Caso cerrado satisfactoriamente"
chat_api.reply(text_message, message)
return True
text_message = f"El/La usuari@ seleccionad@ no tiene casos de este tipo abiertos..."
chat_api.reply(text_message, message)
return True
def logic(interaction, message):
user_id = message['user_id']
user_context = conversation.context(user_id)
last_reply_time = user_context.get('last_reply_time')
is_closing = user_context.get('is_closing')
pending_convos = pending_conversations.find(user_id=user_id, closed=False)
current_p_convo_id = pending_convos[0].get(
'id') if len(pending_convos) > 0 else None
if current_p_convo_id is not None and is_closing == True:
text = message.get('text').lower().split(' ')[0]
current_p_data = pending_conversations.get(current_p_convo_id)
current_user = user.get(user_id)
user_name = current_user.get('name')
if 'no' in text:
for owner in current_p_data['owners']:
agent_context = conversation.context(owner)
message = {'user_id': owner}
c_msg = f'El usuario {user_name} no ha confirmado el cierre de su conversación'
chat_api.reply(c_msg, message)
elif 'si' in text:
pending_conversations.close(current_p_convo_id)
for owner in current_p_data['owners']:
agent_context = conversation.context(owner)
redirect_user = agent_context.get('redirect_user')
agent_p_convo = agent_context.get(
'current_pending_conversation')
message = {'user_id': owner}
c_msg = f'La conversación pendiente con {user_name}({current_p_convo_id}) se ha cerrado'
chat_api.reply(c_msg, message)
if redirect_user == user_id and current_p_convo_id == agent_p_convo:
conversation.update_context(owner, 'redirect_user', None)
conversation.update_context(owner, 'redirect_name', None)
conversation.update_context(owner, 'redirect_phone', None)
conversation.update_context(owner, 'conversational_level',
'user')
conversation.update_context(
owner, 'current_pending_conversation', None)
conversation.update_context(user_id, 'is_closing', False)
return True
if last_reply_time is None:
conversation.update_context(user_id, 'last_reply_time', datetime.now())
chat_api.reply(interaction['text'], message)
else:
if datetime.now() > last_reply_time + timedelta(hours=24):
conversation.update_context(user_id, 'last_reply_time',
datetime.now())
chat_api.reply(interaction['text'], message)
else:
None
# Do nothing if 24 before last reply did not happen
return True
def logic(interaction, message):
user_id = message['user_id']
# We can also use the command number detected before
redirect_user_number = message['text'].split(' ')[0].lower()
users_uuid = user.find(uuid=redirect_user_number)
try:
user_found = users_uuid[0]
except:
user_found = None
if user_found is not None:
conversation.update_context(user_id, 'redirect_user', user_found['id'])
conversation.update_context(user_id, 'redirect_name',
user_found['name'])
conversation.update_context(user_id, 'redirect_phone',
user_found['phone'])
conversation.update_context(user_id, 'conversational_level', 'user')
if user_found.get('owner') is None:
user.update(user_found['id'], {'owner': user_id})
current_p_results = pending_conversations.find(
user_id=user_found['id'], closed=False)
current_p = current_p_results[0].get(
'id') if len(current_p_results) > 0 else None
if current_p is None:
pending_conversations.create(user_found['id'], owners=[user_id])
current_p_results = pending_conversations.find(
user_id=user_found['id'], closed=False)
current_p = current_p_results[0].get(
'id') if len(current_p_results) > 0 else None
conversation.update_context(user_id, 'current_pending_conversation',
current_p)
pending_conversations.add_owner(current_p, user_id)
pending_conversations.remove_new_messages(current_p)
s_msg = "Haz selecionado al " + user_found['uuid'] + " " + user_found[
'name']
chat_api.reply(s_msg, message)
s_msg = "Con la conversacion pendiente " + str(current_p)
chat_api.reply(s_msg, message)
else:
list_users.logic()
return True
def return_logs(message):
all_errors = list(logs.find({}))
for ele in all_errors:
chat_api.reply('---------', message, False)
chat_api.reply(ele['created_at'].isoformat(), message, False)
chat_api.reply(ele['conversation_log'], message, False)
return True
def logic(interaction, message):
chat_api.reply(interaction['text'], message)
user_id = message['user_id']
users_owned = list(user.users.find())
found_threads = False
for user_owned in users_owned:
for thread_owned in user_owned['threads']:
user_name = user_owned['name']
user_phone = user_owned['phone']
thread_label = thread.printable_label(thread_owned['label'])
thread_status = thread.printable_status(thread_owned['solved'])
if thread_owned['label'] == None or thread_owned['solved'] == False:
message_label = 'Primer mensaje'
message_fetch = conversation.get_canonical_message(
user_owned['id'],
thread_owned['first_canonical_message_id'])
else:
message_label = 'Último mensaje'
message_fetch = conversation.get_canonical_message(
user_owned['id'],
thread_owned['last_canonical_message_id'])
text_message = f"👤{user_name}\n☎️{user_phone}\n⚠️{thread_label}/{thread_status}\n🗣️{message_label}:*{message_fetch['text']}*"
chat_api.reply(text_message, message)
found_threads = True
if found_threads == False:
text_message = f"*No se encontraron casos*"
chat_api.reply(text_message, message)
return True
def logic(interaction, message):
user_id = message.get('user_id')
try:
ls_type = message['text'].split(' ')[1]
except:
ls_type = None
if ls_type == 'u':
list_users.logic(interaction, message)
elif ls_type == 'c':
list_cases.logic(interaction, message)
elif ls_type == 'a':
list_agents.logic(interaction, message)
elif ls_type == 'p':
list_pending_conversations.logic(interaction, message)
else:
user_id = message['user_id']
user_context = conversation.context(user_id)
current_id = user_context.get('redirect_user')
if current_id is None:
s_msg = "No esta seleccionado ningún usuario"
chat_api.reply(s_msg, message)
return True
convo = conversation.get_printable_conversation(current_id)
s_msg = "Los mensajes con el usuario actual es:"
chat_api.reply(s_msg, message)
chat_api.reply(convo, message)
return True
def logic(interaction, message):
# We can also use the command number detected before
user_id = message['user_id']
current_p = message['text'].split(' ')[0].lower()
current_p_object = pending_conversations.get(current_p)
if current_p_object is None:
list_pending_conversations.logic(interaction, message)
return True
redirect_user_number = current_p_object['user_id']
user_found = user.get(redirect_user_number)
if user_found is not None:
conversation.update_context(user_id, 'redirect_user', user_found['id'])
conversation.update_context(user_id, 'redirect_name',
user_found['name'])
conversation.update_context(user_id, 'redirect_phone',
user_found['phone'])
conversation.update_context(user_id, 'conversational_level', 'user')
if user_found.get('owner') is None:
user.update(user_found['id'], {'owner': user_id})
conversation.update_context(user_id, 'current_pending_conversation',
current_p)
pending_conversations.add_owner(current_p, user_id)
pending_conversations.remove_new_messages(current_p)
s_msg = "Haz selecionado al " + user_found['uuid'] + " " + user_found[
'name']
chat_api.reply(s_msg, message)
s_msg = "Con la conversacion pendiente " + current_p
chat_api.reply(s_msg, message)
else:
already_selected_p = conversation.context(
'current_pending_conversation')
if already_selected_p is None:
list_pending_conversations.logic(interaction, message)
else:
already_p_object = pending_conversations.get(already_selected_p)
already_user = user.get(already_p_object['user_id'])
already_user_name = already_user.get('name')
s_msg = "Sigues hablando con " + already_user_name
chat_api.reply(s_msg, message)
return True
def logic(interaction, message):
user_id = message.get('user_id')
user_context = conversation.context(user_id)
current_user_id = user_context.get('redirect_user')
if current_user_id is not None:
current_user_name = user_context['redirect_name']
current_user_phone = user_context['redirect_phone']
notification.create(user_id, current_user_id, 0, settings = {'minutes': 5})
reply_text = 'Acabas de poner un timer de 5 min con en tu (conversación) con {current_user_name} ({current_user_phone})'
chat_api.reply(reply_text, message)
new_message_user = user_context.get('last_message_user')
user_new_message = user.get(new_message_user)
if new_message_user is None:
chat_api.reply('Falle en encontrar el usuario para hablar', message)
return True
new_message_name = user_context['last_message_name']
new_message_phone = user_context['last_message_phone']
conversation.update_context(user_id, 'redirect_user', new_message_user)
conversation.update_context(user_id, 'redirect_name', new_message_name)
conversation.update_context(user_id, 'redirect_phone', new_message_phone)
conversation.update_context(user_id, 'conversational_level', 'user')
# Code shared with switch
if user_found.get('owner') is None:
user.update(redirect_user_id, { 'owner': user_id } )
chat_api.reply('La conversación con este usuario es:', message)
user_messages = conversation.get_printable_conversation(redirect_user_id)
chat_api.reply(user_messages, message)
return True
def logic(interaction, message):
chat_api.reply("Estas son las conversaciones pendientes:", message)
user_id = message['user_id']
pending_conversations.clean_pending_index()
p_list = list(pending_conversations.find(
owner=user_id, closed=False)) #message['user_id']
if len(p_list) == 0:
chat_api.reply("No hay casos pendientes a resolver", message)
return True
for p in p_list:
star_messages = ''
if p['new_messages'] == True:
star_messages = '* '
user_p = user.get(p['user_id'])
#user_name = user_info['name']
#user_phone = user_info['phone']
text_message = f"👤{p['id']} {star_messages}= {user_p['name']}"
chat_api.reply(text_message, message)
return True
def logic(interaction, message):
chat_api.reply("Selecciona un usuario@:", message)
user_id = message['user_id']
user.clean_user_index()
users_list = list(user.users.find({'type': 'user'})) #message['user_id']
if len(users_list) == 0:
chat_api.reply("No hay usuari@s dados de alta", message)
return True
for user_info in users_list:
if 'name' not in user_info: continue
user_id = user_info['id']
user_uuid = user_info['uuid']
user_name = user_info['name']
user_phone = user_info['phone']
user_pending = pending_conversations.find(user_id = user_id, closed=False, new_messages=False)
if len(user_pending)>0:
string_pending = '* '
else:
string_pending = ''
text_message = f"👤{user_uuid} {string_pending}= {user_name} ({user_phone})"
chat_api.reply(text_message, message)
return True
def logic(interaction, message):
chat_api.reply("Estos son l@s agentes disponibles:", message)
user_id = message['user_id']
user.clean_agent_index()
users_list = list(user.users.find({'type': 'agent'})) #message['user_id']
if len(users_list) == 0:
chat_api.reply("No hay agentes dados de alta", message)
return True
#Double check if uuids are correctly setup
for user_info in users_list:
if 'name' not in user_info: continue
user_id = user_info['id']
user_uuid = user_info['uuid']
user_name = user_info['name']
user_phone = user_info['phone']
user_pending = pending_conversations.find(user_id = user_id, closed=False, new_messages=False)
if len(user_pending)>0:
string_pending = '* '
else:
string_pending = ''
text_message = f"👤{user_uuid} {string_pending}= {user_name} ({user_phone})"
chat_api.reply(text_message, message)
return True
def send_notification(agent_id):
message = {'user_id': agent_id}
text_alert = f"Hola, este es un recordatorio automatizado de tus conversaciones pendientes"
chat_api.reply(text_alert, message)
list_pending_conversations.logic({}, message)
return True
def logic(interaction, message):
chat_api.reply(interaction['text'], message)
return True
def logic(interaction, message):
gpt_answer = gpt.answer(message['text'])
chat_api.reply(gpt_answer, message)
return True
def logic(interaction, message):
user_id = message['user_id']
user_context = conversation.context(user_id)
name = user_context.get('new_user_info_name')
phone = user_context.get('new_user_info_phone')
country = user_context.get('new_user_info_country')
conversation.update_context(user_id, 'new_user_info_name', None)
conversation.update_context(user_id, 'new_user_info_phone', None)
conversation.update_context(user_id, 'new_user_info_country', None)
id_create_user = user.phone_to_id(phone)
users_by_name = user.find(name=name)
user_same_name = users_by_name[0] if len(users_by_name) > 0 else None
users_by_phone = user.find(phone=phone)
user_same_phone = users_by_phone[0] if len(users_by_phone) > 0 else None
no_change = False
if user.get(
id_create_user
) is None and user_same_phone is None and user_same_name is None:
user_data = {
'name': name,
'phone': phone,
'country': country,
'owner': user_id,
}
user.create(id_create_user, user_data, 'outbound')
message_start = {
'user_id': id_create_user,
'text': '***Inicio Conversacion Outbound'
}
pending_conversations.create(id_create_user, [user_id])
conversation.update_context(id_create_user, 'last_reply',
datetime.now())
user_register = f"Haz registrado a un nuevo usuario. {name} ({phone})"
chat_api.reply(user_register, message)
elif user_same_phone is not None:
if user_same_phone['name'] != name:
user.update(user_same_phone['id'], {'name': name})
name_change = f"Haz cambiado el nombre del usuario con nombre de {name}"
chat_api.reply(name_change, message)
else:
no_change = True
elif user_same_name is not None:
if user_same_name['phone'] != phone:
user.update(user_same_name['id'], {'phone': phone})
phone_change = f"Haz cambiado el telefono del usuario con nombre de {name}"
chat_api.reply(phone_change, message)
else:
no_change = True
if no_change == True:
chat_api.reply('El usuario no sufrio cambios', message)
return True
def messages_route():
os.environ['CLI_ON'] = "0"
data = None
try:
data = request.get_json().get('messages')[0]
except:
print('Invalid data received, Ignoring...')
return jsonify({'success': 'true'})
text = data.get('body')
user_id = data.get('author')
message = build_message(user_id, text)
if text == '//HARDRESET':
chat_api.reply('Reseteando status...', message, False)
try:
canonical_convo = conversation.get_printable_conversation(user_id)
except:
canonical_convo = "- Ningún mensaje encontrado"
log_handler.create(canonical_convo)
chat_api.reply(canonical_convo, message, False)
list(user.users.remove())
list(conversation.conversations.remove())
list(notification.notifications.remove())
list(pending_conversations.pending_conversations.remove({}))
list(user.agents_source.remove({}))
chat_api.reply('Reseteado', message, False)
chat_api.reply('*Log creado*', message, False)
elif text == '//DOCUMENT':
chat_api.reply('Retornando conversación...', message, False)
canonical_convo = conversation.get_printable_conversation(user_id)
chat_api.reply(canonical_convo, message, False)
log_handler.create(canonical_convo)
chat_api.reply('*Log creado*', message, False)
elif text == '//LOGS':
log_handler.return_logs(message)
else:
respond(data)
return jsonify({'success': 'true'})
def exception_flow(message):
chat_api.reply(get_random_phrase(), message, False)
return True
