const { setDB } = require('../core/firebase');
setDB(`subscribers/${user.id}`, true);
sendMessage('Welcome to the Bakery Alerts VIP club! 🥐 You will get notified the moment hot pastries are ready.');

const { getDB } = require('../core/firebase');
if (user.id !== parseInt(process.env.ADMIN_ID)) return sendMessage('Unauthorized access.');
const subs = await getDB('subscribers') || {};
const ids = Object.keys(subs);
const res = await broadcast(ids, '🥐 *Warm pastries ready right now!* Get 30% off for the next 45 minutes.', [{ text: 'Get Code', command: '/claim' }], 100);
sendMessage(`Broadcast complete! Sent: ${res.sent}, Failed: ${res.failed}`);

sendMessage('Show this code at the register to claim your 30% discount:\n\n*BAKERYVIP30*');

⚠️ Note: You must add your Telegram user ID as the ADMIN_ID environment variable so only authorized staff can trigger the alerts.

Comment Down 👇

const prompt = "<b>Issue Reporter</b>\n\nPlease send a headline for the bug:";
sendMessage(prompt);
waitForAnswer("get_desc");

TEMP.setProp("bug_title", message);
sendMessage("Got it. Now reply with full details or steps to reproduce:");
waitForAnswer("finish_report");

const title = await TEMP.getProp("bug_title").value();
pushDB("bugs", { userId: user.id, title, desc: message });
TEMP.deleteProp("bug_title");
clearWait();
sendMessage("<b>Report logged!</b> Our team will review it shortly.");

sendChatAction("typing");
let current = await BOT.getProp("build_status").value() || "Ready";
sendMessage(`*Staging Control Panel*\nCurrent Status: *${current}*`, {
  buttons: [
    [{ text: "🚀 Deploy Staging", command: "/run_deploy" }],
    [{ text: "🔄 Check Status", command: "/staging" }]
  ]
});

if (isCallback) {
  await answerCallback("Initiating deploy sequence...", true);
  await BOT.setProp("build_status", "Deploying...");
  let res = await HTTP.post({
    url: "https://api.github.com/repos/acme/app/dispatches",
    body: { event_type: "deploy" }
  });
  let result = res ? "Deployed" : "Failed";
  await BOT.setProp("build_status", result);
  editCallbackMessage(`*Staging Control Panel*\nCurrent Status: *${result}*`, [
    [{ text: "🔄 Refresh Status", command: "/staging" }]
  ], message_id);
}

⚠️ Note: Replace the target URL in HTTP.post with your CI/CD pipeline or GitHub action dispatch webhook.

if (!params[0]) return sendMessage("Usage: /setbase USD");
let code = params[0].toUpperCase();
USER.setProperty("base", code);
sendMessage(`Base currency updated to *${code}*`);

let base = await USER.getProp("base").value();
let current = base || "USD";
sendMessage(`Your active currency preference is set to *${current}*`);

let amount = parseFloat(params[0]) || 100;
let target = (params[1] || "EUR").toUpperCase();
let base = (await USER.getProp("base").value()) || "USD";
sendChatAction("typing");
let data = await HTTP.get({ url: `https://open.er-api.com/v6/latest/${base}` });
let rate = data?.rates?.[target];
if (!rate) return sendMessage("Conversion failed. Check currency codes.");
let converted = (amount * rate).toFixed(2);
sendMessage(`*${amount} ${base}* = *${converted} ${target}*`);

const rsvp = await USER.getProp('rsvp').value();
if (rsvp) return sendMessage('You already reserved a spot for this meetup!');
const count = await BOT.getProp('rsvps').value() || 0;
if (count >= 30) return sendMessage('Sorry, this meetup is completely full!');
await USER.setProp('rsvp', true);
await BOT.getProp('rsvps').add(1);
sendMessage(`*RSVP Confirmed!* You bagged spot #${count + 1} of 30.`);

