Bot

import telebotfrom telebot import typesimport jsonfrom flask import Flask, requestimport osimport sqlite3import datetimeimport pytzimport psycopg2

TOKEN = "982316071:AAEBrmbkS0SIPRvjvVaAlPVoLhK6SwVpJec"bot = telebot.TeleBot(token=TOKEN)server = Flask(__name__)

#fecha = datetime.date.today()tz = pytz.timezone('America/Mexico_City')fecha = datetime.datetime.now(tz).date()

def conectar(): conexion = psycopg2.connect( host = "ec2-52-202-185-87.compute-1.amazonaws.com", database = "dfj43inlqq5ots", user = "sqnjannzplzmqq", password = "2da318b3355ae17d1dac555a3df412967747cd030ba4a11ba91fdb7b027aa017" ) return conexion

def findat(msg): # from a list of texts, it finds the one with the '@' sign for i in msg: if '@' in i: return i

def menciona_agentes(CHAT_ID,WHEREF8,GRANJAS8,conexion): sqlga8= """ SELECT W."FARM_ID", LST."AGENT_ID",LST."AGENT_NAME",LST."AGENT_ALIAS",LST."COMMENT" FROM PUBLIC."FARM_VOTE" LST ,( SELECT Z."FARM_ID",Y."FARM_ID" FARM_ID2 FROM (SELECT A."FARM_ID" ,VF."FARM_RG" FROM PUBLIC."FARM_VOTE" A, PUBLIC."VALID_FARMS" VF WHERE "FARM_DT" = %s AND "CHAT_ID" = %s AND A."FARM_ID" = VF."FARM_ID" AND A."FARM_ID" = VF."FARM_TXT" AND A."FARM_ID" NOT IN ('CDMX','CDMXN','CDMXS','CDMXC') )Z , (SELECT A."FARM_ID" ,VF."FARM_RG" FROM PUBLIC."FARM_VOTE" A, PUBLIC."VALID_FARMS" VF WHERE "FARM_DT" = %s AND "CHAT_ID" = %s AND A."FARM_ID" = VF."FARM_ID" AND A."FARM_ID" = VF."FARM_TXT" AND A."FARM_ID" IN ('CDMX','CDMXN','CDMXS','CDMXC') )Y WHERE Y."FARM_RG" = Z."FARM_RG" OR Y."FARM_RG" = 'ALL' UNION SELECT "FARM_ID", "FARM_ID" FROM PUBLIC."FARM_VOTE" A WHERE "FARM_DT" = %s AND "CHAT_ID" = %s AND A."FARM_ID" NOT IN ('CDMX','CDMXN','CDMXS','CDMXC') ) W WHERE W.FARM_ID2 = LST."FARM_ID" AND W."FARM_ID" IN %s AND "CHAT_ID" = %s ORDER BY W."FARM_ID" """ consultaga8 = conexion.cursor() where8_txt = tuple (WHEREF8) #bot.send_message(CHAT_ID,'Parametros Qry' + str(fecha) + str(CHAT_ID) + where8_txt) consultaga8.execute(sqlga8, (fecha,str(CHAT_ID),fecha,str(CHAT_ID),fecha,str(CHAT_ID),where8_txt,str(CHAT_ID))) rows_ga8 = consultaga8.fetchall()

#bot.send_message(CHAT_ID,'Menciona Ag' + str(len(rows_ga8))) if len(rows_ga8) > 0 : farm_ant ="" tagsagent = "" Multispuertextfarm = "" for row in rows_ga8: if not(farm_ant): farm_ant = row[0]

