nexushub-commands 1.0.0

package/lib/utils/formatMessage.d.ts

@@ -0,0 +1,8 @@
+export declare function formatMessage({ header, body, footer }: {
+    header?: string;
+    body?: ({
+        title: string;
+        data: any;
+    } | undefined)[];
+    footer?: string;
+}): string;

package/lib/utils/formatMessage.js

@@ -0,0 +1,46 @@
+"use strict";
+//@ts-nocheck
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatMessage = formatMessage;
+function formatMessage({ header, body, footer }) {
+    let text = header ? `${header}\n\n` : '';
+    for (const item of (body === null || body === void 0 ? void 0 : body.filter((x) => x)) || []) {
+        item.data = item.data.filter((x) => x);
+        if (!item.data.length)
+            continue;
+        text += `<blockquote><b>${item.title}</b></blockquote>`;
+        item.data.forEach((x, i) => {
+            var _a, _b, _c, _d;
+            if (!x[0])
+                return (text += '\n');
+            else if (!x[1] && x[1] !== undefined && x[1] !== null && !isNaN(x[1]))
+                x[1] = 'Отсутствует';
+            // else if (x[1] && Number(x[1].toString()?.replace(/\s/g, ''))) x[1] = Number(x[1].toString().replace(/\s/g, '')).toLocaleString('ru');
+            if ((i + 1 === item.data.length || !((_a = item.data[i + 1]) === null || _a === void 0 ? void 0 : _a.length)) && (i === 0 || ((_b = item.data[i - 1]) === null || _b === void 0 ? void 0 : _b.length)))
+                text += '┗';
+            else if (i > 0 && !((_c = item.data[i - 1]) === null || _c === void 0 ? void 0 : _c.length) && !((_d = item.data[i + 1]) === null || _d === void 0 ? void 0 : _d.length))
+                text += '┃';
+            else
+                text += '┣';
+            text += ' ';
+            if (x[0].includes('</a>') || x[0].match(/\@\S+/i))
+                text += x[0];
+            else
+                text += `<b>${x[0]}</b>`;
+            if (x[1]) {
+                text += ':  ';
+                if (x[1].toString().includes('</a>') || x[1].toString().match(/\@\S+/i))
+                    text += x[1];
+                else if (x[2] === null)
+                    text += x[1];
+                else
+                    text += `<${x[2] || 'code'}>${x[1]}</${x[2] || 'code'}>`;
+            }
+            text += '\n';
+        });
+        text += '\n';
+    }
+    if (footer)
+        text += `${footer}`;
+    return text;
+}

package/package.json

@@ -0,0 +1,16 @@
+{
+	"name": "nexushub-commands",
+	"version": "1.0.0",
+	"main": "./lib/index.js",
+	"license": "MIT",
+	"dependencies": {
+		"axios": "^1.9.0",
+		"chalk": "^5.4.1"
+	},
+	"peerDependencies": {
+		"evogram": "^2.0.8"
+	},
+	"devDependencies": {
+		"evogram": "^2.2.3"
+	}
+}

package/src/Client.ts

@@ -0,0 +1,49 @@
+import axios, { AxiosInstance } from 'axios';
+import { Evogram } from 'evogram';
+import { CommandContext } from 'evogram/lib/migrated';
+import { DepositCommand } from './commands/Deposit.command';
+import { GetDepositOrderCommand } from './commands/GetDepositOrder.command';
+
+// Интерфейсы для настройки команды
+export interface DepositConfig {
+	// Базовые настройки
+	API: AxiosInstance;
+	currency: string;
+
+	// Настройки изображений
+	images: {
+		deposit: string;
+		depositCard: string;
+		depositCrypto: string;
+		[key: string]: string;
+	};
+
+	// Настройки поддержки
+	support: {
+		username: string;
+	};
+}
+
+// Значения по умолчанию для конфигурации
+const defaultConfig: DepositConfig = {
+	API: axios.create(),
+	currency: 'RUB',
+
+	images: {
+		deposit: 'deposit',
+		depositCard: 'deposit-card',
+		depositCrypto: 'deposit-crypto',
+	},
+
+	support: {
+		username: 'support',
+	},
+};
+
+export class Client {
+	public static config: (context: CommandContext) => DepositConfig;
+
+	public static async init(client: Evogram) {
+		client.commands.commands.push(new DepositCommand(client), new GetDepositOrderCommand(client));
+	}
+}

