379 lines
16 KiB
Python
379 lines
16 KiB
Python
import time
|
|
import random
|
|
import requests
|
|
import logging
|
|
import constants
|
|
import pytz
|
|
import walladb
|
|
import json
|
|
import string
|
|
from newrelic_telemetry_sdk import Event, EventClient, GaugeMetric, MetricClient
|
|
|
|
from PIL import Image, ImageDraw, ImageFont
|
|
from datetime import datetime, timedelta, timezone, date
|
|
from telegram import InlineKeyboardButton, InlineKeyboardMarkup
|
|
from telegram.ext import Application
|
|
from telegram.constants import ParseMode
|
|
|
|
# Enable logging
|
|
logging.basicConfig(
|
|
format='%(asctime)s - %(name)s - %(levelname)s - %(message)s', level=logging.INFO
|
|
)
|
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
def telegram_escape_characters(text):
|
|
for character in constants.TELEGRAM_ESCAPE_CHARACTERS:
|
|
try:
|
|
text = text.replace(character, f'\\{character}')
|
|
except:
|
|
pass
|
|
for character in constants.TELEGRAM_REMOVE_CHARACTERS:
|
|
try:
|
|
text = text.replace(character, '')
|
|
except:
|
|
pass
|
|
return text
|
|
|
|
def is_user_admin(telegram_user_id):
|
|
return telegram_user_id in constants.ADMIN_IDS
|
|
|
|
def get_telegram_user_id(update):
|
|
#return update.message.chat_id
|
|
return update.effective_chat.id
|
|
|
|
def get_telegram_user_name(update):
|
|
return update.message.from_user
|
|
|
|
def get_date_ahead(add_days):
|
|
date_ahead = date.today() + timedelta(days=add_days)
|
|
return date_ahead
|
|
|
|
def get_spanish_date(date):
|
|
return date.strftime("%d/%m/%Y")
|
|
|
|
def is_date_expired(until):
|
|
#until_date = datetime.strptime(until, "%d/%m/%Y")
|
|
difference = until - date.today()
|
|
return difference.days < 0
|
|
|
|
def random_wait():
|
|
time.sleep(random.random())
|
|
|
|
def download_image(article, product_id):
|
|
r = requests.get(article['images'][0]['original'])
|
|
if r.status_code == 200:
|
|
with open(f"/app/data/images/products/{article['id']}_{product_id}.jpg", "wb") as image:
|
|
image.write(r.content)
|
|
|
|
def create_image(article, product_id):
|
|
download_image(article, product_id)
|
|
currency = '?'
|
|
if article['currency'] == 'EUR':
|
|
currency = '€'
|
|
price = str(article['price']) + currency
|
|
wallamanta_text = "@wallamanta_bot"
|
|
width = 1280
|
|
height = 800
|
|
baseheight = int(height * 0.85)
|
|
# límite de ancho para la parte izquierda (producto)
|
|
wlimit = int(((width / 3) * 2) - 80)
|
|
# límite de ancho para los logos (homelabers y amazon)
|
|
wlogo = int(width * 0.2)
|
|
# fuente y tamaño
|
|
font = ImageFont.truetype("/app/data/fonts/Roboto-Bold.ttf", 90)
|
|
wallamanta_text_font = ImageFont.truetype("/app/data/fonts/Roboto-Bold.ttf", 40)
|
|
# inicializamos canvas
|
|
with Image.new('RGBA', (width, height), (255, 255, 255)) as image:
|
|
draw = ImageDraw.Draw(image)
|
|
# escribimos @wallamanta_bot
|
|
wtext, htext = draw.textsize(wallamanta_text, font=wallamanta_text_font)
|
|
draw.text(((width / 6) * 5 - wtext / 2, int(height - height * 0.2)), wallamanta_text, "#13C1AC", font=wallamanta_text_font)
|
|
# escribimos el precio
|
|
wtext, htext = draw.textsize(price, font=font)
|
|
draw.text(((width / 6) * 5 - wtext / 2, height / 2 - htext / 2), price, (0, 0, 0), font=font)
|
|
# dibujamos rectángulo verde externo, con un margen externo y ancho determinado
|
|
draw.rectangle([15, 15, width - 15, height - 15], width = 15, outline="#13C1AC")
|
|
# ponemos la imagen del producto en la parte izquierda y se redimensiona dependiendo de lo ancho
|
|
with Image.open(f"/app/data/images/products/{article['id']}_{product_id}.jpg") as product_image:
|
|
hpercent = (baseheight / float(product_image.size[1]))
|
|
wsize = int((float(product_image.size[0]) * float(hpercent)))
|
|
if wsize < wlimit:
|
|
resized_product_image = product_image.resize((wsize, baseheight), Image.Resampling.LANCZOS)
|
|
else:
|
|
wpercent = wlimit / float(product_image.size[0])
|
|
hsize = int((float(product_image.size[1]) * float(wpercent)))
|
|
resized_product_image = product_image.resize((wlimit, hsize), Image.Resampling.LANCZOS)
|
|
image.paste(resized_product_image, (int((width/3)-(resized_product_image.size[0]/2)), int((height/2) - (resized_product_image.size[1]/2))))
|
|
resized_product_image.close()
|
|
# guardamos la imagen con otro nombre
|
|
image.save(f"/app/data/images/products/{article['id']}_{product_id}_composed.png", quality=95)
|
|
|
|
def get_publish_date(article):
|
|
article_date = article['creation_date']
|
|
formato_fecha = "%Y-%m-%dT%H:%M:%S.%f%z"
|
|
return datetime.strptime(article_date, formato_fecha).astimezone(pytz.timezone("Europe/Madrid")).strftime("%d/%m/%Y - %H:%M:%S")
|
|
|
|
def get_modified_date(article):
|
|
article_date = article['modification_date']
|
|
formato_fecha = "%Y-%m-%dT%H:%M:%S.%f%z"
|
|
return datetime.strptime(article_date, formato_fecha).astimezone(pytz.timezone("Europe/Madrid")).strftime("%d/%m/%Y - %H:%M:%S")
|
|
|
|
def get_random_string(length):
|
|
result_str = ''.join(random.choice(string.ascii_letters) for i in range(length))
|
|
return result_str
|
|
|
|
def send_message(telegram_user_id, message):
|
|
files = {
|
|
'chat_id': (None, telegram_user_id),
|
|
'text': (None, message),
|
|
}
|
|
try:
|
|
requests.post(f'https://api.telegram.org/bot{constants.TELEGRAM_TOKEN}/sendMessage', files=files)
|
|
except:
|
|
time.sleep(1)
|
|
requests.post(f'https://api.telegram.org/bot{constants.TELEGRAM_TOKEN}/sendMessage', files=files)
|
|
|
|
def send_message_to_all(message):
|
|
for user in walladb.get_user_list:
|
|
try:
|
|
send_message(user['telegram_user_id'], message)
|
|
except Exception as e:
|
|
logging.info(f"Error sending message to {user['telegram_user_id']}: {e}")
|
|
|
|
def check_code(code):
|
|
walladb.get_code(code)
|
|
|
|
def send_article(article, product):
|
|
#application = Application.builder().get_updates_http_version('1.1').http_version('1.1').token(constants.TELEGRAM_TOKEN).build()
|
|
create_image(article, product['id'])
|
|
title = f"*{telegram_escape_characters(article['title'])}*"
|
|
description = f"*📝 Descripción*: {telegram_escape_characters(article['description'])}"
|
|
found_by = f"*🔍 Encontrado por la búsqueda de:* {telegram_escape_characters(product['product_name'])}"
|
|
created_at = f"*📅 Fecha de publicación:* {telegram_escape_characters(get_publish_date(article))}"
|
|
modified_at = f"*📅 Fecha de modificación:* {telegram_escape_characters(get_modified_date(article))}"
|
|
location = f"📍 *Lugar:* {telegram_escape_characters(article['location']['city'])} {telegram_escape_characters('(' + article['location']['postal_code'] + ')')} {telegram_escape_characters('- (' + article['location']['country_code'] + ')')}"
|
|
if article['shipping']['user_allows_shipping']:
|
|
user_ships = f"📦 *Envío:* ✅"
|
|
else:
|
|
user_ships = f"📦 *Envío:* ❌"
|
|
if article['currency'] == 'EUR':
|
|
currency = '€'
|
|
else:
|
|
currency = '?'
|
|
price = f"*💰 Precio*: {telegram_escape_characters(str(article['price']))} {telegram_escape_characters(currency)}"
|
|
text = f"{title}\n\n{description}\n\n{found_by}\n\n{created_at}\n{modified_at}\n\n{location}\n\n{user_ships}\n\n{price}"
|
|
#url = f"https://api.telegram.org/bot{constants.TELEGRAM_TOKEN}/sendPhoto?chat_id={product['telegram_user_id']}&caption={text}&parse_mode=MarkdownV2"
|
|
#files = {'photo':open(f"/app/data/images/products/{article['id']}_composed.png", 'rb')}
|
|
#keyboard = [[InlineKeyboardButton("Ir al anuncio", url=f"https://es.wallapop.com/item/{article['web_slug']}")]]
|
|
#InlineKeyboardButton("Listar productos", callback_data="list")]
|
|
#markup = InlineKeyboardMarkup(keyboard)
|
|
keyboard = {'inline_keyboard':[[{'text':'Ir al anuncio','url':f'https://es.wallapop.com/item/{article["web_slug"]}'}]]}
|
|
|
|
with open(f"/app/data/images/products/{article['id']}_{product['id']}_composed.png", 'rb') as image:
|
|
files = {
|
|
'chat_id': (None, product['telegram_user_id']),
|
|
'photo': image,
|
|
'caption': (None, text),
|
|
'parse_mode': (None, ParseMode.MARKDOWN_V2),
|
|
'reply_markup': (None, json.dumps(keyboard)),
|
|
}
|
|
|
|
response = requests.post(f'https://api.telegram.org/bot{constants.TELEGRAM_TOKEN}/sendPhoto', files=files)
|
|
tries = 0
|
|
while response.status_code != 200:
|
|
logging.info(f"Error sending to Telegram, probably flood restricted. {product['product_name']} ({product['id']}) - ({walladb.get_user(product['telegram_user_id'])}) - {response.status_code}")
|
|
random_wait()
|
|
response = requests.post(f'https://api.telegram.org/bot{constants.TELEGRAM_TOKEN}/sendPhoto', files=files)
|
|
tries = tries + 1
|
|
if tries > 5:
|
|
logging.info(f"Gave up after 5 retries. Error sending to Telegram, probably flood restricted. {product['product_name']} ({product['id']}) - ({walladb.get_user(product['telegram_user_id'])}) - {response.status_code}")
|
|
break
|
|
|
|
#response = await application.bot.send_photo(chat_id=product['telegram_user_id'], photo=open(f"/app/data/images/products/{article['id']}_composed.png", 'rb'), caption=text, parse_mode=ParseMode.MARKDOWN_V2, reply_markup=markup)
|
|
#logging.info(requests.post(url, files=files).content)
|
|
send_to_nr(article, product)
|
|
#logging.info(response.content)
|
|
logging.info(f"'{title}' (https://es.wallapop.com/item/{article['web_slug']}) found by {product['product_name']} ({product['id']}) - ({walladb.get_user(product['telegram_user_id'])})")
|
|
|
|
def get_category_name(category):
|
|
category = int(category)
|
|
return constants.CATEGORIES[category][0]
|
|
|
|
def get_subcategory_name(subcategory):
|
|
subcategory = int(subcategory)
|
|
subcategory_name = ''
|
|
for category in constants.CATEGORIES:
|
|
if has_subcategory(category):
|
|
if constants.CATEGORIES[category][1].get(subcategory):
|
|
subcategory_name = constants.CATEGORIES[category][1].get(subcategory)
|
|
return subcategory_name
|
|
|
|
def has_subcategory(category):
|
|
category = int(category)
|
|
return len(constants.CATEGORIES[category]) > 1
|
|
|
|
def is_subcategory(category, subcategory):
|
|
category = int(category)
|
|
subcategory = int(subcategory)
|
|
if has_subcategory(category):
|
|
return subcategory in constants.CATEGORIES[category][1]
|
|
else:
|
|
return False
|
|
|
|
def create_categories_keyboard(categories):
|
|
categories = categories.split(',')
|
|
count = 0
|
|
category_line = []
|
|
keyboard = []
|
|
for category in categories:
|
|
if has_subcategory(category):
|
|
category_line.append(InlineKeyboardButton(constants.CATEGORIES[int(category)][0], callback_data=f"{int(category)}"))
|
|
count = count + 1
|
|
if count % 3 == 0:
|
|
keyboard.append(category_line)
|
|
category_line = []
|
|
if count % 3 != 0:
|
|
keyboard.append(category_line)
|
|
keyboard.append([InlineKeyboardButton("Volver", callback_data="finish")])
|
|
return keyboard
|
|
|
|
def create_subcategory_keyboard(category):
|
|
category = int(category)
|
|
count = 0
|
|
subcategory_line = []
|
|
keyboard = []
|
|
for subcategory in constants.CATEGORIES[category][1]:
|
|
subcategory_line.append(InlineKeyboardButton(constants.CATEGORIES[category][1][subcategory], callback_data=f"{subcategory}"))
|
|
count = count + 1
|
|
if count % 3 == 0:
|
|
keyboard.append(subcategory_line)
|
|
subcategory_line = []
|
|
if count % 3 != 0:
|
|
keyboard.append(subcategory_line)
|
|
keyboard.append([InlineKeyboardButton("Volver", callback_data="finish")])
|
|
return keyboard
|
|
|
|
def create_category_keyboard():
|
|
count = 0
|
|
category_line = []
|
|
keyboard = []
|
|
for category in constants.CATEGORIES:
|
|
category_line.append(InlineKeyboardButton(constants.CATEGORIES[category][0], callback_data=f"{category}"))
|
|
count = count + 1
|
|
if count % 3 == 0:
|
|
keyboard.append(category_line)
|
|
category_line = []
|
|
if count % 3 != 0:
|
|
keyboard.append(category_line)
|
|
return keyboard
|
|
|
|
def create_products_keyboard(telegram_user_id):
|
|
count = 0
|
|
product_line = []
|
|
keyboard = []
|
|
for product in walladb.get_products_from_user(telegram_user_id):
|
|
product_line.append(InlineKeyboardButton(product['product_name'], callback_data=f"{product['product_name']}"))
|
|
count = count + 1
|
|
if count % 3 == 0:
|
|
keyboard.append(product_line)
|
|
product_line = []
|
|
if count % 3 != 0:
|
|
keyboard.append(product_line)
|
|
return keyboard
|
|
|
|
def create_continue_keyboard():
|
|
keyboard = [
|
|
[
|
|
InlineKeyboardButton("Finalizar", callback_data='add'),
|
|
InlineKeyboardButton("Descartar", callback_data='remove')
|
|
],
|
|
[
|
|
InlineKeyboardButton("Añadir categoría", callback_data='add_category'),
|
|
InlineKeyboardButton("Añadir subcategoría", callback_data='add_subcategory')
|
|
],[
|
|
InlineKeyboardButton("Exclusión de título", callback_data='title_exclude'),
|
|
InlineKeyboardButton("Exclusión de descripción", callback_data='title_description_exclude')
|
|
],[
|
|
InlineKeyboardButton("Coordenadas", callback_data='coords'),
|
|
InlineKeyboardButton("Distancia", callback_data='distance')
|
|
],
|
|
]
|
|
return keyboard
|
|
|
|
def generate_categories_string(categories, subcategories):
|
|
categories_string = ""
|
|
if '0' in categories.split(','):
|
|
categories_string = "todas"
|
|
elif len(categories) > 1:
|
|
for category in categories.split(','):
|
|
categories_string = f"{categories_string}{get_category_name(category)}"
|
|
if has_subcategory(category):
|
|
if len(subcategories) > 1:
|
|
subcategories_temp = ""
|
|
for subcategory in subcategories.split(','):
|
|
if is_subcategory(category, subcategory):
|
|
subcategories_temp = f"{subcategories_temp}{get_subcategory_name(subcategory)}, "
|
|
if subcategories_temp != "":
|
|
categories_string = f"{categories_string} ({subcategories_temp[:-2]})"
|
|
categories_string = f"{categories_string}, "
|
|
categories_string = categories_string[:-2]
|
|
else:
|
|
categories_string = "todas"
|
|
return categories_string
|
|
|
|
def get_thread(product_name):
|
|
global SEARCH_THREADS_LIST
|
|
for product_thread in SEARCH_THREADS_LIST:
|
|
if product_name == product_thread[0]:
|
|
return product_thread[1]
|
|
return None
|
|
|
|
def send_to_nr(article, product):
|
|
event = Event(
|
|
"ProductFound", {
|
|
"article_name": article['title'],
|
|
"article_price": article['price'],
|
|
"article_web_slug": article['web_slug'],
|
|
"product_name": product['product_name'],
|
|
"telegram_user_id": product['telegram_user_id'],
|
|
"telegram_name": walladb.get_user(product['telegram_user_id']),
|
|
"category_id": article['category_id'],
|
|
"seller_id": article['seller_id'],
|
|
"environment": constants.NR_ENV
|
|
}
|
|
)
|
|
event_client = EventClient(insert_key=constants.NEW_RELIC_INSERT_KEY, host=constants.NR_HOST_INSIGHTS)
|
|
try:
|
|
logging.info(f"=== Sending product {article['title']} info to NR ===")
|
|
response = event_client.send(event, timeout=30)
|
|
response.raise_for_status()
|
|
logging.info(f"=== Sent product {article['title']} info to NR ===")
|
|
except Exception as e:
|
|
logging.error(f"Error sending to NR: {e}")
|
|
|
|
def send_statistics_to_nr(query_time, products_found, number_of_searches):
|
|
metric_client = MetricClient(insert_key=constants.NEW_RELIC_INSERT_KEY, host=constants.NR_HOST_METRICS)
|
|
|
|
query_time = GaugeMetric("query_time", query_time, {"units": "Seconds"})
|
|
products_found = GaugeMetric("products_found", products_found)
|
|
number_of_searches = GaugeMetric("active_searches", number_of_searches)
|
|
|
|
batch = [query_time, products_found, number_of_searches]
|
|
try:
|
|
logging.info("=== Sending stats to NR ===")
|
|
response = metric_client.send_batch(batch, timeout=30)
|
|
response.raise_for_status()
|
|
logging.info("=== Stats sent to NR ===")
|
|
except Exception as e:
|
|
logging.error(f"Error sending to NR: {e}")
|
|
|
|
def is_valid_request(product):
|
|
is_valid = False
|
|
if walladb.get_product(product):
|
|
if not walladb.is_user_expired(product['telegram_user_id']):
|
|
if walladb.is_user_active(product['telegram_user_id']):
|
|
if walladb.is_user_premium(product['telegram_user_id']) or \
|
|
walladb.is_user_testing(product['telegram_user_id']):
|
|
is_valid = True
|
|
return is_valid |