if (row[0] == farm_ant): if(tagsagent): if row[3]: tagsagent = tagsagent + '[' + row[3].strip() + '](tg://user?id=' + row[1].strip() + ') ' + row[4].strip() + '\n' else: tagsagent = tagsagent + '[' + row[2].strip() + '](tg://user?id=' + row[1].strip() + ') ' + row[4].strip() + '\n' else: if row[3]: tagsagent = '[' + row[3].strip() + '](tg://user?id=' + row[1].strip() + ') ' + row[4].strip() + '\n' else: tagsagent = '[' + row[2].strip() + '](tg://user?id=' + row[1].strip() + ') ' + row[4].strip() + '\n' else: Multispuertextfarm = "Agentes para Farm en " + farm_ant + ":\n" + tagsagent + "\n" farm_creada(CHAT_ID, Multispuertextfarm, farm_ant,conexion) #bot.send_message(CHAT_ID,Multispuertextfarm, parse_mode="Markdown") tagsagent = "" farm_ant = row[0] if row[3]: tagsagent = '[' + row[3].strip() + '](tg://user?id=' + row[1].strip() + ') ' + row[4].strip() + '\n' else: tagsagent = '[' + row[2].strip() + '](tg://user?id=' + row[1].strip() + ') ' + row[4].strip() + '\n'

Multispuertextfarm = "Agentes para Farm en " + farm_ant + ":\n" + tagsagent + "\n"

#bot.send_message(CHAT_ID,Multispuertextfarm, parse_mode="Markdown") farm_creada(CHAT_ID, Multispuertextfarm, farm_ant,conexion)

mes_txt = chg_month(fecha.strftime("%B"))

msgfarm8tit = b'\xF0\x9F\x8C\xBD'.decode('UTF-8') + ' ' + fecha.strftime("%d") + ' ' + mes_txt + ' ' + GRANJAS8 + ' Farm()'

#try:

bot.set_chat_title(CHAT_ID, msgfarm8tit) #except: # pass

def chg_month(mes): if mes == 'January': return 'Enero' if mes == 'February': return 'Febrero' if mes == 'March': return 'Marzo' if mes == 'April': return 'Abril' if mes == 'May': return 'Mayo' if mes == 'June': return 'Junio' if mes == 'July': return 'Julio' if mes == 'August': return 'Agosto' if mes == 'September': return 'Septiembre' if mes == 'October': return 'Octubre' if mes == 'November': return 'Noviembre' if mes == 'December': return 'Diciembre'

def farm_creada(CHAT_ID, Multispuertextfarm,farm,conexion): sqlfc= """ SELECT COUNT(*) FROM public."FARM_MESSAGES" WHERE "FARM_DT" = %s AND "CHAT_ID" = %s AND "FARM_ID" = %s """ consultafc = conexion.cursor() consultafc.execute(sqlfc, (fecha, str(CHAT_ID),farm))

existfc = consultafc.fetchall()

#bot.send_message(message.chat.id,exist[0][0])

if (existfc[0][0] <= 0): enviofc = bot.send_message(CHAT_ID,Multispuertextfarm, parse_mode="Markdown")

sqlfcins =""" INSERT INTO public."FARM_MESSAGES"("FARM_DT", "CHAT_ID", "FARM_ID", "MESSAGE_ID") VALUES(%s, %s, %s, %s) """

#bot.send_message(CHAT_ID,str(enviofc.message_id))

consultafcin = conexion.cursor() consultafcin.execute(sqlfcins, (fecha, str(CHAT_ID), farm, enviofc.message_id)) consultafcin.close() conexion.commit() else: sqlfcget =""" SELECT "MESSAGE_ID" FROM public."FARM_MESSAGES" WHERE "FARM_DT" = %s AND "CHAT_ID" = %s AND "FARM_ID" = %s """

consultafcget = conexion.cursor() consultafcget.execute(sqlfcget, (fecha, str(CHAT_ID),farm))

message_fc = consultafcget.fetchall()

try: bot.edit_message_text(chat_id = CHAT_ID, message_id= message_fc[0][0], text = Multispuertextfarm, parse_mode="Markdown") except: pass

consultafcget.close()