package/src/commands/CheckPaidOrder.command.ts

@@ -0,0 +1,16 @@
+import { CommandArgument, CommandD, CommandExecuteData } from 'evogram';
+import { Command, CommandContext } from 'evogram/lib/migrated';
+import { Client } from '../Client';
+
+@CommandD({ name: 'checkPaidOrder', backButton: 'К пополнению' })
+export class CheckPaidOrderCommand extends Command {
+	public async execute(context: CommandContext, @CommandArgument('orderId') orderId: string) {
+		const config = Client.config(context);
+
+		await config.API.get(`/orders/${orderId}/checkPaid`).catch(() => {});
+		const order = await config.API.get(`/orders/${orderId}`);
+
+		if (order.data.status !== 'paid' && order.data.status !== 'fakepaid') throw new Error('Счет еще не оплачен');
+		else context.callbackQuery?.answer({ text: 'Счет оплачен', show_alert: true });
+	}
+}

package/src/commands/Deposit.command.ts

@@ -0,0 +1,243 @@
+import { Command, CommandArgument, CommandD, Evogram, numberValidator } from 'evogram';
+import { CommandContext } from 'evogram/lib/migrated';
+import { Client } from '../Client';
+import { GetDepositOrderCommand } from './GetDepositOrder.command';
+import { formatMessage } from '../utils/formatMessage';
+
+@CommandD({ name: 'deposit', description: [{ text: 'Пополнение' }, { language: 'en', text: 'Deposit' }] })
+export class DepositCommand extends Command {
+	public async execute(
+		context: CommandContext,
+
+		@CommandArgument('method', async ({ value, context }) => {
+			const config = Client.config(context);
+
+			if (value) {
+				const paymentMethods = (await config.API.get('/payments')).data;
+				if (!paymentMethods.find((x: any) => x.isEnabled && x.type.toLowerCase() === value.toLowerCase()))
+					throw new Error('К сожалению, данный метод пополнения временно недоступен');
+
+				if (value !== 'cryptowallet') return value;
+			}
+
+			if (!value) {
+				const allowedMethods = (await config.API.get('/orders/allowedMethods', { params: { currency: config.currency } })).data;
+
+				await context.sendFormatted(
+					{
+						photo: config.images.deposit,
+						header: '<b>📤 Выберите удобный для Вас метод пополнения.</b>',
+					},
+					{
+						reply_markup: {
+							inline_keyboard: [
+								...(allowedMethods.includes('card') ? [[{ text: '💳 Банковская карта', command: DepositCommand, payload: { method: 'card' } }]] : []),
+								...(allowedMethods.includes('qrcode') ? [[{ text: '📸 QR-код (СБП)', command: DepositCommand, payload: { method: 'qrcode' } }]] : []),
+								[{ text: '🪙 Криптовалюта', command: DepositCommand, payload: { method: 'cryptowallet' } }],
+							],
+						},
+					}
+				);
+			} else if (value === 'cryptowallet') {
+				await context.sendFormatted(
+					{
+						photo: config.images.depositCrypto,
+						header: '<b>🪙 Выберите удобный для вас метод пополнения.</b>',
+					},
+					{
+						reply_markup: {
+							inline_keyboard: [
+								[
+									{ text: '🤖 CryptoBot', command: DepositCommand, payload: { method: 'cryptoBot' } },
+									{ text: '🌐 По кошельку', command: DepositCommand, payload: { method: 'cryptoWallet' } },
+								],
+							],
+						},
+					}
+				);
+			}
+		})
+		method: string,
+
+		@CommandArgument('coin', async ({ value, args, context }) => {
+			if (value) return value;
+			else if (args.method !== 'cryptoWallet') return true;
+
+			const config = Client.config(context);
+			const wallets = await config.API.get('/crypto/wallets').then((x) => x.data.filter((x: any) => x.isActive));
+
+			context.sendFormatted(
+				{
+					header: '<b>🪙 Доступные криптовалюты для пополнения:</b>',
+					photo: config.images.depositCrypto,
+				},
+				{
+					reply_markup: {
+						inline_keyboard: wallets.map((x: any) => [
+							{
+								text: x.name,
+								command: DepositCommand,
+								payload: { ...args, coin: x.name },
+							},
+						]),
+					},
+				}
+			);
+		})
+		coin: string | undefined,
+
+		@CommandArgument(
+			{
+				name: 'deposit',
+				question: async ({ context, error, args, validateArgs }) => {
+					if (args.method === 'cryptoWallet') return 1;
+					const config = Client.config(context);
+
+					let minAmountSetting = JSON.parse(context.state.settings.find((x: any) => x.name === 'minDeposit').value);
+					let minAmount = minAmountSetting[config.currency] ?? (await minAmountSetting['RUB'].convert({ from: 'RUB', to: config.currency }));
+
+					const minDepositByMethod = await config.API.get('/config/minDepositByMethod').then((x) => x.data);
+					// prettier-ignore
+					if (minDepositByMethod && minDepositByMethod[args.method] !== undefined && (await minAmount.convert({ from: config.currency, to: 'RUB' })) < minDepositByMethod[args.method])
+						minAmount = await minDepositByMethod[args.method].convert({ from: 'RUB', to: config.currency });
+
+					validateArgs.minAmount = minAmount;
+					return (
+						await context.sendFormattedQuestion({
+							photo: ['card', 'qrcode'].includes(args.method) ? config.images.deposit : config.images.depositCrypto,
+							body: [
+								{
+									title: '💰 Сумма пополнения',
+									data: [['Введите сумму пополнения']],
+								},
+							],
+							footer: `<i>Минимальная сумма пополнения: {{ ${Number(minAmount).toLocaleString('ru')} ${config.currency} }}</i>`,
+							error: error?.message,
+						})
+					).text;
+				},
+			},
+			numberValidator({ allowFloat: true, min: 0 }),
+			async ({ value, context, args }) => {
+				if (args.method === 'cryptoWallet') return 0;
+				const config = Client.config(context);
+
+				const maxDeposit = await config.API.get('/config/maxDepositInService').then((x) => x.data);
+				const depositAmount = await value.convert({ from: config.currency, to: 'RUB' });
+
+				if (depositAmount > maxDeposit)
+					throw new Error(
+						`Пополнение, более чем на ${await maxDeposit.convert({ from: 'RUB', to: config.currency })}, доступно только через <a href="t.me/{{ ${
+							config.support.username
+						} }}">тех. поддержку</a>`
+					);
+
+				return value;
+			},
+			async ({ value, context, validateArgs }) => {
+				const config = Client.config(context);
+
+				if (Number(value) < Number(validateArgs.minAmount))
+					throw new Error(`Минимальная сумма пополнения: ${Number(validateArgs.minAmount).toLocaleString('ru')} ${config.currency}`);
+
+				return value;
+			}
+		)
+		deposit: number
+	) {
+		const config = Client.config(context);
+		let interval: NodeJS.Timeout;
+
+		if (method !== 'cryptoWallet') {
+			if (['card', 'qrcode'].includes(method)) {
+				const message = await context.sendFormatted({
+					photo: config.images.deposit,
+					body: [
+						{
+							title: 'ℹ️ Подождите, идет обработка заявки',
+							data: [['Создаем заявку на пополнение...']],
+						},
+					],
+				});
+
+				const startTime = Date.now();
+				interval = setInterval(async () => {
+					await message.edit({
+						text: formatMessage({
+							body: [
+								{
+									title: 'ℹ️ Подождите, идет обработка заявки',
+									data: [[`Создаем заявку на пополнение...`]],
+								},
+							],
+							footer: `<i>⏳ Прошло {{ ${Math.floor((Date.now() - startTime) / 1000)} }} сек.</i>`,
+						}),
+						parse_mode: 'HTML',
+					});
+				}, 1000);
+			}
+
+			const order = await config.API.post(`orders`, {
+				mirrorId: context.mammoth.mirror.mirror.id,
+				mammothId: context.user.id,
+				method,
+				amount: Number(deposit),
+				currency: config.currency,
+			})
+				.then((x) => x.data)
+				.catch(() => null);
+
+			//@ts-ignore
+			if (interval) clearInterval(interval);
+			this.logger.log(`Запрос на пополнение: ${JSON.stringify(order, null, 2)}`);
+
+			if (!order) {
+				context.user.log(0, `Не удалось получить реквизиты для пополнения на сумму ${Number(deposit).toLocaleString('ru')} ${config.currency}`);
+				return context.sendFormatted(
+					{
+						photo: config.images.deposit,
+						header: '<b>❗️К сожалению, сейчас нет доступных реквизитов для оплаты.</b>',
+						footer: '<i>ℹ️ Вы можете попробовать чуть позже, либо связаться с технической поддержкой.</i>',
+					},
+					{
+						reply_markup: {
+							inline_keyboard: [[{ text: '👩‍💻 Поддержка', url: `t.me/${config.support.username}` }]],
+						},
+					}
+				);
+			}
+
+			if (!order.isRepeat)
+				await context.user.log(
+					0,
+					`Запросил пополнение на ${Number(order.amount).toLocaleString('ru')} ${order.currency} (${await order.amount.convert({
+						from: order.currency,
+						to: 'RUB',
+						ceiled: true,
+					})})`,
+					{
+						keyboard: [[{ text: '🚀 Оплатить счет', callback_data: `paidOrder?orderId=${order.id}` }]],
+					}
+				);
+
+			return context.redirect(GetDepositOrderCommand, { orderId: order.id });
+		} else {
+			const wallets = (await config.API.get('/crypto/wallets')).data.filter((x: any) => x.isActive);
+
+			return context.sendFormatted({
+				photo: config.images.depositCrypto,
+				header: '<b>Создана заявка на оплату</b>',
+				body: [
+					{
+						title: 'ℹ️ Информация о реквизитах',
+						data: [
+							['Адрес кошелька', `{{ ${wallets.find((x: any) => x.name === coin).address} }}`],
+							['Криптовалюта', `{{ ${coin} }}`],
+						],
+					},
+				],
+				footer: '<i>Это Ваш постоянный адрес для пополнения.</i>',
+			});
+		}
+	}
+}

