sequelize-game-bank 5.0.2 → 5.1.0

package/.cache_ggshield

@@ -0,0 +1 @@
+{"last_found_secrets": [{"match": "34d9bf2fadeb3b27d67300951ca6eba96da51655834e1db45519bcbdd4bf9bee", "name": "Generic Password - /home/pl/Desktop/sequelize-game-bank/config/setup-env.js"}]}

package/config/setup-env.js

@@ -1,34 +1,53 @@
-const fs = require('fs');
-const path = require('path');
-const process = require('process');
-const envPath = path.resolve(process.cwd(), '.env');
+const fs = require("fs");
+const path = require("path");
+const process = require("process");
+const envPath = path.resolve(process.cwd(), ".env");
 const logger = require("custom-color-logs").print;
 const defaultEnvContent = `
 # ==============================================================================
-# sequelize-game-bank v4.0.0
+# sequelize-game-bank v5.0.0
 # ==============================================================================
+
+# тег инициализации 
 SEQUELIZE_GAME_BANK_INITIALIZED              = true
-JWT_SECRET                                   = 0000
-ROOT_PASSWORD                                = bank-root
-GMAIL                                        = example@gmail.com
-GOOGLE_APP_PASSWORD                          = abcd efgh ijkl mnop
+
+# токен который будет зашиваться в cooki
+JWT_SECRET                                   = "0000"
+
+# пароль от аккаунта админестратора
+ROOT_PASSWORD                                = "bank-root"
+
+# почта админестратора
+GMAIL                                        = "example@gmail.com"
+
+# пароль от приложения gmail
+GOOGLE_APP_PASSWORD                          = "abcd efgh ijkl mnop"
+
+# интервал проверки кредита
+CRON_CREDIT_INTERVAL_MINUTES                 = 5
+
 `;
 function initializeEnvironment() {
-    try {
-        if (!fs.existsSync(envPath)) {
-            fs.writeFileSync(envPath, defaultEnvContent, 'utf8');
-        } else {
-            const currentEnv = fs.readFileSync(envPath, 'utf8');
-            if (currentEnv.includes('SEQUELIZE_GAME_BANK_INITIALIZED')) {
-                require("dotenv").config({ path: envPath });
-                return;
-            }
-            fs.appendFileSync(envPath, `\n\n${defaultEnvContent}`, 'utf8');
-        }
-    } catch (err) {
-        console.log(logger.ServerError('Не удалось проверить или обновить .env:', err.message));
+  try {
+    if (!fs.existsSync(envPath)) {
+      fs.writeFileSync(envPath, defaultEnvContent, "utf8");
+    } else {
+      const currentEnv = fs.readFileSync(envPath, "utf8");
+      if (currentEnv.includes("SEQUELIZE_GAME_BANK_INITIALIZED")) {
+        require("dotenv").config({ path: envPath });
+        return;
+      }
+      fs.appendFileSync(envPath, `\n\n${defaultEnvContent}`, "utf8");
     }
-    require("dotenv").config({ path: envPath });
+  } catch (err) {
+    console.log(
+      logger.ServerError(
+        "Не удалось проверить или обновить .env:",
+        err.message,
+      ),
+    );
+  }
+  require("dotenv").config({ path: envPath });
 }
 initializeEnvironment();
-module.exports = { envPath };
+module.exports = { envPath };

package/database/models/Credit.js

@@ -1,37 +1,50 @@
-const { DataTypes } = require('sequelize');
+const { DataTypes } = require("sequelize");
 const path = require("path");
-const sequelize = require(path.join(__dirname, '..', 'config', 'init-db.js'));
-const Account = require(path.join(__dirname, 'Account.js'));
-const Credit = sequelize.define('credit', {
+const sequelize = require(path.join(__dirname, "..", "config", "init-db.js"));
+const Account = require(path.join(__dirname, "Account.js"));
+
+const Credit = sequelize.define("credit", {
   id: {
     type: DataTypes.INTEGER,
     autoIncrement: true,
-    primaryKey: true
+    primaryKey: true,
   },
-  account_id: {
+  accountId: {
     type: DataTypes.INTEGER,
     allowNull: false,
-    references: { model: Account, key: 'id' },
-    onDelete: 'CASCADE'
+    references: { model: Account, key: "id" },
+    onDelete: "CASCADE",
   },
-  total_payments: {
-    type: DataTypes.INTEGER,
-    allowNull: false
+  amount: {
+    type: DataTypes.DECIMAL(15, 2),
+    allowNull: false,
   },
-  remaining_payments: {
-    type: DataTypes.INTEGER,
-    allowNull: false
+  totalRepay: {
+    type: DataTypes.DECIMAL(15, 2),
+    allowNull: false,
   },
-  payment_amount: {
+  remainingRepay: {
     type: DataTypes.DECIMAL(15, 2),
-    allowNull: false
+    allowNull: false,
   },
-  auto_withdrawal: {
+  termMonths: {
+    type: DataTypes.INTEGER,
+    allowNull: false,
+  },
+  autoRepay: {
     type: DataTypes.BOOLEAN,
     allowNull: false,
-    defaultValue: false
-  }
+    defaultValue: false,
+  },
+  status: {
+    type: DataTypes.STRING,
+    allowNull: false,
+    defaultValue: "active",
+  },
 });
-Account.hasMany(Credit, { foreignKey: 'account_id' });
-Credit.belongsTo(Account, { foreignKey: 'account_id', as: 'linkedAccount' });
-module.exports = Credit;
+
+// Настройка связей с учетом нового имени внешнего ключа accountId
+Account.hasMany(Credit, { foreignKey: "accountId" });
+Credit.belongsTo(Account, { foreignKey: "accountId", as: "linkedAccount" });
+
+module.exports = Credit;

package/database/services/account/create-credit.js

@@ -1,50 +1,92 @@
 const path = require("path");
-const Account = require(path.join(__dirname, '..', '..', 'models', 'Account.js'));
-const Credit = require(path.join(__dirname, '..', '..', 'models', 'Credit.js'));
-const sequelize = require(path.join(__dirname, '..', '..', 'config', 'init-db.js'));
-async function createCredit({ accountId, amount, autoRepay = false, rate = 0.1, termMonths = 12 }) {
+const Account = require(
+  path.join(__dirname, "..", "..", "models", "Account.js"),
+);
+const Credit = require(path.join(__dirname, "..", "..", "models", "Credit.js"));
+const sequelize = require(
+  path.join(__dirname, "..", "..", "config", "init-db.js"),
+);
+const bcrypt = require("bcrypt");
+// Функция теперь принимает аргументы по порядку, как они передаются из роутера
+async function createCredit(
+  username,
+  accountId,
+  amount,
+  pinCode,
+  termMonths = 12,
+  autoRepay = false,
+) {
   const numericAmount = parseFloat(amount);
-  const numericRate = parseFloat(rate);
   const numericTerm = parseInt(termMonths, 10);
+  const numericRate = 0.1;
   if (!accountId || isNaN(numericAmount) || numericAmount <= 0) {
-    return { success: false, error: 'Некорректные параметры для создания кредита' };
+    return {
+      success: false,
+      error: "Некорректные параметры для создания кредита",
+    };
   }
-  if (isNaN(numericRate) || numericRate < 0 || isNaN(numericTerm) || numericTerm <= 0) {
-    return { success: false, error: 'Некорректная процентная ставка или срок кредитования' };
+  if (isNaN(numericTerm) || numericTerm <= 0) {
+    return { success: false, error: "Некорректный срок кредитования" };
   }
+  if (!pinCode) {
+    return {
+      success: false,
+      error: "Укажите PIN-код для подтверждения операции",
+    };
+  }
+
   const transaction = await sequelize.transaction();
   try {
     const account = await Account.findOne({
       where: { id: accountId },
       lock: transaction.LOCK.UPDATE,
-      transaction
+      transaction,
     });
-    if (!account) throw new Error('Аккаунт не найден');
-    if (account.status === 'blocked') throw new Error('Аккаунт заблокирован');
+
+    if (!account) throw new Error("Аккаунт не найден");
+
+    if (account.user !== username)
+      throw new Error("Нет доступа к данному счету");
+
+    if (account.status === "blocked") throw new Error("Аккаунт заблокирован");
+
+    const isPinValid = await bcrypt.compare(
+      pinCode,
+      account.pincode || account.pin_code,
+    );
+    if (!isPinValid) throw new Error("Неверный PIN-код");
+
     const existingCredit = await Credit.findOne({
-      where: { accountId: account.id, status: 'active' },
+      where: { accountId: account.id, status: "active" },
       transaction,
-      lock: transaction.LOCK.UPDATE
+      lock: transaction.LOCK.UPDATE,
     });
     if (existingCredit) {
-      throw new Error('У этого аккаунта уже есть активный кредит');
+      throw new Error("У этого аккаунта уже есть активный кредит");
     }
+
     const totalRepay = numericAmount * (1 + numericRate);
-    const credit = await Credit.create({
-      accountId: account.id,
-      amount: numericAmount,
-      totalRepay: totalRepay,
-      remainingRepay: totalRepay,
-      status: 'active',
-      autoRepay: !!autoRepay,
-      termMonths: numericTerm
-    }, { transaction });
-    await account.increment('balance', { by: numericAmount, transaction });
+
+    const credit = await Credit.create(
+      {
+        accountId: account.id,
+        amount: numericAmount,
+        totalRepay: totalRepay,
+        remainingRepay: totalRepay,
+        status: "active",
+        autoRepay: !!autoRepay,
+        termMonths: numericTerm,
+      },
+      { transaction },
+    );
+
+    await account.increment("manny", { by: numericAmount, transaction });
+
     await transaction.commit();
     return {
       success: true,
-      message: 'Кредит успешно оформлен',
-      creditId: credit.id
+      message: "Кредит успешно оформлен",
+      creditId: credit.id,
     };
   } catch (error) {
     if (transaction && !transaction.finished) {
@@ -53,4 +95,5 @@ async function createCredit({ accountId, amount, autoRepay = false, rate = 0.1,
     return { success: false, error: error.message };
   }
 }
-module.exports = createCredit;
+
+module.exports = createCredit;

package/database/services/bot/cron-schedule.js

@@ -1,14 +1,20 @@
-const cron = require('node-cron');
-const nodemailer = require('nodemailer');
-const { Op } = require('sequelize');
+const cron = require("node-cron");
+const nodemailer = require("nodemailer");
+const { Op } = require("sequelize");
 const path = require("path");
-const Account = require(path.join(__dirname, '..', '..', 'models', 'Account'));
-const Credit = require(path.join(__dirname, '..', '..', 'models', 'Credit'));
-const User = require(path.join(__dirname, '..', '..', 'models', 'User'));
-const sequelize = require(path.join(__dirname, '..', '..', 'config', 'init-db'));
+const sequelize = require(
+  path.join(__dirname, "..", "..", "config", "init-db"),
+);
+const Account = require(path.join(__dirname, "..", "..", "models", "Account"));
+const Credit = require(path.join(__dirname, "..", "..", "models", "Credit"));
+const User = require(path.join(__dirname, "..", "..", "models", "User"));
 const logger = require("custom-color-logs").print;
+if (!Account.associations["User"]) {
+  Account.belongsTo(User, { foreignKey: "user", as: "User" });
+}
+
 const transporter = nodemailer.createTransport({
-  service: 'gmail',
+  service: "gmail",
   auth: {
     user: process.env.GMAIL,
     pass: process.env.GOOGLE_APP_PASSWORD,
@@ -16,8 +22,11 @@ const transporter = nodemailer.createTransport({
 });
 
 transporter.verify((err) => {
-  if (err) console.log(logger.NodemailerError('Ошибка конфигурации почты:', err.message));
-  else console.log(logger.NodemailerInfo('Сервер готов к отправке писем'));
+  if (err)
+    console.log(
+      logger.NodemailerError("Ошибка конфигурации почты:", err.message),
+    );
+  else console.log(logger.NodemailerInfo("Сервер готов к отправке писем"));
 });
 
 async function sendEmailNotification(userEmail, subject, htmlContent) {
@@ -29,63 +38,158 @@ async function sendEmailNotification(userEmail, subject, htmlContent) {
       subject: subject,
       html: htmlContent,
     });
-    console.log(logger.NodemailerFunctionPositivePerformance(`Письмо успешно отправлено на ${userEmail}`));
+    console.log(
+      logger.ServerCreditNodemailerFunctionPositivePerformance(
+        `Письмо успешно отправлено на ${userEmail}`,
+      ),
+    );
   } catch (error) {
-    console.log(logger.NodemailerError(`Не удалось отправить письмо на ${userEmail}:\n ${error.message}`));
+    console.log(
+      logger.ServerCreditNodemailerError(
+        `Не удалось отправить письмо на ${userEmail}:\n ${error.message}`,
+      ),
+    );
   }
 }
-cron.schedule('0 0 * * *', async () => {
-  console.log(logger.NodemailerFunctionInfo(`Проверка активных кредитов и обработка платежей...`));
-  
+const envMinutes = parseInt(process.env.CRON_CREDIT_INTERVAL_MINUTES, 10);
+let cronExpression = "0 0 * * *";
+
+if (!isNaN(envMinutes) && envMinutes > 0) {
+  cronExpression = `*/${envMinutes} * * * *`;
+  console.log(
+    logger.ServerCreditInfo(
+      `Установлен кастомный интервал проверки: каждые ${envMinutes} мин. (${cronExpression})`,
+    ),
+  );
+} else {
+  console.log(
+    logger.ServerCreditInfo(
+      `Переменная CRON_CREDIT_INTERVAL_MINUTES не задана. Переход на режим: раз в сутки (${cronExpression})`,
+    ),
+  );
+}
+cron.schedule(cronExpression, async () => {
+  console.log(
+    logger.ServerCreditInfo(`Проверка active кредитов и обработка платежей...`),
+  );
+
   try {
     const activeCredits = await Credit.findAll({
       where: {
-        status: 'active',
-        remainingRepay: { [Op.gt]: 0 }
-      }
+        status: "active",
+        remainingRepay: { [Op.gt]: 0 },
+      },
     });
+
+    if (activeCredits.length === 0) {
+      console.log(
+        logger.ServerCreditInfo(`Активных кредитов для обработки не найдено.`),
+      );
+      return;
+    }
+
     for (const activeCreditData of activeCredits) {
       let emailToSend = null;
-      let emailSubject = '';
-      let emailHtml = '';
+      let emailSubject = "";
+      let emailHtml = "";
+
+      const creditId =
+        activeCreditData.id ||
+        activeCreditData.get("id") ||
+        (activeCreditData.dataValues ? activeCreditData.dataValues.id : null);
+      if (!creditId) {
+        console.log(
+          logger.ServerCreditError(
+            `Не удалось определить ID записи кредита. Пропускаем.`,
+          ),
+        );
+        continue;
+      }
+
       const transaction = await sequelize.transaction();
+
       try {
-        const credit = await Credit.findByPk(activeCreditData.id, {
+        const credit = await Credit.findByPk(creditId, {
           transaction,
-          lock: transaction.LOCK.UPDATE
+          lock: transaction.LOCK.UPDATE,
         });
-        if (!credit || credit.status !== 'active' || credit.remainingRepay <= 0) {
+
+        if (
+          !credit ||
+          credit.status !== "active" ||
+          credit.remainingRepay <= 0
+        ) {
           await transaction.rollback();
           continue;
         }
+
         const calculatedPayment = credit.totalRepay / credit.termMonths;
-        const paymentAmount = Math.min(calculatedPayment, credit.remainingRepay);
+        const paymentAmount = Math.min(
+          calculatedPayment,
+          credit.remainingRepay,
+        );
+
+        const targetAccountId =
+          credit.accountId ||
+          credit.account_id ||
+          credit.get("accountId") ||
+          credit.get("account_id");
+
+        if (!targetAccountId) {
+          console.log(
+            logger.ServerCreditError(
+              `У кредита ID #${credit.id} не найден связанный ID аккаунта`,
+            ),
+          );
+          await transaction.rollback();
+          continue;
+        }
+
         const account = await Account.findOne({
-          where: { id: credit.accountId },
-          include: [{ model: User, as: 'User' }],
+          where: { id: targetAccountId },
+          include: [{ model: User, as: "User" }],
           transaction,
-          lock: transaction.LOCK.UPDATE
+          lock: transaction.LOCK.UPDATE,
         });
-        if (!account || !account.User || !account.User.gmail) {
-          console.error(`[CRON Warning] Не найден Email или аккаунт для кредита ID #${credit.id}`);
+
+        if (!account || !account.User || !account.User.user_gmail) {
+          console.log(
+            logger.ServerCreditError(
+              `Не найден Email (user_gmail) или аккаунт для кредита ID #${credit.id}`,
+            ),
+          );
           await transaction.rollback();
           continue;
         }
-        const userEmail = account.User.gmail;
+
+        const userEmail = account.User.user_gmail;
+
         if (credit.autoRepay) {
-          if (account.status === 'blocked') {
-            throw new Error('Аккаунт заблокирован');
+          if (account.status === "blocked") {
+            throw new Error("Аккаунт заблокирован");
           }
-          if (account.balance >= paymentAmount) {
-            await account.decrement('balance', { by: paymentAmount, transaction });
+
+          if (
+            account.balance >= paymentAmount ||
+            account.manny >= paymentAmount
+          ) {
+            const balanceField =
+              account.manny !== undefined ? "manny" : "balance";
+            await account.decrement(balanceField, {
+              by: paymentAmount,
+              transaction,
+            });
+
             credit.remainingRepay -= paymentAmount;
             if (credit.remainingRepay <= 0) {
-              credit.status = 'paid';
+              credit.status = "paid";
             }
+
             await credit.save({ transaction });
             await transaction.commit();
+
             emailToSend = userEmail;
-            emailSubject = 'Успешное автосписание по кредиту — Game Bank';
+            emailSubject = "Успешное автосписание по кредиту — Game Bank";
             emailHtml = `<h3>Уважаемый клиент!</h3>
                <p>С вашего баланса было автоматически списано <b>${paymentAmount.toFixed(2)} USD</b> в счет погашения кредита.</p>
                <p>Остаток задолженности: <b>${credit.remainingRepay.toFixed(2)} USD</b>.</p>`;
@@ -93,7 +197,8 @@ cron.schedule('0 0 * * *', async () => {
             await transaction.rollback();
 
             emailToSend = userEmail;
-            emailSubject = 'Ошибка автосписания: недостаточно средств — Game Bank';
+            emailSubject =
+              "Ошибка автосписания: недостаточно средств — Game Bank";
             emailHtml = `<h3>Внимание! Недостаточно средств</h3>
                <p>Мы не смогли списать регулярный платеж по кредиту в размере <b>${paymentAmount.toFixed(2)} USD</b>.</p>
                <p>Пожалуйста, пополните баланс вашего аккаунта, чтобы избежать просрочки.</p>`;
@@ -101,12 +206,13 @@ cron.schedule('0 0 * * *', async () => {
         } else {
           await transaction.rollback();
           emailToSend = userEmail;
-          emailSubject = 'Напоминание о платеже по кредиту — Game Bank';
+          emailSubject = "Напоминание о платеже по кредиту — Game Bank";
           emailHtml = `<h3>Здравствуйте!</h3>
            <p>Напоминаем, что вам необходимо внести обязательный платеж по кредиту в размере <b>${paymentAmount.toFixed(2)} USD</b>.</p>
            <p>Текущий остаток по кредиту: <b>${credit.remainingRepay.toFixed(2)} USD</b>.</p>
            <p>Вы можете оплатить его в личном кабинете.</p>`;
         }
+
         if (emailToSend) {
           await sendEmailNotification(emailToSend, emailSubject, emailHtml);
         }
@@ -114,10 +220,18 @@ cron.schedule('0 0 * * *', async () => {
         if (transaction && !transaction.finished) {
           await transaction.rollback();
         }
-        console.log(logger.NodemailerError(`Ошибка обработки кредита ID ${activeCreditData.id}: ${err.message}`));
+        console.log(
+          logger.ServerCreditError(
+            `Ошибка обработки кредита ID ${activeCreditData.id}: ${err.message}`,
+          ),
+        );
       }
     }
   } catch (error) {
-    console.log(logger.NodemailerError(`Ошибка кредитного планировщика: ${error.message}`));
+    console.log(
+      logger.ServerCreditError(
+        `Ошибка кредитного планировщика: ${error.message}`,
+      ),
+    );
   }
-});
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sequelize-game-bank",
-  "version": "5.0.2",
+  "version": "5.1.0",
   "description": "A Sequelize-based gaming economy and banking system featuring user profiles, credits, admin management, and detailed transaction history.",
   "main": "index.js",
   "type": "commonjs",