def Valida_granja8(CHAT_ID,conexion): sqlgetf8= """ SELECT X.FARM_ID, X.HORA FROM ( SELECT Y.FARM_ID, Y.VOTES, CASE WHEN Y.FARM_RG = 'CEN' THEN COALESCE(Y.CDMX,0) + COALESCE(Y.CDMXC,0) WHEN Y.FARM_RG = 'SUR' THEN coalesce(Y.CDMX,0) + coalesce(Y.CDMXS,0) WHEN Y.FARM_RG = 'NOR' THEN coalesce(Y.CDMX,0) + coalesce(Y.CDMXN,0) END COMODINES, Y.HORA FROM( SELECT Z."FARM_ID" FARM_ID, Z.VOTES, TO_CHAR(Z.HORA,'HH24:MI') HORA, "FARM_RG" FARM_RG ,(SELECT SUM(B."VOTES") FROM PUBLIC."FARM_VOTE" B WHERE B."FARM_DT" = Z."FARM_DT" AND B."CHAT_ID" = Z."CHAT_ID" AND B."FARM_ID" = 'CDMX') CDMX ,(SELECT SUM(B."VOTES") FROM PUBLIC."FARM_VOTE" B WHERE B."FARM_DT" = Z."FARM_DT" AND B."CHAT_ID" = Z."CHAT_ID" AND B."FARM_ID" = 'CDMXS') CDMXS ,(SELECT SUM(B."VOTES") FROM PUBLIC."FARM_VOTE" B WHERE B."FARM_DT" = Z."FARM_DT" AND B."CHAT_ID" = Z."CHAT_ID" AND B."FARM_ID" = 'CDMXN') CDMXN ,(SELECT SUM(B."VOTES") FROM PUBLIC."FARM_VOTE" B WHERE B."FARM_DT" = Z."FARM_DT" AND B."CHAT_ID" = Z."CHAT_ID" AND B."FARM_ID" = 'CDMXC') CDMXC FROM (SELECT A."FARM_DT",A."CHAT_ID",A."FARM_ID",VF."FARM_RG", SUM(A."VOTES") VOTES, MAX(A."HOUR") HORA FROM PUBLIC."FARM_VOTE" A, PUBLIC."VALID_FARMS" VF WHERE A."FARM_DT" = %s AND A."CHAT_ID" = %s AND A."FARM_ID" NOT IN ('CDMX','CDMXS', 'CDMXN', 'CDMXC') AND A."FARM_ID" = VF."FARM_ID" AND A."FARM_ID" = VF."FARM_TXT" GROUP BY A."FARM_DT", A."CHAT_ID", A."FARM_ID", VF."FARM_RG") Z ) Y )X WHERE X.VOTES + COALESCE(X.COMODINES,0) >= 8 """ consultagetf8 = conexion.cursor() consultagetf8.execute(sqlgetf8, (fecha,str(CHAT_ID)))

f8_row = consultagetf8.fetchall()

fams8 = "" farm8_inic = [] if len(f8_row) > 0:

for row in f8_row: farm = row[0].strip() hora = row[1] if fams8: fams8 = fams8 + ',' + farm + ' ' + str(hora) farm8_inic.append(farm) else: fams8 = farm + ' ' + str(hora) farm8_inic = [farm] return fams8, farm8_inic