package/src/commands/GetDepositOrder.command.ts

@@ -0,0 +1,88 @@
+import { Command, CommandArgument, CommandD, CommandExecuteData } from 'evogram';
+import { CommandContext } from 'evogram/lib/migrated';
+import { Client } from '../Client';
+import { CheckPaidOrderCommand } from './CheckPaidOrder.command';
+
+@CommandD({ name: 'getDepositOrder', backButton: 'К пополнению' })
+export class GetDepositOrderCommand extends Command {
+	public async execute(context: CommandContext, @CommandArgument('orderId') orderId: string) {
+		const config = Client.config(context);
+		const order = await config.API.get(`/orders/deposit/${orderId}`)
+			.then((x) => x.data)
+			.catch(() => null);
+
+		if (!order) throw new Error('Заявка на оплату не найдена');
+
+		switch (order.method) {
+			case 'cryptoBot':
+				return context.sendFormatted(
+					{
+						photo: config.images.depositCrypto,
+						header: '<b>Создана заявка на оплату</b>',
+						body: [
+							{
+								title: 'ℹ️ Информация о счете',
+								data: [
+									['Сумма', `{{ ${Number(order.amount).toLocaleString('ru')} ${order.currency} }}`],
+									['Дата', `{{ ${new Date().toLocaleString('ru')} }}`],
+								],
+							},
+							{
+								title: '📎 Ваша ссылка для оплаты',
+								data: [[`{{ ${order.cryptoBot.url} }}`]],
+							},
+						],
+						footer: '<i>Ссылка действительна 10 минут.</i>',
+					},
+					{
+						reply_markup: {
+							inline_keyboard: [
+								[{ text: '🔗 Перейти к оплате', url: order.cryptoBot.url }],
+								[{ text: '🔄 Проверить оплату', command: CheckPaidOrderCommand, payload: { orderId: order.id } }],
+							],
+						},
+					}
+				);
+			case 'card':
+				return context.sendFormatted(
+					{
+						photo: config.images.deposit,
+						header: order.isRepeat ? '<b>❗️У вас уже есть заявка на пополнение, сначала оплатите ёё</b>' : '<b>Создана заявка на оплату</b>',
+						body: [
+							{
+								title: 'ℹ️ Информация о реквизитах',
+								data: [
+									['Реквизиты', `{{ ${order.card.requisites} }}`],
+									order.card.bank && ['Банк', `{{ ${order.card.bank} }}`],
+									order.card.holder && ['Получатель', `{{ ${order.card.holder} }}`],
+									['Сумма оплаты', `{{ ${Number(order.amount).toLocaleString('ru')} ${order.currency} }}`],
+								],
+							},
+						],
+						footer: '<i>Реквизиты действительны 10 минут.</i>',
+					},
+					{
+						reply_markup: {
+							inline_keyboard: [[{ text: '🔄 Проверить оплату', command: CheckPaidOrderCommand, payload: { orderId: order.id } }]],
+						},
+					}
+				);
+			case 'qrcode':
+				return context.sendFormatted(
+					{
+						photo: config.images.deposit,
+						header: '<b>Создана заявка на оплату</b>',
+						footer: `<i>Ссылка действительна ${Math.ceil((new Date(order.expiresAt).getTime() - new Date().getTime()) / 60000)} минут.</i>`,
+					},
+					{
+						reply_markup: {
+							inline_keyboard: [
+								[{ text: '🔗 Перейти к оплате', url: order.qrcode.link }],
+								[{ text: '🔄 Проверить оплату', command: CheckPaidOrderCommand, payload: { orderId: order.id } }],
+							],
+						},
+					}
+				);
+		}
+	}
+}