const rsvp = await USER.getProp('rsvp').value();
if (!rsvp) return sendMessage('You do not have an active spot reserved.');
await USER.deleteProp('rsvp');
await BOT.getProp('rsvps').add(-1);
sendMessage('Your reservation was canceled and the spot is back open.');

const count = await BOT.getProp('rsvps').value() || 0;
const left = Math.max(0, 30 - count);
sendMessage(`*Meetup Capacity Status*\n\nBooked spots: ${count}/30\nRemaining spots: ${left}`);

⚠️ Note: Ensure FIREBASE_URL and FIREBASE_SECRET are configured in your environment variables so persistent state works seamlessly.

if (!params) return sendMessage("Usage: /addsnippet Title | Code");
const [title, code] = params.split("|").map(s => s.trim());
if (!title || !code) return sendMessage("Provide both title and code split by |");
const list = (await BOT.getProp("snippets").value()) || [];
list.push({ title, code });
await BOT.setProperty("snippets", list);
sendMessage(`*Snippet saved!* Type \`@yourbot ${title}\` in any chat to use it.`);

const query = inlineQuery.toLowerCase();
const list = (await BOT.getProp("snippets").value()) || [];
const matches = list.filter(item => item.title.toLowerCase().includes(query));
const results = matches.map((item, id) => ({
  type: "article",
  id: String(id),
  title: item.title,
  input_message_content: { message_text: `\`\`\`\n${item.code}\n\`\`\``, parse_mode: "Markdown" }
}));
answerInlineQuery(results);

⚠️ Note: Subscribe Backup Channel: https://youtube.com/@flecdev

🔔 Leave Notify Telegram Bot Code

import { getDB, deleteDB } from "./firebase.js";

export const commandName = "__message__";

export default async function (flex) {
  const body = flex.request.body;
  const leftMember = body.message && body.message.left_chat_member;
  const chatMemberUpdate = body.chat_member;

  const farewellText = `👋 <b>Sorry to see you leave!</b>

<b>You’ve stepped away from our community, but you’re always welcome back.</b>

✨ Whether it was by accident, you needed some time away, or simply wanted a change, our doors remain open for you.

📢 Don’t miss future updates, exclusive offers, and valuable content shared with our members.

👇 Whenever you're ready, tap the button below and rejoin the community. We'd be happy to have you back!`;

  const button = [{ text: "🔗 Join Again", url: "https://t.me/Flex_Coder" }];

  if (leftMember) {
    await API.sendMessage({
      chat_id: leftMember.id,
      text: farewellText,
      parse_mode: "HTML",
      reply_markup: {
        inline_keyboard: [button],
      },
    });
    return;
  }

  if (chatMemberUpdate) {
    const newStatus =
      chatMemberUpdate.new_chat_member &&
      chatMemberUpdate.new_chat_member.status;
    const oldStatus =
      chatMemberUpdate.old_chat_member &&
      chatMemberUpdate.old_chat_member.status;
    const leftNow =
      (newStatus === "left" || newStatus === "kicked") &&
      oldStatus !== "left" &&
      oldStatus !== "kicked";
    if (leftNow) {
      const u = chatMemberUpdate.old_chat_member.user;
      await API.sendMessage({
        chat_id: u.id,
        text: farewellText,
        parse_mode: "HTML",
        reply_markup: {
          inline_keyboard: button,
        },
      });
      return;
    }
  }

  const userId = flex.user.id;

  let pending = null;
  try {
    pending = await getDB(`wait_for_answer/${userId}`);
  } catch {}

  if (pending?.command) {
    if (Date.now() > pending.expires_at) {
      await deleteDB(`wait_for_answer/${userId}`).catch(() => {});
      await sendMessage("⏰ Session timed out. Please start again.");
      return;
    }
    await deleteDB(`wait_for_answer/${userId}`).catch(() => {});
    await runCommand(pending.command, flex.message);
    return;
  }
}

🎥 Tutorial Video: https://youtu.be/sf-v0scqi9U

Do some like & comment on video 😊

