def main():
'''
Instancia y ejecuta todos los threads del programa
'''
API = WebApi()
#API = WebApi(url = 'http://generador/generador/api/v1')
config = API.get_config(1)
logging.debug(config)
DEPRECIACION = config['porcentaje_devaluacion']
CAPITAL_INICIAL = config['valor_proyecto']
VALOR_SIMBOLICO = config['valor_simbolico']
VALOR_MINUTO_TRABAJO = config['valor_hora_trabajo']
#minutos
TIEMPO_REALIZACION_TITULO = 5
try:
#inicializa los threads
watcher = WatchAndPost(DEPRECIACION)
watcher.start()
ca = CreateCert(watcher,
VALOR_SIMBOLICO,
VALOR_MINUTO_TRABAJO,
TIEMPO_REALIZACION_TITULO)
ca.start()
ser = SerialCom(ca, watcher)
ser.start()
while True:
#simplemente mantiene vivo el MainThread para poder terminar el
#proceso con cntr+c
time.sleep(0.01)
except KeyboardInterrupt:
'''
cntrl + c: termina los hilos y apaga el programa
'''
watcher.quit()
watcher.join()
ca.quit()
ca.join()
ser.quit()
ser.join()
sys.exit("closing by CRTL+C")
except Exception, err:
print err
def __init__(self, w, simbolico, minuto, tiempo):
Thread.__init__(self)
self.name = 'CreateCert'
self.loop = Event()
#evento para crear el titulo
self.doit = Event()
#inicializa en set el evento
self.doit.set()
#instancia de WatchAndPost
self.watcher = w
self.api = WebApi()
self.tw = TemplateWriter(template='base65.jinja')
self.ca = Certificate_generator('keys/generador.key',
'keys/generador.crt')
self.valor_simbolico = simbolico
self.valor_minuto = minuto
self.tiempo_trabajo = tiempo
def __init__(self):
client_id = config['authentication']['client_id']
redirect_uri = 'https://platelminto.eu.pythonanywhere.com/users/registering'
scope_list = [
'user-library-read', 'user-library-modify',
'playlist-modify-public', 'user-modify-playback-state',
'user-read-playback-state', 'playlist-modify-private'
]
self.web_api = WebApi(scope_list=scope_list,
client_id=client_id,
redirect_uri=redirect_uri)
if current_os == 'Darwin':
self.local_api = AppleScriptApi()
elif current_os == 'Windows':
self.local_api = MediaKeysApi()
self.repeat_states = ['track', 'context', 'off']
class CreateCert(Thread):
'''
Clase que crea y firma los certificados criptograficos de cada titulo
valor. Recibe en los parametros de inicializacion una instancia de la clase
``WatchAndPost`` para poder actualizar tanto el capital como el numero de
titulos emitidos.
:param w: Instancia de la clase ``WatchAndPost``
:param simbolico: porcentaje del valor simbolico
:param minuto: valor del minuto de trabajo
:param tiempo: tiempo de trabajo de realizacion de cada bono
'''
def __init__(self, w, simbolico, minuto, tiempo):
Thread.__init__(self)
self.name = 'CreateCert'
self.loop = Event()
#evento para crear el titulo
self.doit = Event()
#inicializa en set el evento
self.doit.set()
#instancia de WatchAndPost
self.watcher = w
self.api = WebApi()
self.tw = TemplateWriter(template='base65.jinja')
self.ca = Certificate_generator('keys/generador.key',
'keys/generador.crt')
self.valor_simbolico = simbolico
self.valor_minuto = minuto
self.tiempo_trabajo = tiempo
def run(self):
'''
Esta funcion corre en el fondo hasta ser llamada para crear el
certificado -cuando llega un dato del puerto serial-. Internamente
realiza los calculos del porcentaje a agregar al capital y actualiza
los valores en el estado global del sistema.
'''
while not self.loop.is_set():
#mantiene vivo el thread
self.loop.wait(0.01)
def quit(self):
'''
Cambia el flag interno para terminar la funcion ``self.run()`` y
terminar el Thread
'''
self.loop.set()
def create(self):
logging.debug('generando certificado')
logging.debug('numero de titulos %s', self.watcher.num_titulos_emitidos)
#toma el tiempo y suma uno a los titulos
now = datetime.datetime.now()
self.watcher.setNumTitulosPlus()
new_num = self.watcher.num_titulos_emitidos
#actualiza el valor del capital
percentage = (self.valor_minuto * self.valor_simbolico) / 100
addToCapital = percentage * self.tiempo_trabajo
self.watcher.setCapital(addToCapital)
logging.debug('>>> valuacion: %s', addToCapital)
logging.debug('nuevo numero de titulos %s', new_num)
CA_response = self.ca.generate_and_sign('CO', 'Bogota', 'Bogota',
'generador de valores', 'generador de certificados',
str(new_num).zfill(9), new_num)
logging.debug('certificado: %s', CA_response)
source = self.tw.createSource(CA_response['certificate'], CA_response['digest'],
str(new_num).zfill(9), now)
new_post = self.api.post_valor(new_num, now,
CA_response['certificate'],
CA_response['key'],
source)
logging.debug('nuevo cert', new_post)
#al finalizar vuelve a poner el set en el evento
#self.doit.set()
return source
def home():
utterance = request.args.get('utterance')
user_session_id = request.args.get('user_session_id')
key_session_id = "session_id"
web_api = WebApi(utterance, new_session)
active_module_node = dict()
last_active_node = None
# check for last active state for a user
active_state_nodes, active_bot, active_module_id = web_api.get_user_active_state(
key_session_id, user_session_id)
if active_state_nodes:
if active_module_id in active_state_nodes:
last_active_node = active_state_nodes[active_module_id]
if not active_bot:
bot = initialize_bot()
else:
bot = active_bot
chat = ConsoleChatInterface(bot)
if not utterance or user_session_id == "null":
if user_session_id == "null": # for new user coming first time
session_id = str(uuid.uuid4())
final_api_output = add_user_and_start_chat(
web_api, chat, active_state_nodes, key_session_id, session_id,
last_active_node, bot, active_module_id, '')
logger.info(json.dumps(final_api_output))
else: # if user open new tab while old tab is also open i.e. session exist
session_id = user_session_id
if not web_api.user_session_exist(key_session_id, session_id):
final_api_output = add_user_and_start_chat(
web_api, chat, active_state_nodes, key_session_id,
session_id, last_active_node, bot, active_module_id, '')
logger.info(json.dumps(final_api_output))
else: # for last user utterance as first bot message
last_user_utterance = web_api.get_last_user_utterance(
key_session_id, user_session_id)
if not last_user_utterance: # if user open new tab without any chat in old tab
final_api_output = chat.start_chat('', active_state_nodes,
last_active_node,
active_module_id,
new_session, session_id)
logger.info(json.dumps(final_api_output))
else:
active_node, module_id, final_api_output = chat.start_chat(
last_user_utterance, active_state_nodes,
last_active_node, active_module_id, new_session,
session_id)
logger.info(json.dumps(final_api_output))
else:
session_id = user_session_id
active_node, module_id, final_api_output = chat.start_chat(
utterance, active_state_nodes, last_active_node, active_module_id,
new_session, session_id)
if active_node and module_id and active_bot:
last_active_node = active_node
active_module_id = module_id
active_user_bot = active_bot
if web_api.user_session_exist(key_session_id, session_id):
web_api.update_last_user_utterance(key_session_id, user_session_id)
if active_node and module_id and active_bot:
web_api.update_user_active_state(key_session_id,
user_session_id, active_node,
active_bot, module_id)
logger.info(json.dumps(final_api_output))
# if last_active_node:
# web_api.print_active_tree(last_active_node)
chatbot_output = {"chatbot_output": final_api_output}
user_session_id = {str(key_session_id): session_id}
final_api_output = web_api.finalize_api_output(chatbot_output,
user_session_id)
return jsonify(final_api_output)
