fix messages, save tonPerStar rate

app/core/background/convert_service.py

@@ -7,14 +7,17 @@ import shutil
 from base58 import b58decode, b58encode
 from sqlalchemy import and_, or_
 from app.core.models.node_storage import StoredContent
+from app.core.models._telegram import Wrapped_CBotChat
 from app.core._utils.send_status import send_status
 from app.core.logger import make_log
+from app.core.models.user import User
+from app.core.models import WalletConnection
 from app.core.storage import db_session
 from app.core._config import UPLOADS_DIR
 from app.core.content.content_id import ContentId
 
 
-async def convert_loop():
+async def convert_loop(memory):
     with db_session() as session:
         # Query for unprocessed encrypted content
         unprocessed_encrypted_content = session.query(StoredContent).filter(
@@ -193,8 +196,15 @@ async def convert_loop():
             **unprocessed_encrypted_content.meta,
             'converted_content': converted_content
         }
-        session.commit()
 
+        session.commit()
+        if not unprocessed_encrypted_content.meta.get('upload_notify_msg_id'):
+            wallet_owner_connection = session.query(WalletConnection).order_by(WalletConnection.id.desc()).first()
+            if wallet_owner_connection:
+                wallet_owner_user = wallet_owner_connection.user
+                wallet_owner_bot = Wrapped_CBotChat(memory._client_telegram_bot, chat_id=wallet_owner_user.telegram_id, user=wallet_owner_user, db_session=session)
+                unprocessed_encrypted_content.meta['upload_notify_msg_id'] = await wallet_owner_bot.send_content(session, unprocessed_encrypted_content)
+                session.commit()
 
 async def main_fn(memory):
     make_log("ConvertProcess", "Service started", level="info")
@@ -202,7 +212,7 @@ async def main_fn(memory):
     while True:
         try:
             make_log("ConvertProcess", "Service running", level="debug")
-            await convert_loop()
+            await convert_loop(memory)
             await asyncio.sleep(5)
             await send_status("convert_service", f"working (seqno={seqno})")
             seqno += 1

app/core/background/indexer_service.py

@@ -11,7 +11,7 @@ from app.core._blockchain.ton.platform import platform
 from app.core._blockchain.ton.toncenter import toncenter
 from app.core._utils.send_status import send_status
 from app.core.logger import make_log
-from app.core.models import UserContent, KnownTelegramMessage
+from app.core.models import UserContent, KnownTelegramMessage, ServiceConfig
 from app.core.models.node_storage import StoredContent
 from app.core._utils.resolve_content import resolve_content
 from app.core.models.wallet_connection import WalletConnection
@@ -34,6 +34,18 @@ async def indexer_loop(memory, platform_found: bool, seqno: int) -> [bool, int]:
 
     make_log("Indexer", "Service running", level="debug")
     with db_session() as session:
+        try:
+            result = await toncenter.run_get_method('EQD8TJ8xEWB1SpnRE4d89YO3jl0W0EiBnNS4IBaHaUmdfizE', 'get_pool_data')
+            assert result['exit_code'] == 0, f"Error in get-method: {result}"
+            assert result['stack'][0][0] == 'num', f"get first element is not num"
+            assert result['stack'][1][0] == 'num', f"get second element is not num"
+            usdt_per_ton = (int(result['stack'][0][1], 16) * 1e3) / int(result['stack'][1][1], 16)
+            ton_per_star = 0.014 / usdt_per_ton
+            await ServiceConfig(session).set('live_tonPerStar', [ton_per_star, datetime.utcnow().timestamp()])
+            make_log("TON_Daemon", f"TON per STAR price: {ton_per_star}", level="DEBUG")
+        except BaseException as e:
+            make_log("TON_Daemon", f"Error while saving TON per STAR price: {e}" + '\n' + traceback.format_exc(), level="ERROR")
+
         new_licenses = session.query(UserContent).filter(
             and_(
                 ~UserContent.meta.contains({'notification_sent': True}),
@@ -50,30 +62,31 @@ async def indexer_loop(memory, platform_found: bool, seqno: int) -> [bool, int]:
             content_metadata = licensed_content.metadata_json(session)
             assert content_metadata, "No content metadata found"
 
-            try:
-                user = new_license.user
-                if user.telegram_id and licensed_content:
-                    await (Wrapped_CBotChat(memory._client_telegram_bot, chat_id=user.telegram_id, user=user, db_session=session)).send_content(
-                        session, licensed_content
-                    )
+            if not (licensed_content.owner_address == new_license.owner_address):
+                try:
+                    user = new_license.user
+                    if user.telegram_id and licensed_content:
+                        await (Wrapped_CBotChat(memory._client_telegram_bot, chat_id=user.telegram_id, user=user, db_session=session)).send_content(
+                            session, licensed_content
+                        )
 
-                wallet_owner_connection = session.query(WalletConnection).filter_by(
-                    wallet_address=licensed_content.owner_address,
-                    invalidated=False
-                ).order_by(desc(WalletConnection.id)).first()
-                wallet_owner_user = wallet_owner_connection.user
-                if wallet_owner_user.telegram_id:
-                    wallet_owner_bot = Wrapped_CBotChat(memory._client_telegram_bot, chat_id=wallet_owner_user.telegram_id, user=wallet_owner_user, db_session=session)
-                    await wallet_owner_bot.send_message(
-                        user.translated('p_licenseWasBought').format(
-                            username=user.front_format(),
-                            nft_address=f'"https://tonviewer.com/{new_license.onchain_address}"',
-                            content_title=content_metadata.get('name', 'Unknown'),
-                        ),
-                        message_type='notification',
-                    )
-            except BaseException as e:
-                make_log("IndexerSendNewLicense", f"Error: {e}" + '\n' + traceback.format_exc(), level="error")
+                    wallet_owner_connection = session.query(WalletConnection).filter_by(
+                        wallet_address=licensed_content.owner_address,
+                        invalidated=False
+                    ).order_by(desc(WalletConnection.id)).first()
+                    wallet_owner_user = wallet_owner_connection.user
+                    if wallet_owner_user.telegram_id:
+                        wallet_owner_bot = Wrapped_CBotChat(memory._client_telegram_bot, chat_id=wallet_owner_user.telegram_id, user=wallet_owner_user, db_session=session)
+                        await wallet_owner_bot.send_message(
+                            user.translated('p_licenseWasBought').format(
+                                username=user.front_format(),
+                                nft_address=f'"https://tonviewer.com/{new_license.onchain_address}"',
+                                content_title=content_metadata.get('name', 'Unknown'),
+                            ),
+                            message_type='notification',
+                        )
+                except BaseException as e:
+                    make_log("IndexerSendNewLicense", f"Error: {e}" + '\n' + traceback.format_exc(), level="error")
 
             new_license.meta = {**new_license.meta, 'notification_sent': True}
             session.commit()
@@ -199,7 +212,8 @@ async def indexer_loop(memory, platform_found: bool, seqno: int) -> [bool, int]:
                         encrypted_stored_content.user_id = user_wallet_connection.user_id
                         user = user_wallet_connection.user
 
-                    await (Wrapped_CBotChat(memory._telegram_bot, chat_id=user.telegram_id)).send_message(
+                    user_uploader_wrapper = Wrapped_CBotChat(memory._telegram_bot, chat_id=user.telegram_id, user=user, db_session=session)
+                    await user_uploader_wrapper.send_message(
                         user.translated('p_contentWasIndexed').format(
                             item_address=item_address.to_string(1, 1, 1),
                             item_index=item_index,
@@ -213,7 +227,6 @@ async def indexer_loop(memory, platform_found: bool, seqno: int) -> [bool, int]:
                         ])
                     )
 
-                    user_uploader_wrapper = Wrapped_CBotChat(memory._telegram_bot, chat_id=user.telegram_id, user=user, db_session=session)
                     for hint_message in session.query(KnownTelegramMessage).filter(
                         and_(
                             KnownTelegramMessage.chat_id == user.telegram_id,
@@ -222,6 +235,8 @@ async def indexer_loop(memory, platform_found: bool, seqno: int) -> [bool, int]:
                         )
                     ):
                         await user_uploader_wrapper.delete_message(hint_message.message_id)
+
+                    user.client
                 elif encrypted_stored_content.type.startswith('onchain') and encrypted_stored_content.onchain_index == item_index:
                     encrypted_stored_content.type = "onchain/content" + ("_unknown" if (encrypted_stored_content.key_id is None) else "")
                     encrypted_stored_content.owner_address = item_owner_address.to_string(1, 1, 1)