sendReplyKeyboard("Select a dev service package to kick off your quote:", [
  [{ text: "🛠️ Web App" }, { text: "📱 Mobile App" }],
  [{ text: "🤖 Telegram Bot" }]
])

removeKeyboard(`Got it! Package selected: *${message}*`)
sendMessage("Would you like to attach high-priority SLA support to this project?", {
  buttons: [
    { text: "⚡ Add Express SLA", command: "/priority_on" }
  ]
})

if (isCallback) {
  answerCallback("Express SLA appended!", true)
  editButton(message_id, [
    { text: "✅ Express SLA Active", command: "/priority_off" }
  ])
}

if (isCallback) {
  answerCallback("Express SLA removed")
  editButton(message_id, [
    { text: "⚡ Add Express SLA", command: "/priority_on" }
  ])
}

sendChatAction('typing')
const response = await HTTP.get({ url: 'https://api.github.com/zen' })
if (response) {
  BOT.setProp('last_check', Date.now())
  sendMessage('*System Status:* All systems operational 🟢')
} else {
  BOT.setProp('last_status', 'DOWN')
  sendMessage('*System Status:* Service disruption detected 🔴')
}

if (String(user.telegramid) !== process.env.ADMIN_ID) {
  return sendMessage('Unauthorized command.')
}
const allUsers = await getDB('users')
const userIds = allUsers ? Object.keys(allUsers) : []
const report = await broadcast(userIds, `🚨 *Incident Update:* ${params || 'Maintenance in progress.'}`, [], 50)
sendMessage(`Alert dispatched: ${report.sent} delivered, ${report.failed} failed.`)

sendMessage('Unrecognized command. Use /check to test system health.')

⚠️ Note: Requires the ADMIN_ID environment variable set in your deployment environment to restrict alert privileges.

const active = await USER.getProp('vip_status').value();
if (active) {
  sendMessage('✨ You already have an active VIP membership!');
  return;
}
waitForAnswer('verify_key');
sendMessage('🔑 Please enter your VIP license key to activate access:');

const res = await HTTP.post({ url: 'https://api.example.com/verify', body: { key: message, uid: user.telegramid } });
if (res && res.valid) {
  USER.setProperty('vip_status', true);
  clearWait();
  sendMessage('🎉 *Key activated!* Access your VIP portal below:', { buttons: [{ text: 'Join VIP Lounge', url: 'https://t.me/+example' }] });
} else {
  sendMessage('❌ Invalid or expired license key. Please check your key and try again.');
}

const active = await USER.getProp('vip_status').value();
if (!active) {
  sendMessage('🔒 No active VIP pass found. Type /activate to redeem a key.');
  return;
}
sendMessage('🎫 *VIP Member Card*\nUser: *' + user.first_name + '*\nStatus: *Active*');

⚠️ Note: Replace the API endpoint in verify_key.js with your actual authentication server URL.

const item = (Array.isArray(params) ? params[0] : params) || "sku_101";
const prop = await BOT.getProp(`stock_${item}`);
const qty = prop ? prop.value() || 0 : 0;
sendMessage(`📦 *Stock Level:* \`${item}\`\nQuantity: *${qty}*`, {
  buttons: [[
    { text: "-5", command: `/adj ${item} -5` },
    { text: "-1", command: `/adj ${item} -1` },
    { text: "+1", command: `/adj ${item} 1` },
    { text: "+5", command: `/adj ${item} 5` }
  ]]
});

if (!isCallback) return;
const args = Array.isArray(params) ? params : (params ? params.split(" ") : []);
const item = args[0] || "sku_101";
const delta = parseInt(args[1] || "0", 10);
const prop = await BOT.getProp(`stock_${item}`);
const current = prop ? prop.value() || 0 : 0;
const next = Math.max(0, current + delta);
await BOT.setProp(`stock_${item}`, next);
await answerCallback(`Stock updated to ${next}`);
editCallbackMessage(`📦 *Stock Level:* \`${item}\`\nQuantity: *${next}*`, [[
  { text: "-5", command: `/adj ${item} -5` },
  { text: "-1", command: `/adj ${item} -1` },
  { text: "+1", command: `/adj ${item} 1` },
  { text: "+5", command: `/adj ${item} 5` }
]], message_id);