def Update_keyboard(CHAT_ID, MESSAGE_ID,conexion): sqlupd= """ SELECT Y.FARM_ID, Y.VOTES, CASE WHEN Y.FARM_RG = 'CEN' THEN COALESCE(Y.CDMX,0) + COALESCE(Y.CDMXC,0) WHEN Y.FARM_RG = 'SUR' THEN COALESCE(Y.CDMX,0) + COALESCE(Y.CDMXS,0) WHEN Y.FARM_RG = 'NOR' THEN COALESCE(Y.CDMX,0) + COALESCE(Y.CDMXN,0) END COMODINES, Y.HORA FROM( SELECT Z."FARM_ID" FARM_ID, Z.VOTES, TO_CHAR(Z.HORA,'HH24:MI') HORA, "FARM_RG" FARM_RG ,(SELECT SUM(B."VOTES") FROM PUBLIC."FARM_VOTE" B WHERE B."FARM_DT" = Z."FARM_DT" AND B."CHAT_ID" = Z."CHAT_ID" AND B."FARM_ID" = 'CDMX') CDMX ,(SELECT SUM(B."VOTES") FROM PUBLIC."FARM_VOTE" B WHERE B."FARM_DT" = Z."FARM_DT" AND B."CHAT_ID" = Z."CHAT_ID" AND B."FARM_ID" = 'CDMXS') CDMXS ,(SELECT SUM(B."VOTES") FROM PUBLIC."FARM_VOTE" B WHERE B."FARM_DT" = Z."FARM_DT" AND B."CHAT_ID" = Z."CHAT_ID" AND B."FARM_ID" = 'CDMXN') CDMXN ,(SELECT SUM(B."VOTES") FROM PUBLIC."FARM_VOTE" B WHERE B."FARM_DT" = Z."FARM_DT" AND B."CHAT_ID" = Z."CHAT_ID" AND B."FARM_ID" = 'CDMXC') CDMXC FROM (SELECT A."FARM_DT",A."CHAT_ID",A."FARM_ID",VF."FARM_RG", SUM(A."VOTES") VOTES, MAX(A."HOUR") HORA FROM PUBLIC."FARM_VOTE" A, PUBLIC."VALID_FARMS" VF WHERE A."FARM_DT" = %s AND A."CHAT_ID" = %s AND A."FARM_ID" NOT IN ('CDMX','CDMXS', 'CDMXN', 'CDMXC') AND A."FARM_ID" = VF."FARM_ID" AND A."FARM_ID" = VF."FARM_TXT" GROUP BY A."FARM_DT", A."CHAT_ID", A."FARM_ID", VF."FARM_RG") Z) Y """ consultaupd = conexion.cursor() consultaupd.execute(sqlupd, (fecha,str(CHAT_ID)))

mes_kbrd = fecha.strftime("%d") + ' ' + chg_month(fecha.strftime("%B")) upd_row = consultaupd.fetchall()

if len(upd_row) > 0: key2 = types.InlineKeyboardMarkup() for row in upd_row: farm = row[0].strip() votos = row[1] comodines = row[2] hora = row[3]

text_row = "" if comodines: text_row = farm + ' ' + str(votos) + '(+' + str(comodines) +') ' + str(hora) else: text_row = farm + ' ' + str(votos) + ' ' + str(hora)

key2.add(types.InlineKeyboardButton(text_row, callback_data=farm)) key2.add(types.InlineKeyboardButton("Nueva Propuesta", callback_data="New"))

try:

bot.edit_message_text(chat_id = CHAT_ID, message_id= MESSAGE_ID, text = 'Votos ' + mes_kbrd, reply_markup=key2) except: pass else: key3 = types.InlineKeyboardMarkup() key3.add(types.InlineKeyboardButton("Nueva Propuesta", callback_data="New")) try: bot.edit_message_text(chat_id = CHAT_ID, message_id= MESSAGE_ID, text = 'Votos ' + mes_kbrd, reply_markup=key3) except: pass

def validaFarm(Farm,conexion):

sqlgetf= """ select "FARM_ID" from public."VALID_FARMS" WHERE "FARM_TXT" = %s """ consultagetf = conexion.cursor() consultagetf.execute(sqlgetf, [Farm])

valid_row = consultagetf.fetchall()

if len(valid_row) > 0: return valid_row[0][0].strip() else: return 'Invalid'

consultagetf.close()

