Removed prem keys from bot

bot/db_handler/db_service.py

@@ -87,26 +87,6 @@ async def reset_daily_keys_if_needed(session: AsyncSession, user_id: int):
         await session.commit()
 
 
-# Resets daily safety keys if needed
-async def reset_daily_safety_keys_if_needed(session: AsyncSession, user_id: int):
-    current_date = datetime.now(timezone.utc).date()
-
-    result = await session.execute(
-        select(User).filter(User.user_id == user_id)
-    )
-    user = result.scalar_one_or_none()
-    if user and user.last_reset_date_safety_keys != current_date:
-        await session.execute(
-            update(User)
-            .where(User.user_id == user_id)
-            .values(
-                daily_safety_keys_requests_count=0,
-                last_reset_date_safety_keys=current_date,
-            )
-        )
-        await session.commit()
-
-
 # Logs user action
 async def log_user_action(session: AsyncSession, user_id: int, action: str):
     new_log = UserLog(user_id=user_id, action=action)
@@ -141,16 +121,6 @@ async def get_keys(session: AsyncSession, game_name: str, limit: int = 4):
         return []
 
 
-# Getting safety keys with new tables for the game
-async def get_safety_keys(session: AsyncSession, game_name: str, limit: int = 4):
-    table_name = f"safety.{game_name.replace(' ', '_').lower()}"
-    if table_name == "safety.fluff_crusade":
-        limit = 8
-    query = text(f"SELECT promo_code FROM {table_name} ORDER BY created_at ASC LIMIT :limit")
-    result = await session.execute(query, {'limit': limit})
-    return result.fetchall()
-
-
 # Deleting used keys
 async def delete_keys(session: AsyncSession, game_name: str, keys: list):
     """Deleting keys from the database and cache"""
@@ -167,14 +137,6 @@ async def delete_keys(session: AsyncSession, game_name: str, keys: list):
     logger.info(f"Deleted {len(keys)} keys from both cache and database for game: {game_name}")
 
 
-# Deleting used safety keys
-async def delete_safety_keys(session: AsyncSession, game_name: str, keys: list):
-    table_name = f"safety.{game_name.replace(' ', '_').lower()}"
-    query = text(f"DELETE FROM {table_name} WHERE promo_code = ANY(:keys)")
-    await session.execute(query, {'keys': keys})
-    await session.commit()
-
-
 # Update key count and time of the last request
 async def update_keys_generated(session: AsyncSession, user_id: int, keys_generated: int):
     # Get the current time in UTC with timezone info