package/src/commands/index.ts

@@ -0,0 +1,3 @@
+export * from './Deposit.command';
+export * from './GetDepositOrder.command';
+export * from './CheckPaidOrder.command';

package/src/convert.ts

@@ -0,0 +1,91 @@
+import { CoinBaseService } from './utils/CoinBase.service';
+
+interface ConvertParams {
+	from?: string;
+	to: string;
+	round?: boolean;
+	ceiled?: boolean;
+}
+
+interface CurrencyConverter {
+	convert(params: ConvertParams): Promise<number>;
+}
+
+class ConvertedNumber {
+	private value: number;
+	private stringValue: string;
+
+	constructor(value: number, stringValue: string) {
+		this.value = value;
+		this.stringValue = stringValue;
+	}
+
+	// Переопределяем метод toString
+	toString() {
+		return this.stringValue;
+	}
+
+	// Добавляем valueOf для корректного сравнения
+	valueOf() {
+		return this.value;
+	}
+
+	convert(params: ConvertParams) {
+		return this.value.convert(params);
+	}
+}
+
+declare global {
+	interface String extends CurrencyConverter {
+		translate(language: string, ...args: any[]): Promise<string>;
+	}
+
+	interface Number extends CurrencyConverter {}
+}
+
+Number.prototype.convert = async function (this: number, params: ConvertParams): Promise<number> {
+	const { to = 'RUB', from = 'RUB', round, ceiled } = params;
+
+	const fromCurrency = from.toUpperCase();
+	const currency = to.toUpperCase();
+
+	if (currency === 'RUB' && fromCurrency === 'RUB') {
+		const value = round ? Math.round(this) : ceiled ? Math.ceil(this) : this;
+		//@ts-ignore
+		return new ConvertedNumber(value, `${value.toLocaleString('ru', { maximumFractionDigits: 2 })} RUB`);
+	} else if (currency === 'RUB') {
+		const rates = await CoinBaseService.getInstance().getRates('RUB');
+		const targetRate = 1 / Number(rates[fromCurrency]);
+
+		let convertedAmount = this * Number(targetRate);
+		if (!convertedAmount) convertedAmount = this;
+
+		if (round) {
+			convertedAmount = Math.round(convertedAmount);
+		} else if (ceiled) {
+			convertedAmount = Math.ceil(convertedAmount);
+		}
+
+		//@ts-ignore
+		return new ConvertedNumber(convertedAmount, `${convertedAmount.toLocaleString('ru', { maximumFractionDigits: 2 })} ${currency}`);
+	}
+
+	const rates = await CoinBaseService.getInstance().getRates(fromCurrency);
+	const targetRate = rates[currency];
+
+	let convertedAmount = this * Number(targetRate);
+	if (!convertedAmount) convertedAmount = this;
+
+	if (round) {
+		convertedAmount = Math.round(convertedAmount);
+	} else if (ceiled) {
+		convertedAmount = Math.ceil(convertedAmount);
+	}
+
+	//@ts-ignore
+	return new ConvertedNumber(convertedAmount, `${convertedAmount.toLocaleString('ru', { maximumFractionDigits: 2 })} ${targetRate ? currency : 'RUB'}`);
+};
+
+String.prototype.convert = function (this: string, params: ConvertParams) {
+	return Number(this).convert(params);
+};

package/src/index.ts

@@ -0,0 +1 @@
+export * from './Client';