def alertarPocoVino(s):
if botValido(s) is False:
return
horas = read(msg=_(
'¿Cuántas horas deben quedar hasta que se acabe el vino en una ciudad para que es dé aviso?: '
),
min=1)
print(
_('Se avisará cuando el vino se acabe en {:d} horas en alguna ciudad.'
).format(horas))
enter()
forkear(s)
if s.padre is True:
return
info = _('\nAviso si el vino se acaba en {:d} horas\n').format(horas)
setInfoSignal(s, info)
try:
do_it(s, horas)
except:
msg = _('Error en:\n{}\nCausa:\n{}').format(info,
traceback.format_exc())
sendToBot(msg)
finally:
s.logout()
def searchForIslandSpaces(session, event, stdin_fd):
"""
Parameters
----------
session : ikabot.web.session.Session
event : multiprocessing.Event
stdin_fd: int
"""
sys.stdin = os.fdopen(stdin_fd)
try:
if checkTelegramData(session) is False:
event.set()
return
banner()
print(_('I will search for new spaces each hour.'))
enter()
except KeyboardInterrupt:
event.set()
return
set_child_mode(session)
event.set()
info = _('\nI search for new spaces each hour\n')
setInfoSignal(session, info)
try:
do_it(session)
except:
msg = _('Error in:\n{}\nCause:\n{}').format(info,
traceback.format_exc())
sendToBot(session, msg)
finally:
session.logout()
def loginDaily(session, event, stdin_fd, predetermined_input):
"""
Parameters
----------
session : ikabot.web.session.Session
event : multiprocessing.Event
stdin_fd: int
predetermined_input : multiprocessing.managers.SyncManager.list
"""
sys.stdin = os.fdopen(stdin_fd)
config.predetermined_input = predetermined_input
try:
banner()
print(_('I will enter every day.'))
enter()
except KeyboardInterrupt:
event.set()
return
set_child_mode(session)
event.set()
info = _('\nI enter every day\n')
setInfoSignal(session, info)
try:
do_it(session)
except Exception as e:
msg = _('Error in:\n{}\nCause:\n{}').format(info,
traceback.format_exc())
sendToBot(session, msg)
finally:
session.logout()
def searchForIslandSpaces(s, e, fd):
sys.stdin = os.fdopen(fd)
try:
if checkTelegramData(s) is False:
e.set()
return
banner()
print(_('I will search for new spaces each hour.'))
enter()
except KeyboardInterrupt:
e.set()
return
set_child_mode(s)
e.set()
info = _('\nI search for new spaces each hour\n')
setInfoSignal(s, info)
try:
do_it(s)
except:
msg = _('Error in:\n{}\nCause:\n{}').format(info,
traceback.format_exc())
sendToBot(s, msg)
finally:
s.logout()
def alertAttacks(s,e,fd):
sys.stdin = os.fdopen(fd)
try:
if checkTelegramData(s) is False:
e.set()
return
banner()
default = 20
minutes = read(msg=_('How often should I search for attacks?(min:3, default: {:d}): ').format(default), min=3, empty=True)
if minutes == '':
minutes = default
print(_('I will check for attacks every {:d} minutes').format(minutes))
enter()
except KeyboardInterrupt:
e.set()
return
set_child_mode(s)
e.set()
info = _('\nI check for attacks every {:d} minutes\n').format(minutes)
setInfoSignal(s, info)
try:
do_it(s, minutes)
except:
msg = _('Error in:\n{}\nCause:\n{}').format(info, traceback.format_exc())
sendToBot(s, msg)
finally:
s.logout()
def entrarDiariamente(s):
print(_('Se entrará todos los días automaticamente.'))
enter()
forkear(s)
if s.padre is True:
return
info = _('\nEntro diariamente\n')
setInfoSignal(s, info)
try:
do_it(s)
except:
msg = _('Error en:\n{}\nCausa:\n{}').format(info,
traceback.format_exc())
sendToBot(msg)
finally:
s.logout()
def buscarEspacios(s):
if botValido(s) is False:
return
print('Se buscarán espacios nuevos cada hora.')
enter()
forkear(s)
if s.padre is True:
return
info = '\nBusco espacios nuevos en las islas cada 1 hora\n'
setInfoSignal(s, info)
try:
do_it(s)
except:
msg = 'Error en:\n{}\nCausa:\n{}'.format(info, traceback.format_exc())
sendToBot(msg)
finally:
s.logout()
def alertAttacks(session, event, stdin_fd, predetermined_input):
"""
Parameters
----------
session : ikabot.web.session.Session
event : multiprocessing.Event
stdin_fd: int
predetermined_input : multiprocessing.managers.SyncManager.list
"""
sys.stdin = os.fdopen(stdin_fd)
config.predetermined_input = predetermined_input
try:
if checkTelegramData(session) is False:
event.set()
return
banner()
default = 20
minutes = read(msg=_(
'How often should I search for attacks?(min:3, default: {:d}): ').
format(default),
min=3,
default=default)
# min_units = read(msg=_('Attacks with less than how many units should be ignored? (default: 0): '), digit=True, default=0)
print(_('I will check for attacks every {:d} minutes').format(minutes))
enter()
except KeyboardInterrupt:
event.set()
return
set_child_mode(session)
event.set()
info = _('\nI check for attacks every {:d} minutes\n').format(minutes)
setInfoSignal(session, info)
try:
do_it(session, minutes)
except Exception as e:
msg = _('Error in:\n{}\nCause:\n{}').format(info,
traceback.format_exc())
sendToBot(session, msg)
finally:
session.logout()
def alertarAtaques(s):
if botValido(s) is False:
return
print('Se buscarán ataques cada 20 minutos.')
enter()
forkear(s)
if s.padre is True:
return
info = '\nEspero por ataques cada 20 minutos\n'
setInfoSignal(s, info)
try:
do_it(s)
except:
msg = 'Error en:\n{}\nCausa:\n{}'.format(info, traceback.format_exc())
sendToBot(msg)
finally:
s.logout()
def alertAttacks(session, event, stdin_fd):
"""
Parameters
----------
session : ikabot.web.session.Session
event : multiprocessing.Event
stdin_fd: int
"""
sys.stdin = os.fdopen(stdin_fd)
try:
if checkTelegramData(session) is False:
event.set()
return
banner()
default = 20
minutes = read(msg=_(
'How often should I search for attacks?(min:3, default: {:d}): ').
format(default),
min=3,
empty=True)
if minutes == '':
minutes = default
print(_('I will check for attacks every {:d} minutes').format(minutes))
enter()
except KeyboardInterrupt:
event.set()
return
set_child_mode(session)
event.set()
info = _('\nI check for attacks every {:d} minutes\n').format(minutes)
setInfoSignal(session, info)
try:
do_it(session, minutes)
except:
msg = _('Error in:\n{}\nCause:\n{}').format(info,
traceback.format_exc())
sendToBot(session, msg)
finally:
session.logout()
def loginDaily(s, e, fd):
sys.stdin = os.fdopen(fd)
try:
banner()
print(_('I will enter every day.'))
enter()
except KeyboardInterrupt:
e.set()
return
set_child_mode(s)
e.set()
info = _('\nI enter every day\n')
setInfoSignal(s, info)
try:
do_it(s)
except:
msg = _('Error in:\n{}\nCause:\n{}').format(info,
traceback.format_exc())
sendToBot(s, msg)
finally:
s.logout()
def botValido(s):
if telegramFileValido():
return True
else:
print(
_('Debe proporcionar las credenciales válidas para comunicarse por telegram.'
))
print(_('Se requiere del token del bot a utilizar y de su chat_id'))
print(
_('Para más informacion sobre como obtenerlos vea al readme de https://github.com/physics-sp/ikabot'
))
rta = read(msg=_('¿Porporcionará las credenciales ahora? [y/N]'),
values=['y', 'Y', 'n', 'N', ''])
if rta.lower() != 'y':
return False
else:
botToken = read(msg=_('Token del bot:'))
chat_id = read(msg=_('Chat_id:'))
with open(config.telegramFile, 'w', os.O_NONBLOCK) as filehandler:
filehandler.write(botToken + '\n' + chat_id)
filehandler.flush()
rand = random.randint(1000, 9999)
msg = _('El token a ingresar es:{:d}').format(rand)
sendToBot(msg, Token=True)
rta = read(
msg=_('Se envio un mensaje por telegram, ¿lo recibió? [Y/n]'),
values=['y', 'Y', 'n', 'N', ''])
if rta.lower() == 'n':
with open(config.telegramFile, 'w', os.O_NONBLOCK) as file:
pass
print(_('Revíse las credenciales y vuelva a proveerlas.'))
enter()
return False
else:
recibido = read(
msg=_('Ingrese el token recibido mediante telegram:'),
digit=True)
if rand != recibido:
with open(config.telegramFile, 'w', os.O_NONBLOCK) as file:
pass
print(_('El token es incorrecto'))
enter()
return False
else:
print(_('El token es correcto.'))
enter()
return True
def searchForIslandSpaces(session, event, stdin_fd):
"""
Parameters
----------
session : ikabot.web.session.Session
event : multiprocessing.Event
stdin_fd: int
"""
sys.stdin = os.fdopen(stdin_fd)
try:
if checkTelegramData(session) is False:
event.set()
return
banner()
print(
'Do you want to search for spaces on your islands or a specific set of islands?'
)
print('(0) Exit')
print('(1) Search all islands I have colonised')
print('(2) Search a specific set of islands')
choice = read(min=0, max=2)
islandList = []
if choice == 0:
event.set()
return
elif choice == 2:
banner()
print(
'Insert the coordinates of each island you want searched like so: X1:Y1, X2:Y2, X3:Y3...'
)
coords_string = read()
coords_string = coords_string.replace(' ', '')
coords = coords_string.split(',')
for coord in coords:
coord = '&xcoord=' + coord
coord = coord.replace(':', '&ycoord=')
html = session.get('view=island' + coord)
island = getIsland(html)
islandList.append(island['id'])
else:
pass
banner()
print(
'How frequently should the islands be searched in minutes (minimum is 3)?'
)
time = read(min=3, digit=True)
banner()
print(_('I will search for changes in the selected islands'))
enter()
except KeyboardInterrupt:
event.set()
return
set_child_mode(session)
event.set()
info = _('\nI search for new spaces each hour\n')
setInfoSignal(session, info)
try:
do_it(session, islandList, time)
except:
msg = _('Error in:\n{}\nCause:\n{}').format(info,
traceback.format_exc())
sendToBot(session, msg)
finally:
session.logout()
def buyResources(session, event, stdin_fd):
"""
Parameters
----------
session : ikabot.web.session.Session
event : multiprocessing.Event
stdin_fd: int
"""
sys.stdin = os.fdopen(stdin_fd)
try:
banner()
# get all the cities with a store
commercial_cities = getCommercialCities(session)
if len(commercial_cities) == 0:
print(_('There is no store build'))
enter()
event.set()
return
# choose which city to buy from
if len(commercial_cities) == 1:
city = commercial_cities[0]
else:
city = chooseCommertialCity(commercial_cities)
banner()
# choose resource to buy
resource = chooseResource(session, city)
banner()
# get all the offers of the chosen resource from the chosen city
offers = getOffers(session, city)
if len(offers) == 0:
print(_('There are no offers available.'))
event.set()
return
# display offers to the user
total_price = 0
total_amount = 0
for offer in offers:
amount = offer['amountAvailable']
price = offer['precio']
cost = amount * price
print(_('amount:{}').format(addDot(amount)))
print(_('price :{:d}').format(price))
print(_('cost :{}').format(addDot(cost)))
print('')
total_price += cost
total_amount += amount
# ask how much to buy
print(
_('Total amount available to purchase: {}, for {}').format(
addDot(total_amount), addDot(total_price)))
available = city['freeSpaceForResources'][resource]
if available < total_amount:
print(
_('You just can buy {} due to storing capacity').format(
addDot(available)))
total_amount = available
print('')
amount_to_buy = read(msg=_('How much do you want to buy?: '),
min=0,
max=total_amount)
if amount_to_buy == 0:
event.set()
return
# calculate the total cost
gold = getGold(session, city)
total_cost = calculateCost(offers, amount_to_buy)
print(
_('\nCurrent gold: {}.\nTotal cost : {}.\nFinal gold : {}.'
).format(addDot(gold), addDot(total_cost),
addDot(gold - total_cost)))
print(_('Proceed? [Y/n]'))
rta = read(values=['y', 'Y', 'n', 'N', ''])
if rta.lower() == 'n':
event.set()
return
print(_('It will be purchased {}').format(addDot(amount_to_buy)))
enter()
except KeyboardInterrupt:
event.set()
return
set_child_mode(session)
event.set()
info = _('\nI will buy {} from {} to {}\n').format(
addDot(amount_to_buy), materials_names[resource], city['cityName'])
setInfoSignal(session, info)
try:
do_it(session, city, offers, amount_to_buy)
except:
msg = _('Error in:\n{}\nCause:\n{}').format(info,
traceback.format_exc())
sendToBot(session, msg)
finally:
session.logout()
def comprarRecursos(s):
banner()
ciudades_comerciales = getCiudadesComerciales(s)
if len(ciudades_comerciales) == 0:
print(_('No hay una Tienda contruida'))
enter()
return
ciudad = ciudades_comerciales[0] # por ahora solo uso la primera ciudad
numRecurso, recurso = asignarRecursoBuscado(s, ciudad)
banner()
ofertas = obtenerOfertas(s, ciudad)
if len(ofertas) == 0:
print(_('No se encontraron ofertas.'))
return
precio_total = 0
cantidad_total = 0
for oferta in ofertas:
cantidad = oferta['cantidadDisponible']
unidad = oferta['precio']
costo = cantidad * unidad
print(_('cantidad :{}').format(addPuntos(cantidad)))
print(_('precio :{:d}').format(unidad))
print(_('costo :{}').format(addPuntos(costo)))
print('')
precio_total += costo
cantidad_total += cantidad
ocupado = getRecursosDisponibles(ciudad['html'], num=True)[numRecurso - 1]
capacidad = getCapacidadDeAlmacenamiento(ciudad['html'], num=True)
disponible = capacidad - ocupado
print(
_('Total disponible para comprar: {}, por {}').format(
addPuntos(cantidad_total), addPuntos(precio_total)))
if disponible < cantidad_total:
print(
_('Solo se puede comprar {} por falta de almacenamiento.').format(
addPuntos(disponible)))
cantidad_total = disponible
print('')
cantidadAComprar = read(msg=_('¿Cuánta cantidad comprar? '),
min=0,
max=cantidad_total)
if cantidadAComprar == 0:
return
oro = getOro(s, ciudad)
costoTotal = calcularCosto(ofertas, cantidadAComprar)
print(
_('\nOro actual : {}.\nCosto total: {}.\nOro final : {}.').format(
addPuntos(oro), addPuntos(costoTotal),
addPuntos(oro - costoTotal)))
print(_('¿Proceder? [Y/n]'))
rta = read(values=['y', 'Y', 'n', 'N', ''])
if rta.lower() == 'n':
return
print(_('Se comprará {}').format(addPuntos(cantidadAComprar)))
enter()
forkear(s)
if s.padre is True:
return
info = _('\nCompro {} de {} para {}\n').format(addPuntos(cantidadAComprar),
tipoDeBien[numRecurso - 1],
ciudad['cityName'])
setInfoSignal(s, info)
try:
do_it(s, ciudad, ofertas, cantidadAComprar)
except:
msg = _('Error en:\n{}\nCausa:\n{}').format(info,
traceback.format_exc())
sendToBot(msg)
finally:
s.logout()