@@ -193,23 +155,6 @@ async def update_keys_generated(session: AsyncSession, user_id: int, keys_genera
     await session.commit()
 
 
-# Update safety key count and time of the last request
-async def update_safety_keys_generated(session: AsyncSession, user_id: int, keys_generated: int):
-    current_time = datetime.now(timezone.utc)
-
-    await session.execute(
-        update(User)
-        .where(User.user_id == user_id)
-        .values(
-            total_safety_keys_generated=User.total_safety_keys_generated + keys_generated,
-            daily_safety_keys_requests_count=User.daily_safety_keys_requests_count + 1,
-            last_safety_keys_request_time=current_time,
-            last_reset_date_safety_keys=current_time.date()
-        )
-    )
-    await session.commit()
-
-
 # Check user limits
 async def check_user_limits(session: AsyncSession, user_id: int, status_limits: dict) -> bool:
     result = await session.execute(
@@ -235,43 +180,15 @@ async def check_user_limits(session: AsyncSession, user_id: int, status_limits:
     return True
 
 
-# Check user safety limits
-async def check_user_safety_limits(session: AsyncSession, user_id: int, status_limits: dict) -> bool:
-    result = await session.execute(
-        select(User.user_status, User.daily_safety_keys_requests_count, User.last_reset_date_safety_keys)
-        .filter(User.user_id == user_id)
-    )
-    user = result.one_or_none()
-
-    if user:
-        current_date = datetime.now(timezone.utc).date()
-
-        # Check if the counter needs to be reset
-        if user.last_reset_date_safety_keys != current_date:
-            await reset_daily_safety_keys_if_needed(session, user_id)
-            daily_safety_keys_requests_count = 0
-        else:
-            daily_safety_keys_requests_count = user.daily_safety_keys_requests_count
-
-        # Checking limits
-        limit = status_limits.get(user.user_status, {}).get('safety_daily_limit', 0)
-        if daily_safety_keys_requests_count >= limit:
-            return False  # Limit has been reached
-    return True
-
-
 # Check for ban, status, user limits
 async def get_user_status_info(session: AsyncSession, user_id: int):
     result = await session.execute(
         select(
             User.is_banned,
             User.last_request_time,
-            User.last_safety_keys_request_time,
             User.user_status,
             User.daily_requests_count,
-            User.daily_safety_keys_requests_count,
             User.last_reset_date,
-            User.last_reset_date_safety_keys
         ).filter(User.user_id == user_id)
     )
     return result.one_or_none()
@@ -309,24 +226,15 @@ async def get_admin_chat_ids():
 # Get count games keys in DB
 async def get_keys_count_for_games(session: AsyncSession, games: list) -> list:
     regular_results = ["<i>Quantity</i>....<b>Game</b>\n"]
-    safety_results = ["\n<i>Quantity</i>....<b>Game (safety)</b>\n"]
 
     for game in games:
         table_name = game.replace(" ", "_").lower()
         query = text(f"SELECT COUNT(*) FROM {table_name}")
         result = await session.execute(query)
         keys_count = result.scalar()
         regular_results.append(f"<i>{keys_count}</i>......<b>{game}</b>")
-        safety_table_name = f"safety.{table_name}"
-        safety_query = text(f"SELECT COUNT(*) FROM {safety_table_name}")
-        try:
-            safety_result = await session.execute(safety_query)
-            safety_keys_count = safety_result.scalar()
-            safety_results.append(f"<i>{safety_keys_count}</i>......<b>{game} (safety)</b>")
-        except Exception as e:
-            safety_results.append(f"<i>Table not found</i>......<b>{game} (safety). Error: {e}</b>")
 
-    return "\n".join(regular_results + safety_results)
+    return "\n".join(regular_results)
 
 
 # Get users list for admin panel
@@ -339,15 +247,12 @@ async def get_users_list_admin_panel(session: AsyncSession, games: list):
     users_count = user_count_result.scalar()
 
     keys_today = await get_daily_requests_count(session)
-    premium_keys_today = await get_daily_safety_requests_count(session)
 
     keys_today_total = keys_today * len(games) * 4
-    premium_keys_today_total = premium_keys_today * len(games) * 4
 
     user_list = [
         f"<i>Всего пользователей:  <b>{users_count}</b>\n(нажми ID что бы скопировать)</i>\n",
         f"<i>Сегодня забрали ключей:  <b>{keys_today_total}</b></i>\n",
-        f"<i>Сегодня забрали прем ключей:  <b>{premium_keys_today_total}</b></i>\n",
     ]
 
     return "\n".join(user_list)
@@ -402,14 +307,11 @@ async def get_subscribed_users(session):
 # Get users list for admin panel
 async def get_keys_count_main_menu(session: AsyncSession, games: list):
     keys_today = await get_daily_requests_count(session)
-    premium_keys_today = await get_daily_safety_requests_count(session)
     POPULARITY_COEFFICIENT = int(os.getenv('POPULARITY_COEFFICIENT', 1))
 
     keys_today_total = keys_today * len(games) * 4 * POPULARITY_COEFFICIENT
-    premium_keys_today_total = premium_keys_today * len(games) * 4 * POPULARITY_COEFFICIENT
     keys_dict = {
         'keys_today': keys_today_total,
-        'premium_keys_today': premium_keys_today_total
     }
     return keys_dict
 
@@ -424,38 +326,23 @@ async def get_daily_requests_count(session: AsyncSession) -> int:
     return result.scalar() or 0
 
 
-# Get daily requests count for safety (premium) keys
-async def get_daily_safety_requests_count(session: AsyncSession) -> int:
-    today = datetime.utcnow().date()
-    result = await session.execute(
-        select(func.sum(func.coalesce(User.daily_safety_keys_requests_count, 0)))
-        .where(User.last_reset_date_safety_keys == today)
-    )
-    return result.scalar() or 0
-
-
 # Get user stats for statistic function
 async def get_user_stats(session: AsyncSession, user_id: int, games: list) -> dict:
     result = await session.execute(
         select(
             User.registration_date,
             User.user_status,
             User.daily_requests_count,
-            User.daily_safety_keys_requests_count,
             User.total_keys_generated,
-            User.total_safety_keys_generated,
         ).filter(User.user_id == user_id)
     )
     user_data = result.fetchone()
     if not user_data:
         raise KeyError(f"User with ID {user_id} not found or missing data.")
     keys_today = user_data[2] * (len(games) * 4 + 4)
-    premium_keys_today = (user_data[3] or 0) * (len(games) * 4 + 4)
     return {
         "registration_date": user_data[0],
         "user_status": user_data[1],
         "keys_today": keys_today,
-        "premium_keys_today": premium_keys_today,
-        "total_keys_generated": user_data[4],
-        "total_safety_keys_generated": user_data[5],
+        "total_keys_generated": user_data[3],
     }