⚠️ Note: Ensure your bot has database access configured via FIREBASE_URL and FIREBASE_SECRET so inventory levels persist across server restarts.

sendChatAction("typing");
sendMessage("Send the expense summary and total cost (e.g., Client Lunch $45):");
waitForAnswer("expense_photo");

TEMP.setProp("expense_details", message);
sendChatAction("typing");
sendMessage("Got it! Now upload a photo of the receipt image:");
waitForAnswer("expense_save");

const details = await TEMP.getProp("expense_details").value();
clearWait();
USER.add("total_expenses", 1);
TEMP.deleteProp("expense_details");
sendMessage("Logged expense receipt for: " + details);

⚠️ Note: Persistent counter methods like USER.add() require setting FIREBASE_URL and FIREBASE_SECRET in your environment variables.

🎉 We have just completed 2 yrs on YouTube

if (!params) return sendMessage("Please provide details: `/blocker <issue description>`");
USER.setProp("has_blocker", true);
USER.setProp("blocker_text", params);
USER.setProp("blocker_user", user.first_name);
sendMessage(`Logged active blocker: *${params}*\nClear it anytime with /unblock when resolved.`);

const active = await USER.getProp("has_blocker").value();
if (!active) return sendMessage("You currently have no active blockers logged. Nice work!");
const details = await USER.getProp("blocker_text").value();
sendMessage(`Your current blocker: *${details}*`);

USER.setProp("has_blocker", false);
USER.deleteProp("blocker_text");
USER.deleteProp("blocker_user");
sendMessage("Impediment cleared! Updated your status across the workspace.");

if (!inlineQuery) return;
const url = inlineQuery.startsWith('http') ? inlineQuery : `https://${inlineQuery}`;
const res = await HTTP.get({ url });
const status = res ? 'HTTP 200 OK' : 'Unreachable / Error';
answerInlineQuery([{
  type: 'article',
  id: '1',
  title: `Check ${inlineQuery}`,
  description: status,
  input_message_content: { message_text: `*Target:* \`${url}\`\n*Status:* ${status}` }
}]);

if (!params) return sendMessage('Provide a domain: `/ping example.com`');
sendChatAction('typing');
const url = params.startsWith('http') ? params : `https://${params}`;
const res = await HTTP.get({ url });
const status = res ? 'online' : 'offline';
sendMessage(`Host \`${url}\` is currently *${status}*.`);

⚠️ Note: Inline Mode must be explicitly turned on in @BotFather under Bot Settings > Inline Mode for the inline handler to work across chats.

⚠️ Note: Subscribe Backup Channel: https://youtube.com/@flecdev

📍 Comment "WhatsApp Hosting" on YouTube channel to get Part 2 as soon as possible.

await FLEX.setProperty('active', true)
const statusText = 'Welcome! You are now subscribed to automated community alerts.'
sendMessage(statusText, { buttons: [{ text: 'Check Status', command: '/status' }] })

const isActive = await FLEX.getProperty('active').value()
const text = isActive ? 'Subscription: *Active*' : 'Subscription: *Inactive*'
sendMessage(text)

if (String(user.telegramid) !== process.env.ADMIN_ID) return sendMessage('Access denied.')
sendMessage('Send the text you want to broadcast across all active subscribers:')
waitForAnswer('dispatch_announce')

clearWait()
const usersData = await getDB('users') || {}
const subscriberIds = Object.keys(usersData)
sendMessage(`Dispatching updates to ${subscriberIds.length} users with 100ms throttle...`)
const stats = await broadcast(subscriberIds, message, null, 100)
sendMessage(`Dispatch finished! Delivered: *${stats.sent}* | Failed: *${stats.failed}*`)

⚠️ Note: Ensure your ADMIN_ID environment variable is set to your numeric Telegram user ID to restrict access to the broadcast trigger.