def ins_vote(chat_id, agent_id, farm_id, votes, hour, agent_name, agent_alias, comment,conexion): sqlgetv= """ SELECT 'Y' from public."FARM_VOTE" where "FARM_DT" = %s and "CHAT_ID" = %s and "AGENT_ID" = %s and "FARM_ID" = %s """ consultagetv = conexion.cursor() consultagetv.execute(sqlgetv, (fecha,str(chat_id), agent_id, farm_id))

exists_v = consultagetv.fetchall()

if len(exists_v) > 0: sqldelv= """ DELETE from public."FARM_VOTE" where "FARM_DT" = %s and "CHAT_ID" = %s and "AGENT_ID" = %s and "FARM_ID" = %s """ consultadelv = conexion.cursor() consultadelv.execute(sqldelv, (fecha,str(chat_id), agent_id, farm_id)) consultadelv.close() conexion.commit()

vborra_mesfarm(chat_id, farm_id,conexion)

else: sqlins= """ INSERT INTO public."FARM_VOTE"("FARM_DT","CHAT_ID","AGENT_ID","FARM_ID", "VOTES","HOUR","AGENT_NAME","AGENT_ALIAS","COMMENT") VALUES(%s,%s,%s,%s,%s,%s,%s,%s,%s) """ consultains = conexion.cursor() consultains.execute(sqlins, (fecha,str(chat_id), agent_id, farm_id, votes, hour, agent_name, agent_alias, comment)) consultains.close() conexion.commit()

def vborra_mesfarm(chat_id, farm_id,conexion): sqlvalidx8= """ SELECT W.VOTES + W.COMODINES FROM ( SELECT Y.FARM_ID, Y.VOTES, CASE WHEN Y.FARM_RG = 'CEN' THEN COALESCE(Y.CDMX,0) + COALESCE(Y.CDMXC,0) WHEN Y.FARM_RG = 'SUR' THEN COALESCE(Y.CDMX,0) + COALESCE(Y.CDMXS,0) WHEN Y.FARM_RG = 'NOR' THEN COALESCE(Y.CDMX,0) + COALESCE(Y.CDMXN,0) END COMODINES FROM( SELECT Z."FARM_ID" FARM_ID, Z.VOTES, "FARM_RG" FARM_RG ,(SELECT SUM(B."VOTES") FROM PUBLIC."FARM_VOTE" B WHERE B."FARM_DT" = Z."FARM_DT" AND B."CHAT_ID" = Z."CHAT_ID" AND B."FARM_ID" = 'CDMX') CDMX ,(SELECT SUM(B."VOTES") FROM PUBLIC."FARM_VOTE" B WHERE B."FARM_DT" = Z."FARM_DT" AND B."CHAT_ID" = Z."CHAT_ID" AND B."FARM_ID" = 'CDMXS') CDMXS ,(SELECT SUM(B."VOTES") FROM PUBLIC."FARM_VOTE" B WHERE B."FARM_DT" = Z."FARM_DT" AND B."CHAT_ID" = Z."CHAT_ID" AND B."FARM_ID" = 'CDMXN') CDMXN ,(SELECT SUM(B."VOTES") FROM PUBLIC."FARM_VOTE" B WHERE B."FARM_DT" = Z."FARM_DT" AND B."CHAT_ID" = Z."CHAT_ID" AND B."FARM_ID" = 'CDMXC') CDMXC FROM (SELECT A."FARM_DT",A."CHAT_ID",A."FARM_ID",VF."FARM_RG", SUM(A."VOTES") VOTES FROM PUBLIC."FARM_VOTE" A, PUBLIC."VALID_FARMS" VF WHERE A."FARM_DT" = %s AND A."CHAT_ID" = %s AND A."FARM_ID" = %s AND A."FARM_ID" = VF."FARM_ID" AND A."FARM_ID" = VF."FARM_TXT" GROUP BY A."FARM_DT", A."CHAT_ID", A."FARM_ID", VF."FARM_RG") Z) Y)W """ consultadelvalid = conexion.cursor() consultadelvalid.execute(sqlvalidx8, (fecha,str(chat_id), farm_id))

