def profile():
# Variables locales
error = None
response = None
id_client = None
id_user = None
try:
# Revisar formato JSON
valid_json_data = Utils.validateRequestJsonData(request)
if valid_json_data:
# Revisar existencia del token
token = Utils.getTokenFromHeader(request)
if token is not None:
# Revisar validez del token
auth = JWTAuth(__jwtPrivateKey, __jwtPublicKey)
decoded_token = auth.decodeToken(token)
if 'errno' not in decoded_token:
# Revisar argumentos válidos
json_data = request.get_json()
validate_arguments = Utils.allPostArgumentsExists(
json_data, ['id_user', 'id_client'])
if validate_arguments[0]:
# Crear db, tupla de args y llamada a SP
db = Database.getInstance(__dbHost, __dbUser, __dbPswd,
__dbName)
id_user = json_data['id_user']
id_client = json_data['id_client']
args = (id_user, id_client)
user_opt = db.callProc(Procedure.GET_USER_MENU_OPTIONS,
args,
True) # Obtención de opciones
# Revisar que el usuario existe
if user_opt:
response = User.get_ordered_options(user_opt)
else:
# Usuario inválido
error = Error.INVALID_USER
else:
# Argumentos inválidos
error = copy.deepcopy(Error.REQUIRED_ARGUMENTS)
error['errmsg'] = error['errmsg'].format(
validate_arguments[1])
else:
# Token inválido
error = decoded_token
else:
# Token inexistente
error = Error.TOKEN_NOT_FOUND
else:
# Formato JSON inválido
error = Error.INVALID_REQUEST_BODY
except:
Utils.setLog()
error = Error.PROGRAMMING_ERROR
return wrappers.Response(json.dumps(response if error is None else error),
200,
mimetype='application/json')
def test():
error = None
response = None
try:
# Revisamos si el token viene en el header de la peticion
token = Utils.getTokenFromHeader(request)
if token is not None:
# Si esta, lo decodificamos
auth = JWTAuth(__jwtPrivateKey, __jwtPublicKey)
decodedToken = auth.decodeToken(token)
if "errno" not in decodedToken:
response = decodedToken
else:
error = decodedToken
else:
error = Error.TOKEN_NOT_FOUND
except:
Utils.setLog()
error = Error.PROGRAMMING_ERROR
return wrappers.Response(json.dumps(response if error is None else error),
200,
mimetype='application/json')
def typeMethodTypeOfOrdered(
method_name
): #Datos agrupados y ordenados por tipo de.. (reacciones, num. de veces, etc)
try:
isValid = Utils.isValidJsonData(request)
if isValid:
jsonData = request.get_json()
validArgs = Utils.areValidPostArguments(
jsonData, ["account", "date_since", "date_until"])
if validArgs["status"] == "error":
return json.dumps(validArgs)
if Utils.areValidDatesInputUnix(jsonData["date_since"],
jsonData["date_until"]):
if Utils.areDatesDifferences90days(
jsonData["date_since"], jsonData["date_until"]
): #Chequeo diferencia 90 dias
res_token = Utils.getToken(Settings.PLATFORM_DB_HOST,
Settings.PLATFORM_DB_USER,
Settings.PLATFORM_DB_PSWD,
Settings.PLATFORM_DB_NAME,
jsonData["account"], 2)
token = res_token["message"]
url = Utils.buildUrl(graphUrl, token, method_name,
jsonData["date_since"],
jsonData["date_until"])
req = requests.get(url)
res = json.loads(req.text)
jRes = [
] #lista de datos que se muestran en json response
for data in res["data"]:
if data["period"] == "day":
for values in data["values"]:
fecha_temp = values["end_time"].split(
'T') #end_time
fecha = fecha_temp[0]
dic_info = {}
claves = values["value"].keys()
for c in claves:
valor_dato = values["value"][
c] #valor de la clave 1, valor de la clave 2..
clave_dato = c
dic_info[clave_dato] = valor_dato
dic_resultado = Utils.orderDictionary(
dic_info)
jRes.append({fecha: dic_resultado})
jsonResponse = Utils.getResponseJson(
"success", "", False)
jsonResponse["data"] = jRes
return json.dumps(jsonResponse)
else:
return Utils.getResponseJson(
"error", "The maximum range is 90 days", False)
else:
return Utils.getResponseJson(
"error", "Invalid data format or not data available")
except:
Utils.setLog()
return Utils.getResponseJson("error", "Programming failure")
def get_auth():
error = None
response = None
try:
# Revisa que el body de la petición sea un json válido
validJsonData = Utils.isValidJsonData(request)
if validJsonData == True:
jsonData = request.get_json()
# Revisa que en el json esten los argumentos necesarios. En este caso, user y password
validateArguments = Utils.areValidPostArguments(
jsonData, ["username", "password"])
if validateArguments['status'] == 'success':
# Crea instancia de DB, arma tupla de argumentos y llama al SP correspondiente
DATABASE = Database.getInstance(
Settings.PLATFORM_DB_HOST,
Settings.PLATFORM_DB_USER,
Settings.PLATFORM_DB_PSWD,
Settings.PLATFORM_DB_NAME
)
username = jsonData["username"]
password = jsonData["password"]
args = (username, password, 0,)
res = DATABASE.callProc(Procedure.GET_USER_API, args, False)
# Si res es NONE, no trajo resultados el SP
if res is None:
error = Error.INVALID_USER
else:
# Si el usuario existe, genera el token
auth = JWTAuth(__jwtPrivateKey, __jwtPublicKey)
# 1: Cantidad de días de vigencia del token
# user-api-: SUBJECT del token, meramente informativo. Podemos usar el id del usuario y que es de la api
userId = res["id"]
token = auth.encodeToken(1, 'user-api-' + str(userId))
if token is not None:
response = OrderedDict([
("token", token["token"]),
("expires", token["expires"].isoformat())
])
else:
error = Error.TOKEN_GENERATION_ERROR
else:
# Si hay que modificar algo del mensaje, se hace un deepcopy, no modificamos directamente la variable porque es estatica
error = copy.deepcopy(Error.REQUIRED_ARGUMENTS)
error["errmsg"] = error["errmsg"].format(validateArguments[1])
else:
error = Error.INVALID_REQUEST_BODY
except:
Utils.setLog()
error = Error.PROGRAMMING_ERROR
return wrappers.Response(
json.dumps(response if error is None else error), 200, mimetype='application/json'
)
def typeMethodPostsVideos(
method_name
): #Numero de visitas a post o reproducciones de videos (VER)
try:
isValid = Utils.isValidJsonData(request)
if isValid:
jsonData = request.get_json()
validArgs = Utils.areValidPostArguments(
jsonData, ["account", "date_since", "date_until", "posts"])
if validArgs["status"] == "error":
return json.dumps(validArgs)
if Utils.areValidDatesInputUnix(jsonData["date_since"],
jsonData["date_until"]):
if Utils.areDatesDifferences90days(
jsonData["date_since"], jsonData["date_until"]
): #Chequeo diferencia 90 dias
res_token = Utils.getToken(Settings.PLATFORM_DB_HOST,
Settings.PLATFORM_DB_USER,
Settings.PLATFORM_DB_PSWD,
Settings.PLATFORM_DB_NAME,
jsonData["account"], 2)
token = res_token["message"]
pageId = Utils.getPageId(FbSettings.graphUrlId, token)
jRes = [
] #lista de datos que se muestran en json response
for post in jsonData["posts"]:
url = buildUrlPost(pageId, post, token,
method_name,
jsonData["date_since"],
jsonData["date_until"])
print(url)
req = requests.get(url)
res = json.loads(req.text)
for data in res["data"]:
for value in data["values"]:
valor_dato = value["value"]
jRes.append({
post: valor_dato #idPost : valor
})
jsonResponse = Utils.getResponseJson(
"success", "", False)
jsonResponse["data"] = jRes
return json.dumps(jsonResponse)
else:
return getResponseJson("error",
"The maximum range is 90 days",
False)
else:
return getResponseJson(
"error", "Invalid data format or not data available")
except:
Utils.setLog()
return Utils.getResponseJson("error", "Programming failure")
def typeMethodNumberOf(
method_name
): #Datos agrupados por numero de.. (personas, veces, clicks, milisegundos)
try:
isValid = Utils.isValidJsonData(request)
if isValid:
jsonData = request.get_json()
validArgs = Utils.areValidPostArguments(
jsonData, ["account", "date_since", "date_until"])
if validArgs["status"] == "error":
return json.dumps(validArgs)
if Utils.areValidDatesInputUnix(jsonData["date_since"],
jsonData["date_until"]):
if Utils.areDatesDifferences90days(
jsonData["date_since"], jsonData["date_until"]
): #Chequeo diferencia 90 dias
res_token = Utils.getToken(Settings.PLATFORM_DB_HOST,
Settings.PLATFORM_DB_USER,
Settings.PLATFORM_DB_PSWD,
Settings.PLATFORM_DB_NAME,
jsonData["account"], 2)
token = res_token["message"]
url = Utils.buildUrl(graphUrl, token, method_name,
jsonData["date_since"],
jsonData["date_until"])
req = requests.get(url)
res = json.loads(req.text)
jRes = [
] #lista de datos que se muestran en json response
for data in res["data"]:
if data["period"] == "day":
for values in data["values"]:
value = values[
"value"] #value (nro de personas)
fecha_temp = values["end_time"].split(
'T') #end_time
fecha = fecha_temp[0]
jRes.append({fecha: value})
jsonResponse = Utils.getResponseJson(
"success", "", False)
jsonResponse["data"] = jRes
return json.dumps(jsonResponse)
else:
return Utils.getResponseJson(
"error", "The maximum range is 90 days", False)
else:
return Utils.getResponseJson(
"error", "Invalid data format or not data available")
except:
Utils.setLog()
return Utils.getResponseJson("error", "Programming failure")
def auth2():
error = None
response = None
try:
# Revisa que esten los argumentos necesarios en la peticion. En este caso, user y password
validateArguments = Utils.allGetArgumentsExists(
request, ["username", "password"])
if validateArguments[0] == True:
# Crea instancia de DB, arma tupla de argumentos y llama al SP correspondiente
DATABASE = Database.getInstance(__dbHost, __dbUser, __dbPswd,
__dbName)
username = request.args.get("username")
password = request.args.get("password")
args = (
username,
password,
0,
)
res = DATABASE.callProc(Procedure.GET_USER_API, args, False)
# Si res es NONE, no trajo resultados el SP
if res is None:
error = Error.INVALID_USER
else:
# Si el usuario existe, genera el token
auth = JWTAuth(__jwtPrivateKey, __jwtPublicKey)
# 1: Cantidad de días de vigencia del token
# user-api-: SUBJECT del token, meramente informativo. Podemos usar el id del usuario y que es de la api
userId = res["id"]
token = auth.encodeToken(1, 'user-api-' + str(userId))
if token is not None:
response = OrderedDict([("token", token["token"]),
("expires",
token["expires"].isoformat())])
else:
error = Error.TOKEN_GENERATION_ERROR
else:
error = copy.deepcopy(Error.REQUIRED_ARGUMENTS)
error["errmsg"] = error["errmsg"].format(validateArguments[1])
except:
Utils.setLog()
error = Error.PROGRAMMING_ERROR
return wrappers.Response(json.dumps(response if error is None else error),
200,
mimetype='application/json')
def typeMethodCity(method_name): #Datos agrupados por ciudad
try:
isValid = Utils.isValidJsonData(request)
if isValid:
jsonData = request.get_json()
validArgs = Utils.areValidPostArguments(
jsonData, ["account", "date_since", "date_until"])
if validArgs["status"] == "error":
return json.dumps(validArgs)
if Utils.areValidDatesInputUnix(jsonData["date_since"],
jsonData["date_until"]):
if Utils.areDatesDifferences90days(
jsonData["date_since"], jsonData["date_until"]
): #Chequeo diferencia 90 dias
res_token = Utils.getToken(Settings.PLATFORM_DB_HOST,
Settings.PLATFORM_DB_USER,
Settings.PLATFORM_DB_PSWD,
Settings.PLATFORM_DB_NAME,
jsonData["account"], 2)
token = res_token["message"]
url = Utils.buildUrl(graphUrl, token, method_name,
jsonData["date_since"],
jsonData["date_until"])
req = requests.get(url)
res = json.loads(req.text)
jRes = [
] #lista de datos que se muestran en json response
for data in res["data"]:
if data["period"] == "day":
for values in data["values"]:
fecha_temp = values["end_time"].split(
'T') #end_time
fecha = fecha_temp[0]
claves = values["value"].keys(
) #Ciudad, provincia, pais.
lista_paises = []
lista_provincias = []
lista_ciudades = []
for c in claves: #c es la clave
valor_dato = values["value"][
c] #valor de la clave 1, valor de la clave 2..
clave_dato = c
clave_dato_splitted = clave_dato.split(
',')
cantidad_divisiones = len(
clave_dato_splitted)
if cantidad_divisiones > 3:
ciudad = clave_dato_splitted[0]
provincia = clave_dato_splitted[
1] #Provincia compuesta
provincia = provincia.strip()
for i in range(
2,
(len(clave_dato_splitted) -
1)):
provincia = provincia + clave_dato_splitted[
i]
pais = clave_dato_splitted[3]
pais = pais.strip()
if pais not in lista_paises:
lista_paises.append(pais)
t_provincia = (provincia, pais
) #prov, pais
if t_provincia not in lista_provincias:
lista_provincias.append(
t_provincia)
t_ciudad = (
(ciudad,
valor_dato), provincia, pais
) #ciudad y valor, provincia, pais
if t_ciudad not in lista_ciudades:
lista_ciudades.append(t_ciudad)
if (cantidad_divisiones == 3):
ciudad = clave_dato_splitted[0]
provincia = clave_dato_splitted[1]
provincia = provincia.strip()
pais = clave_dato_splitted[2]
pais = pais.strip()
if pais not in lista_paises:
lista_paises.append(pais)
t_provincia = (provincia, pais
) #prov, pais
if t_provincia not in lista_provincias:
lista_provincias.append(
t_provincia)
t_ciudad = (
(ciudad,
valor_dato), provincia, pais
) #ciudad y valor, provincia, pais
if t_ciudad not in lista_ciudades:
lista_ciudades.append(t_ciudad)
else:
if (cantidad_divisiones == 2):
ciudad = clave_dato_splitted[0]
pais = clave_dato_splitted[1]
pais = pais.strip()
if pais not in lista_paises:
lista_paises.append(pais)
t_ciudad = (
(ciudad,
valor_dato), None, pais
) #ciudad y valor, nada, pais
if t_ciudad not in lista_ciudades:
lista_ciudades.append(
t_ciudad)
#Estructuro jerarquicamente localidad, con provincia , con pais.
lista_pa = []
for pais in lista_paises:
lista_pr = []
for provincia in lista_provincias:
lista_ci = []
for ciudad in lista_ciudades: #ciudades con provincia
if ciudad[1] != None and ciudad[
1] == provincia[
0] and ciudad[
2] == pais:
lista_ci.append(ciudad[0])
if len(lista_ci) > 0:
lista_pr.append(
(provincia[0], lista_ci))
for ciudad in lista_ciudades: #ciudades sin provincia
if ciudad[1] == None and ciudad[
2] == pais:
lista_pr.append(
(ciudad[0], None))
lista_pa.append((pais, lista_pr))
dic_pais = {}
for pais in lista_pa:
dic_provincia = {}
for prov in pais[
1]: #prov puede ser una ciudad y su valor, o una tupla (provincia,lista_ci)
dic_ciudad = {}
if prov[1] != None: #lista_ci
for ciud in prov[
1]: #itero en lista ciudades para esa prov
dic_ciudad[
ciud[0]] = ciud[1]
dic_provincia[
prov[0]] = dic_ciudad
else:
dic_provincia[prov[0]
[0]] = prov[0][1]
dic_pais[pais[0]] = dic_provincia
jRes.append({fecha: dic_pais})
jsonResponse = Utils.getResponseJson(
"success", "", False)
jsonResponse["data"] = jRes
return json.dumps(jsonResponse)
else:
return Utils.getResponseJson(
"error", "The maximum range is 90 days", False)
else:
return Utils.getResponseJson(
"error", "Invalid data format or not data available")
except:
Utils.setLog()
return Utils.getResponseJson("error", "Programming failure")
def typeMethodGenderAge(
method_name): #Datos agrupados por genero en rango de edades.
try:
isValid = Utils.isValidJsonData(request)
if isValid:
jsonData = request.get_json()
validArgs = Utils.areValidPostArguments(
jsonData, ["account", "date_since", "date_until"])
if validArgs["status"] == "error":
return json.dumps(validArgs)
if Utils.areValidDatesInputUnix(
jsonData["date_since"],
jsonData["date_until"]): #Chequeo fechas UNIX validas
if Utils.areDatesDifferences90days(
jsonData["date_since"], jsonData["date_until"]
): #Chequeo diferencia 90 dias
res_token = Utils.getToken(Settings.PLATFORM_DB_HOST,
Settings.PLATFORM_DB_USER,
Settings.PLATFORM_DB_PSWD,
Settings.PLATFORM_DB_NAME,
jsonData["account"], 2)
token = res_token["message"]
url = Utils.buildUrl(graphUrl, token, method_name,
jsonData["date_since"],
jsonData["date_until"])
req = requests.get(url)
res = json.loads(req.text)
jRes = []
for data in res["data"]:
if data["period"] == "day":
for values in data["values"]:
fecha_temp = values["end_time"].split(
'T') #end_time
fecha = fecha_temp[0]
dic_male = {}
dic_female = {}
dic_undefined = {}
claves = values["value"].keys()
for c in claves: #c es la clave
valor_dato = values["value"][
c] #valor de la clave 1, valor de la clave 2..
clave_dato = c
clave_dato_splitted = clave_dato.split(
'.')
clave_genero = clave_dato_splitted[
0] #Genero
clave_info = clave_dato_splitted[
1] #Info del genero
#DATOS A MOSTRAR clave_genero, clave_info, valor_dato
if (clave_genero == 'M'):
dic_male[clave_info] = valor_dato
if (clave_genero == 'F'):
dic_female[clave_info] = valor_dato
if (clave_genero == 'U'):
dic_undefined[
clave_info] = valor_dato
jRes.append({
fecha: {
"female": dic_female,
"male": dic_male,
"undefined": dic_undefined
}
})
jsonResponse = Utils.getResponseJson(
"success", "", False)
jsonResponse["data"] = jRes
return json.dumps(jsonResponse)
else:
return Utils.getResponseJson(
"error", "The maximum range is 90 days", False)
else:
return Utils.getResponseJson(
"error", "Invalid data format or not data available")
except:
Utils.setLog()
return Utils.getResponseJson("error", "Programming failure")
from chatbots.facebook import facebook_blueprint
from chatbots.instagram import instagram_blueprint
from chatbots.web import web_blueprint
from chatbots.whatsapp import whatsapp_blueprint
__appHostname = '0.0.0.0'
__appPort = 5001
app = Flask(__name__)
CORS(app)
app.register_blueprint(auth_blueprint, url_prefix='/auth')
app.register_blueprint(chatbots_blueprint, url_prefix='/chatbots')
app.register_blueprint(facebook_blueprint, url_prefix='/chatbots/fb')
app.register_blueprint(instagram_blueprint, url_prefix='/chatbots/ig')
app.register_blueprint(web_blueprint, url_prefix='/chatbots/wb')
app.register_blueprint(whatsapp_blueprint, url_prefix='/chatbots/wa')
if __name__ == '__main__':
try:
reload(sys)
# EN PRODUCCION, CON LOS CERTIFICADOS CORRESPONDIENTES
# context = ssl.SSLContext(ssl.PROTOCOL_TLSv1_2)
# context.load_cert_chain(__sslCert, __sslKey)
# serving.run_simple(__appHostname, __appPort, app, threaded=True, ssl_context=context)
# DESARROLLO
serving.run_simple(__appHostname, __appPort, app)
except:
Utils.setLog()
def update_user():
# Variables locales
error = None
response = None
id_user = None
user_name = None
email = None
password = None
id_hub = None
options = None
try:
# Revisar formato JSON válido
valid_json_data = Utils.validateRequestJsonData(request)
if valid_json_data:
# Revisar existencia del token
token = Utils.getTokenFromHeader(request)
if token is not None:
# Revisar validez del token
auth = JWTAuth(__jwtPrivateKey, __jwtPublicKey)
decoded_token = auth.decodeToken(token)
if 'errno' not in decoded_token:
# Revisar argumentos válidos
json_data = request.get_json()
validate_arguments = Utils.allPostArgumentsExists(
json_data, [
'id_user', 'user_name', 'email', 'password',
'id_hub', 'options'
])
if validate_arguments[0]:
# Crear db, tupla de args y llamada a SP
db = Database.getInstance(__dbHost, __dbUser, __dbPswd,
__dbName)
id_user = json_data['id_user']
user_name = json_data['user_name']
email = json_data['email']
password = json_data['password']
id_hub = json_data['id_hub']
options = json_data['options']
args = (id_user, user_name, email, password, id_hub,
options)
creation_result = db.callProc(
Procedure.UPDATE_USER, args,
True) # Creación de usuario
# Revisar que la creación sea exitosa
if creation_result:
response = OrderedDict([
('status', 'success'),
('message', 'User updated successfully')
])
else:
# Creación de usuario fallida
error = Error.USER_CREATION_ERROR
else:
# Argumentos inválidos
error = copy.deepcopy(Error.REQUIRED_ARGUMENTS)
error['errmsg'] = error['errmsg'].format(
validate_arguments[1])
else:
# Token inválido
error = decoded_token
else:
# Token inexistente
error = Error.TOKEN_NOT_FOUND
else:
# Formato JSON inválido
error = Error.INVALID_REQUEST_BODY
except:
Utils.setLog()
error = Error.PROGRAMMING_ERROR
return wrappers.Response(json.dumps(response if error is None else error),
200,
mimetype='application/json')
def login():
# Variables locales
error = None
response = None
email = None
password = None
try:
# Revisar formato JSON válido
valid_json_data = Utils.validateRequestJsonData(request)
if valid_json_data:
# Revisar existencia del token
token = Utils.getTokenFromHeader(request)
if token is not None:
# Revisar validez del token
auth = JWTAuth(__jwtPrivateKey, __jwtPublicKey)
decoded_token = auth.decodeToken(token)
if 'errno' not in decoded_token:
# Revisar argumentos válidos
json_data = request.get_json()
validate_arguments = Utils.allPostArgumentsExists(
json_data, ['email', 'password'])
if validate_arguments[0]:
# Crear db, tupla de args y llamada a SP
db = Database.getInstance(__dbHost, __dbUser, __dbPswd,
__dbName)
email = json_data['email']
password = json_data['password']
args = (email, password)
user_results = db.callProc(
Procedure.GET_USER_PLATFORM, args,
True) # Obtención de usuario
# Revisar que el usuario existe
if user_results:
response = OrderedDict([
('id', user_results[0]['id']),
('id_cliente', user_results[0]['id_cliente']),
('nombre', user_results[0]['nombre']),
('email', user_results[0]['email']),
('canales',
User.get_user_channels(user_results))
])
else:
# Usuario inválido
error = Error.INVALID_USER
else:
# Argumentos inválidos
error = copy.deepcopy(Error.REQUIRED_ARGUMENTS)
error['errmsg'] = error['errmsg'].format(
validate_arguments[1])
else:
# Token inválido
error = decoded_token
else:
# Token inexistente
error = Error.TOKEN_NOT_FOUND
else:
# Formato JSON inválido
error = Error.INVALID_REQUEST_BODY
except:
Utils.setLog()
error = Error.PROGRAMMING_ERROR
return wrappers.Response(json.dumps(response if error is None else error),
200,
mimetype='application/json')