Telegram Bot Integration

import { 
  checkChannelMembership, 
  createAndSendInvite,
  processPeriodicMembershipChecks
} from './server/telegramChannelService';

// Check if user is in channel
const isMember = await checkChannelMembership(userId, telegramId);

if (!isMember) {
  // Send invite link
  const result = await createAndSendInvite(telegramId);
  // User receives message with "Join Channel" button
}

// Periodic checks (run via cron)
const stats = await processPeriodicMembershipChecks();
// { checked: 50, invited: 10, errors: 0 }

import { updateBotMessage, getBotMessage } from './server/telegramMessageService';

// Update payment success message
await updateBotMessage(
  'payment_success',
  '✅ Payment complete!\n\n{credits} credits have been added to your account.',
  adminUserId,
  'HTML'  // parse_mode
);

// Get message with placeholders filled
const message = await getBotMessage('payment_success', {
  credits: '100'
});
console.log(message.content);
// "✅ Payment complete!\n\n100 credits have been added to your account."

// Message functions
function sendMessage(
  chatId: string | number,
  text: string,
  options?: { parse_mode?: 'HTML' | 'Markdown'; reply_markup?: object }
): Promise<void>

function sendPhoto(
  chatId: string | number,
  photo: string,  // URL or file_id
  caption?: string,
  options?: object
): Promise<void>

// Payment functions
function sendInvoice(
  chatId: string | number,
  session: PaymentSession,
  pkg: CreditPackage
): Promise<void>

function answerPreCheckoutQuery(
  queryId: string,
  ok: boolean,
  errorMessage?: string
): Promise<void>

function createInvoiceLink(
  sessionId: string,
  pkg: CreditPackage
): Promise<string>  // Returns direct payment link

function refundStarPayment(
  userId: string | number,
  telegramPaymentChargeId: string
): Promise<void>

// Webhook functions
function setWebhook(webhookUrl: string): Promise<void>
function getWebhookInfo(): Promise<object>
function deleteWebhook(): Promise<void>
function verifyWebhookSecret(headerSecret: string): boolean

// Bot info
function getMe(): Promise<{ id: number; username: string; ... }>
function setMyCommands(commands: TelegramBotCommand[]): Promise<void>
function getMyCommands(): Promise<TelegramBotCommand[]>

// Channel functions
function getChat(chatId: string | number): Promise<object>
function getChatMember(
  chatId: string | number,
  userId: number
): Promise<{ status: string }>
function createChatInviteLink(
  chatId: string | number,
  options?: { member_limit?: number; expire_date?: number }
): Promise<{ invite_link: string }>

interface TelegramUpdate {
  update_id: number;
  message?: TelegramMessage;
  pre_checkout_query?: TelegramPreCheckoutQuery;
  chat_member?: TelegramChatMemberUpdate;
}

interface TelegramMessage {
  message_id: number;
  from?: TelegramUser;
  chat: { id: number; type: string };
  text?: string;
  successful_payment?: {
    currency: string;  // "XTR" for Stars
    total_amount: number;
    invoice_payload: string;  // Your session ID
    telegram_payment_charge_id: string;
  };
  refunded_payment?: {
    currency: string;
    total_amount: number;
    telegram_payment_charge_id: string;
  };
}

interface TelegramPreCheckoutQuery {
  id: string;
  from: TelegramUser;
  currency: string;
  total_amount: number;
  invoice_payload: string;  // Your session ID
}

import { sendMessage } from './server/telegramBot';

await sendMessage(
  chatId,
  'Choose a credit package:',
  {
    parse_mode: 'HTML',
    reply_markup: {
      inline_keyboard: [
        [
          { text: '100 Credits - 10 Stars', callback_data: 'buy_100' },
          { text: '500 Credits - 45 Stars', callback_data: 'buy_500' }
        ],
        [
          { text: 'Visit Website', url: 'https://app.joip.io' }
        ]
      ]
    }
  }
);

import { refundStarPayment } from './server/telegramBot';
import { creditService } from './server/creditService';

// Refund Telegram Stars payment
await refundStarPayment(
  telegramUserId,
  telegramPaymentChargeId
);

// Deduct credits from user account
await creditService.deductCredits(
  userId,
  amount,
  `Refund for ${sessionId}`
);

// Notify user
await sendMessage(
  chatId,
  '⚠️ Your purchase has been refunded. Credits removed from your account.'
);

import { bulkInviteUsers } from './server/telegramChannelService';

// Invite all patrons to channel
const patronIds = await db
  .select({ id: users.id })
  .from(users)
  .where(eq(users.isActivePatron, true));

const result = await bulkInviteUsers(
  patronIds.map(u => u.id),
  adminUserId
);

console.log(`Invited ${result.success.length} users`);
console.log(`Failed: ${result.failed.length}`);

app.post('/api/telegram/webhook', (req, res) => {
  console.log('Telegram webhook:', JSON.stringify(req.body, null, 2));
  // Process update...
});

import { deleteWebhook } from './server/telegramBot';

// Remove webhook
await deleteWebhook();

// Use getUpdates in loop (not shown - use library like 'node-telegram-bot-api')