import logging import requests from database import * # Import all DB functions from config import * # Import constants if needed (like BOT_TOKEN for direct API calls, although better passed) from PIL import Image, ImageDraw, ImageFont import os from requests.auth import HTTPBasicAuth logger = logging.getLogger(__name__) def format_raffle_details(raffle_id): """Fetches and formats raffle details for display, including multi-channel prices.""" raffle = get_raffle(raffle_id) # Fetches basic info from 'raffles' table if not raffle: return "Error: No se encontró la rifa." details = ( f"ℹ️ **Detalles de la rifa** ℹ️\n\n" f"**ID:** `{raffle['id']}`\n" f"**Nombre:** {raffle['name']}\n" f"**Descripción:**\n{raffle['description']}\n\n" f"**Activo:** {'Sí' if raffle['active'] else 'No (Terminado)'}\n" f"**Precio por número (canal principal):** {raffle['price']}€\n" ) # Image ID (optional display) if raffle['image_file_id']: details += f"**ID Imagen:** (Presente)\n" else: details += f"**ID Imagen:** (No asignada)\n" # Add participant count and remaining numbers participants = get_participants(raffle_id) # Fetches list of Rows completed_participants_count = 0 # pending_participants_count = 0 # If you want to show pending if participants: # Check if participants list is not None or empty completed_participants_count = sum(1 for p in participants if p['step'] == 'completed') # pending_participants_count = sum(1 for p in participants if p['step'] == 'waiting_for_payment') details += f"\n**Participantes Confirmados:** {completed_participants_count}\n" # details += f"**Reservas Pendientes:** {pending_participants_count}\n" remaining_count = get_remaining_numbers_amount(raffle_id) details += f"**Números Disponibles:** {remaining_count if remaining_count >= 0 else 'Error al calcular'}\n" return details def get_winners(raffle_id, winner_numbers_int): """Finds winners based on chosen numbers.""" participants = get_participants(raffle_id) # Gets all participants for the raffle winners = {} # { user_name: [list_of_winning_numbers_they_had] } if not participants: return "" # No participants, no winners winner_numbers_set = set(winner_numbers_int) for participant in participants: # Only consider completed participations as potential winners if participant['step'] != 'completed' or not participant['numbers']: continue user_id = participant['user_id'] user_name = escape_markdown_v2_chars_for_username(participant['user_name']) or f"User_{user_id}" # Fallback name numbers_str = participant['numbers'] try: participant_numbers_set = {int(n) for n in numbers_str.split(',') if n.isdigit()} except ValueError: logger.warning(f"Invalid number format for participant {user_id} in raffle {raffle_id}: {numbers_str}") continue # Skip participant with bad data # Find the intersection won_numbers = winner_numbers_set.intersection(participant_numbers_set) if won_numbers: # Store the winning numbers (as strings, sorted) for this user won_numbers_str_sorted = sorted([f"{n:02}" for n in won_numbers]) if user_name not in winners: winners[user_name] = [] winners[user_name].extend(won_numbers_str_sorted) # Add potentially multiple matches if not winners: return "No hubo ganadores con esos números." # Format the output string winners_message_parts = [] for user_name, numbers in winners.items(): # Ensure numbers are unique in the final output per user unique_numbers_str = ", ".join(sorted(list(set(numbers)))) winners_message_parts.append(f"- @{escape_markdown_v2_chars_for_username(user_name)} acertó: **{unique_numbers_str}**") return "\n".join(winners_message_parts) # def generate_table_image(raffle_id): # """Generates the 10x10 grid image showing number status.""" # # Define image parameters # cols, rows = 10, 10 # cell_width, cell_height = 120, 50 # title_height_space = 70 # image_width = cols * cell_width # image_height = rows * cell_height + title_height_space # background_color = "white" # line_color = "black" # font_size = 16 # title_font_size = 24 # # Create image # img = Image.new("RGB", (image_width, image_height), background_color) # draw = ImageDraw.Draw(img) # # Load fonts (handle potential errors) # try: # # Ensure the font file exists or provide a fallback path # font_path = "/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf" # Example Linux path # if not os.path.exists(font_path): # font_path = "arial.ttf" # Try common Windows font # font = ImageFont.truetype(font_path, font_size) # title_font = ImageFont.truetype(font_path, title_font_size) # except IOError: # logger.warning("Specific font not found, using default PIL font.") # font = ImageFont.load_default() # # Adjust size for default font if needed, default doesn't take size arg directly # # title_font = ImageFont.truetype(font_path, title_font_size) # Need a default large font method # title_font = ImageFont.load_default() # Revert to default for title too for simplicity # # Draw Title # raffle_details = get_raffle(raffle_id) # if not raffle_details: # logger.error(f"Cannot generate image: Raffle {raffle_id} not found.") # # Draw error message on image # draw.text((10, 10), f"Error: Rifa {raffle_id} no encontrado", fill="red", font=title_font) # img.save(f"/app/data/raffles/raffle_table_{raffle_id}_error.png") # return False # Indicate failure # raffle_name = raffle_details['name'] # title_text = f"Rifa: {raffle_name}" # # Calculate text bounding box for centering # try: # # Use textbbox for more accurate centering # title_bbox = draw.textbbox((0, 0), title_text, font=title_font) # title_width = title_bbox[2] - title_bbox[0] # # title_height = title_bbox[3] - title_bbox[1] # Not needed for x centering # title_x = (image_width - title_width) / 2 # title_y = 10 # Padding from top # draw.text((title_x, title_y), title_text, fill=line_color, font=title_font) # except AttributeError: # Handle older PIL versions that might not have textbbox # # Fallback using textlength (less accurate) # title_width = draw.textlength(title_text, font=title_font) # title_x = (image_width - title_width) / 2 # title_y = 10 # draw.text((title_x, title_y), title_text, fill=line_color, font=title_font) # # Get participant data # participants = get_participants(raffle_id) # number_status = {} # { num_int: (user_name, status_color) } # if participants: # for p in participants: # if not p['numbers'] or p['step'] not in ['waiting_for_payment', 'completed']: # continue # user_name = p['user_name'] or f"User_{p['user_id']}" # Fallback name # status_color = "red" if p['step'] == 'waiting_for_payment' else "black" # Red=Reserved, Black=Completed # try: # nums = {int(n) for n in p['numbers'].split(',') if n.isdigit()} # for num in nums: # if 0 <= num <= 99: # number_status[num] = (user_name, status_color) # except ValueError: # logger.warning(f"Skipping invalid numbers '{p['numbers']}' for user {p['user_id']} in image generation.") # continue # # Draw Grid and Fill Numbers # for i in range(rows): # for j in range(cols): # num = i * cols + j # x1 = j * cell_width # y1 = i * cell_height + title_height_space # x2 = x1 + cell_width # y2 = y1 + cell_height # # Draw cell rectangle # draw.rectangle([x1, y1, x2, y2], outline=line_color) # # Prepare text and color # number_text = f"{num:02}" # text_fill = "blue" # Default color for free numbers # owner_text = "" # if num in number_status: # owner, status_color = number_status[num] # text_fill = status_color # # Truncate long usernames # max_name_len = 12 # owner_text = owner[:max_name_len] + ('…' if len(owner) > max_name_len else '') # # Position text within the cell # text_x = x1 + 10 # Padding from left # text_y_num = y1 + 5 # Padding for number line # text_y_owner = y1 + 5 + font_size + 2 # Padding for owner line (below number) # draw.text((text_x, text_y_num), number_text, fill=text_fill, font=font) # if owner_text: # draw.text((text_x, text_y_owner), owner_text, fill=text_fill, font=font) # # Ensure data directory exists # os.makedirs("/app/data/raffles", exist_ok=True) # # Save the image # image_path = f"/app/data/raffles/raffle_table_{raffle_id}.png" # try: # img.save(image_path) # logger.info(f"Generated raffle table image: {image_path}") # return True # Indicate success # except Exception as e: # logger.error(f"Failed to save raffle table image {image_path}: {e}") # return False # Indicate failure def generate_table_image(raffle_id): """Generates a fancier 10x10 raffle grid image with participant names and legend.""" # Parameters cols, rows = 10, 10 cell_width, cell_height = 120, 60 title_height_space = 90 title_bottom_padding = 30 # extra space between title and grid legend_height_space = 80 margin_x = 40 # left/right margin image_width = cols * cell_width + margin_x * 2 image_height = rows * cell_height + title_height_space + title_bottom_padding + legend_height_space background_color = "#fdfdfd" grid_line_color = "#666666" free_bg_color = "#e8f0ff" reserved_bg_color = "#ffe8e8" taken_bg_color = "#e8ffe8" font_size = 16 title_font_size = 28 legend_font_size = 18 # Create base image img = Image.new("RGB", (image_width, image_height), background_color) draw = ImageDraw.Draw(img) # Load fonts try: font_path = "/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf" if not os.path.exists(font_path): font_path = "arial.ttf" font = ImageFont.truetype(font_path, font_size) title_font = ImageFont.truetype(font_path, title_font_size) legend_font = ImageFont.truetype(font_path, legend_font_size) except IOError: font = ImageFont.load_default() title_font = ImageFont.load_default() legend_font = ImageFont.load_default() # --- Title Bar --- raffle_details = get_raffle(raffle_id) if not raffle_details: draw.text((10, 10), f"Error: Rifa {raffle_id} no encontrada", fill="red", font=title_font) img.save(f"/app/data/raffles/raffle_table_{raffle_id}_error.png") return False raffle_name = raffle_details['name'] title_text = f"Rifa: {raffle_name}" # Draw title bar (full width) title_bar_color = "#4a90e2" draw.rectangle([0, 0, image_width, title_height_space], fill=title_bar_color) # Centered title text title_bbox = draw.textbbox((0, 0), title_text, font=title_font) title_width = title_bbox[2] - title_bbox[0] title_height = title_bbox[3] - title_bbox[1] title_x = (image_width - title_width) / 2 title_y = (title_height_space - title_height) / 2 draw.text((title_x, title_y), title_text, fill="white", font=title_font) # --- Participants --- participants = get_participants(raffle_id) number_status = {} if participants: for p in participants: if not p['numbers'] or p['step'] not in ['waiting_for_payment', 'completed']: continue user_name = p['user_name'] or f"User_{p['user_id']}" status = p['step'] nums = {int(n) for n in p['numbers'].split(',') if n.isdigit()} for num in nums: if 0 <= num <= 99: number_status[num] = (user_name, status) # --- Grid --- grid_top = title_height_space + title_bottom_padding for i in range(rows): for j in range(cols): num = i * cols + j x1 = margin_x + j * cell_width y1 = grid_top + i * cell_height x2 = x1 + cell_width y2 = y1 + cell_height # Background color if num in number_status: owner, status = number_status[num] bg_color = reserved_bg_color if status == "waiting_for_payment" else taken_bg_color text_color = "#000000" else: owner, bg_color, text_color = "", free_bg_color, "#1a4db3" # Rounded rectangle cell radius = 12 draw.rounded_rectangle([x1+1, y1+1, x2-1, y2-1], radius, outline=grid_line_color, fill=bg_color) # Draw number number_text = f"{num:02}" draw.text((x1+10, y1+8), number_text, fill=text_color, font=font) # Draw owner if owner: max_name_len = 12 owner_text = owner[:max_name_len] + ('…' if len(owner) > max_name_len else '') draw.text((x1+10, y1+8+font_size+4), owner_text, fill=text_color, font=font) # --- Legend --- legend_y = image_height - legend_height_space + 20 legend_items = [ ("Libre", free_bg_color), ("Reservado", reserved_bg_color), ("Pagado", taken_bg_color) ] spacing = 280 # more spacing between legend items start_x = (image_width - (spacing * (len(legend_items)-1) + 140)) / 2 for i, (label, color) in enumerate(legend_items): box_x = start_x + i * spacing box_y = legend_y box_w, box_h = 34, 34 # Color box draw.rounded_rectangle([box_x, box_y, box_x+box_w, box_y+box_h], 6, fill=color, outline=grid_line_color) # Label text draw.text((box_x + box_w + 14, box_y + 6), label, fill="black", font=legend_font) # Save os.makedirs("/app/data/raffles", exist_ok=True) image_path = f"/app/data/raffles/raffle_table_{raffle_id}.png" img.save(image_path) return True def escape_markdown_v2_chars_for_username(text: str) -> str: """Escapes characters for MarkdownV2, specifically for usernames.""" # For usernames, usually only _ and * are problematic if not part of actual formatting # Other MarkdownV2 special characters: `[` `]` `(` `)` `~` `>` `#` `+` `-` `=` `|` `{` `}` `.` `!` # We are most concerned with _ in @user_name context. # A more comprehensive list of characters to escape for general text: # escape_chars = r'_*[]()~`>#+-=|{}.!' # For just usernames in this context, focus on what breaks @user_name escape_chars = r'_*`[' # Adding ` and [ just in case they appear in odd usernames # Python's re.escape escapes all non-alphanumerics. # We only want to escape specific markdown control characters within the username. # For usernames, simply escaping '_' is often enough for the @mention issue. return "".join(['\\' + char if char in escape_chars else char for char in text]) def format_last_participants_list(participants_list: list) -> str: """ Formats the list of last participants for the announcement message. participants_list is a list of dicts: [{'user_name', 'numbers'}] """ if not participants_list: return "" # Return empty string if no other recent participants # Reverse the list so the oldest of the "last N" appears first in the formatted string # as per the example "nick1, nick2, nick3" implies chronological order of joining. # The DB query already returns newest first, so we reverse it for display. formatted_lines = ["Los últimos participantes en unirse (además del más reciente) han sido:"] for p_info in reversed(participants_list): # Display oldest of this batch first user_name = p_info.get('user_name', 'Usuario Anónimo') numbers_str = p_info.get('numbers', '') if numbers_str: num_list = numbers_str.split(',') if len(num_list) == 1: line = f" - {escape_markdown_v2_chars_for_username(user_name)}, con la papeleta: {num_list[0]}" else: line = f" - {escape_markdown_v2_chars_for_username(user_name)}, con las papeletas: {', '.join(num_list)}" formatted_lines.append(line) return "\n".join(formatted_lines) # Add a trailing newline def get_paypal_access_token(): old_token = get_paypal_access_token_db() if old_token: logger.info(f"Using cached PayPal access token") return old_token logger.info("Fetching new PayPal access token") url = "https://api-m.sandbox.paypal.com/v1/oauth2/token" headers = {"Accept": "application/json", "Accept-Language": "en_US"} data = {"grant_type": "client_credentials"} response = requests.post(url, headers=headers, data=data, auth=HTTPBasicAuth(PAYPAL_CLIENT_ID, PAYPAL_SECRET)) response.raise_for_status() store_paypal_access_token(response.json()["access_token"], response.json()["expires_in"]) return response.json()["access_token"] def create_paypal_order(access_token, value): url = "https://api-m.sandbox.paypal.com/v2/checkout/orders" headers = { "Content-Type": "application/json", "Authorization": f"Bearer {access_token}" } payload = { "intent": "CAPTURE", "purchase_units": [ { "amount": {"currency_code": "EUR", "value": f"{value:.2f}"} } ], "application_context": { "return_url": f"https://t.me/{BOT_NAME}", "cancel_url": f"https://t.me/{BOT_NAME}" } } response = requests.post(url, headers=headers, json=payload) response.raise_for_status() order = response.json() # Extract the approval link approval_url = next(link["href"] for link in order["links"] if link["rel"] == "approve") return approval_url, order["id"]