rows_deleted = consultadelvalid.fetchall()

if len(rows_deleted) > 0: if rows_deleted[0][0] < 8: sub_borra_msgf(chat_id, farm_id,conexion) else: sub_borra_msgf(chat_id, farm_id,conexion)

consultadelvalid.close()

def sub_borra_msgf(chat_id, farm_id,conexion): sqlsbf = """ select "MESSAGE_ID" from public."FARM_MESSAGES" where "FARM_DT" = %s and "CHAT_ID" = %s and "FARM_ID" = %s """ consultasbf = conexion.cursor() consultasbf.execute(sqlsbf, (fecha,str(chat_id), farm_id))

rows_sbf = consultasbf.fetchall() if len(rows_sbf) > 0:

bot.delete_message(chat_id, rows_sbf[0][0])

sqlsbfd = """ DELETE from public."FARM_MESSAGES" where "FARM_DT" = %s and "CHAT_ID" = %s and "FARM_ID" = %s """ consultasbfd = conexion.cursor() consultasbfd.execute(sqlsbfd, (fecha,str(chat_id), farm_id)) consultasbfd.close() conexion.commit() consultasbf.close()

def Create_Keybrd(CHAT_ID,conexion, Chat_Type): consulta = conexion.cursor() #bot.send_message(message.chat.id,fecha)

sql= """ SELECT COUNT(*) FROM public."FARM_POOL" WHERE "FARM_DT" = %s AND "CHAT_ID" = %s """

consulta.execute(sql, (fecha, str(CHAT_ID)))

exist = consulta.fetchall()

#bot.send_message(message.chat.id,exist[0][0])

if (exist[0][0] <= 0): key = types.InlineKeyboardMarkup() key.add(types.InlineKeyboardButton("Nueva Propuesta", callback_data="New")) envio = bot.send_message(CHAT_ID, 'Crear keyboard', reply_markup=key)

if Chat_Type != 'private': try: bot.pin_chat_message(CHAT_ID, envio.message_id) except: pass

#Elimina los registros anteriores para mantener registros al minimo sql2= """ DELETE FROM public."FARM_POOL" WHERE "FARM_DT" < %s and "CHAT_ID" = %s """ consulta2 = conexion.cursor() consulta2.execute(sql2, (fecha,str(CHAT_ID))) consulta2.close()

sql2a= """ DELETE FROM public."FARM_VOTE" WHERE "FARM_DT" < %s and "CHAT_ID" = %s """ consulta2a = conexion.cursor() consulta2a.execute(sql2a, (fecha,str(CHAT_ID))) consulta2a.close()

conexion.commit()

sql2b= """ DELETE FROM public."FARM_MESSAGES" WHERE "FARM_DT" < %s and "CHAT_ID" = %s """ consulta2b = conexion.cursor() consulta2b.execute(sql2b, (fecha,str(CHAT_ID))) consulta2b.close()

conexion.commit()

#Inserta el registro del dia

sql3= """ INSERT INTO public."FARM_POOL"("FARM_DT", "CHAT_ID", "MESSAGE_ID") VALUES(%s, %s, %s) """ consulta3 = conexion.cursor() consulta3.execute(sql3, (fecha,str(CHAT_ID),envio.message_id)) consulta3.close() message_id_farm = envio.message_id

conexion.commit() else: sql3a= """ SELECT "MESSAGE_ID" FROM public."FARM_POOL" WHERE "FARM_DT" = %s AND "CHAT_ID" = %s """ consulta3a = conexion.cursor() consulta3a.execute(sql3a, (fecha, str(CHAT_ID))) mes_fetch = consulta3a.fetchall() message_id_farm = mes_fetch[0][0] consulta3a.close()

consulta.close()

return int(message_id_farm)

def searchx(trying2, message,conexion):

sqls1= """ SELECT "FARM_ID", "SRC_RPL" FROM PUBLIC."VALID_FARMS" WHERE SUBSTRING(%s,POSITION('X' IN %s) - "SRC_INI", "SRC_FIN") = "FARM_TXT" AND POSITION('X' IN %s) - "SRC_INI" >= 0 """ consultas1 = conexion.cursor() consultas1.execute(sqls1, (trying2,trying2,trying2)) rows_s1_fetch = consultas1.fetchall()

trying2a = trying2

#bot.send_message(message.chat.id, 'Registro Xs' + str(len(rows_s1_fetch))) if len(rows_s1_fetch) > 0 : for row in rows_s1_fetch: #bot.send_message(message.chat.id, 'Remplazo ' + row[0].strip() + 'con' + row[1].strip()) trying2a = trying2.replace(row[0].strip(),row[1].strip()) #sendText(chatid, "Bling Bling Bling! ! tenemos un ganador!!!!");

#bot.send_message(message.chat.id, 'Despues del replace' + trying2a) trying2a = trying2a.replace("X","*") #bot.send_message(message.chat.id, 'Remplazando X' + trying2a) trying2a = trying2a.replace("@","X") #bot.send_message(message.chat.id, 'Remplazando @' + trying2a) else: trying2a = trying2a.replace("X","*") consultas1.close()

return trying2a

@bot.message_handler(commands=['start']) # welcome message handlerdef send_welcome(message): bot.reply_to(message, 'Ya Cambio1')

@bot.message_handler(commands=['help']) # help message handlerdef send_welcome(message): bot.reply_to(message, 'ALPHA = FEATURES MAY NOT WORK')

@bot.message_handler(func=lambda m: True)def granjas(message): #bot.send_message(message.chat.id, 'fecha' + str(fecha)) conexion = conectar() #Extract the comment thecomm2 = message.text.upper() iscommntbgn = thecomm2.find("(") iscommntend = thecomm2.find(")") idagente = str(message.from_user.id) N_agente = str(message.from_user.first_name) U_agente = str(message.from_user.username)

#bot.send_message(message.chat.id, 'mensaje' + str(message))

comment_vto = "" resthrly = "" restcomm = "" avercuant = 0 numvotes1 = 0

if (iscommntbgn == -1): trying = thecomm2 else: if (iscommntend == -1): #Comentario No cerrado se va al final comment_vto = thecomm2[iscommntbgn + 1:len(thecomm2)] iscommntend = len(thecomm2) else: #/*Extrae comentario*/ comment_vto = thecomm2[iscommntbgn + 1:iscommntend] comment_vto = comment_vto.strip()

if (iscommntend < len(thecomm2)): restcomm = thecomm2[iscommntend + 1:len(thecomm2)]

trying = thecomm2[0:iscommntbgn] + restcomm trying = trying.strip() fistlet_comm = comment_vto[0:1] demas_comm = comment_vto[1:len(comment_vto)] comment_vto = fistlet_comm.upper() + demas_comm.lower() trying = trying.replace(" ","") trying = trying.replace(".","")

#bot.send_message(message.chat.id, 'Comentario' + comment_vto + 'Resto msg' + trying)

#Searching hour ishrly = trying.find(":") if (ishrly == -1) : trying2 = trying lahora = "20:00" else: newtry = trying[ishrly -2:ishrly + 3] trying2 = trying[0:ishrly-2]

hors = newtry.split(":")[0] mins = newtry.split(":")[1] if (int(hors) >= 24): hors = 23 mins = 59 else: if (int(mins) >= 60): mins = 59

lahora = str(hors) + ":" + str(mins)

if (ishrly + 3 < len(trying)): resthrly = trying[ishrly + 3:len(trying)]

#bot.send_message(message.chat.id, 'Antes rest' + trying2) trying2 = trying2 + resthrly #bot.send_message(message.chat.id, 'Despues rest' + trying2)

ismulti2 = trying2.find("X") if (ismulti2 != -1): #//sendText(chatid, "Antes de" + trying2); #bot.send_message(message.chat.id, 'Nuevo msg' + trying2) trying2 = searchx(trying2, message,conexion) #bot.send_message(message.chat.id, 'After search x' + trying2)

ismulti = trying2.find("*") #bot.send_message(message.chat.id, 'ismulti ' + str(ismulti)) trying3 = trying2 if (ismulti == -1): numvotes1 = 1 else: avercuant = trying2[ismulti+1:len(trying2)] #bot.send_message(message.chat.id, 'avercuant ' + avercuant) numvotes1 = int(avercuant) trying3 = trying2[0:ismulti]

isdiffer = trying3.find("/")

if (isdiffer == -1): VoteTo = validaFarm(str(trying3), conexion) if (VoteTo != "Invalid"): ins_vote(message.chat.id,idagente, VoteTo, numvotes1, lahora, N_agente, U_agente, comment_vto, conexion) else: diffpreset = trying3.split("/")

for diffpreset in diffpreset: VoteTo = validaFarm(str(diffpreset), conexion) if (VoteTo != "Invalid"): ins_vote(message.chat.id,idagente, VoteTo, numvotes1, lahora, N_agente, U_agente, comment_vto, conexion)

message_id_farm = Create_Keybrd(message.chat.id,conexion, message.chat.type) Update_keyboard(message.chat.id, message_id_farm, conexion)

granjas8,farm8_inic = Valida_granja8(message.chat.id, conexion)

if granjas8: menciona_agentes(message.chat.id,farm8_inic, granjas8, conexion) #bot.send_message(message.chat.id, 'Ya se armó la machaca' + granjas8)

#bot.send_message(message.chat.id, 'Comentario' + comment_vto + 'Hora' + lahora + "Votos" + str(numvotes1) + 'Nuevo msg' + trying3) conexion.close()

#bot.send_message(message.chat.id, 'Mensaje_keyboard =' + str(message_id_farm))#@bot.callback_query_handler(func=lambda call: True)#def callback_inline(call):@bot.callback_query_handler(func=lambda call: True)def test_callback(call): conexion = conectar() idagente = str(call.from_user.id) N_agente = str(call.from_user.first_name) U_agente = str(call.from_user.username)

#bot.send_message(call.message.chat.id, 'Esto sirve?' + str(call)) VoteTo = str(call.data) message_kb = str(call.message.message_id)

if VoteTo != "New": comment_vto = ""

sqllasth= """ select max("HOUR") from public."FARM_VOTE" WHERE "FARM_DT" = %s AND "CHAT_ID" = %s AND "FARM_ID" = %s """ consultalasth = conexion.cursor() consultalasth.execute(sqllasth, (fecha, str(call.message.chat.id), VoteTo)) lasthrfr = consultalasth.fetchall()

if len(lasthrfr) > 0: lahora = lasthrfr[0][0] else: lahora = "20:00" #bot.send_message(call.message.chat.id,idagente + VoteTo) ins_vote(call.message.chat.id, idagente, VoteTo, 1, lahora, N_agente, U_agente, comment_vto, conexion)

bot.answer_callback_query(call.id)

Update_keyboard(call.message.chat.id, message_kb, conexion)

granjas8,farm8_inic = Valida_granja8(call.message.chat.id, conexion)

if granjas8: menciona_agentes(call.message.chat.id,farm8_inic,granjas8, conexion) conexion.close()

@server.route('/' + TOKEN, methods=['POST'])def getMessage(): bot.process_new_updates([telebot.types.Update.de_json(request.stream.read().decode("utf-8"))]) return "!", 200

@server.route("/")def webhook(): bot.remove_webhook() bot.set_webhook(url='https://guarded-citadel-09093.herokuapp.com/' + TOKEN) return "!", 200

if __name__ == "__main__": server.run(host="0.0.0.0", port=int(os.environ.get('PORT', 5000)))

conexion.commit()conexion.close()