med-cms 1.0.0-beta.1 → 1.0.0-beta.2

package/database/config/db-init.js

@@ -1,12 +1,9 @@
-const { Sequelize } = require('sequelize');
+const { Sequelize, DataTypes } = require('sequelize');
 const path = require('path');
-const Clinic = require(path.join(__dirname, '..', 'models', 'clinics'));
-const User = require(path.join(__dirname, '..', 'models', 'users'));
-const UserAddress = require(path.join(__dirname, '..', 'models', 'user-addresses'));
-const Disease = require(path.join(__dirname, '..', 'models', 'diseases'));
-const Appointment = require(path.join(__dirname, '..', 'models', 'appointments'));
 const logger = require("custom-color-logs").print;
+
 let sequelize;
+
 function getSequelizeInstance(dbPath) {
   if (!sequelize) {
     const storagePath = dbPath || path.join(process.cwd(), 'med-cms.sqlite');
@@ -18,27 +15,76 @@ function getSequelizeInstance(dbPath) {
   }
   return sequelize;
 }
+
 async function initDatabase(dbPath) {
   const instance = getSequelizeInstance(dbPath);
+  
   try {
     await instance.authenticate();
-    console.log(logger.DatabaseMedInfo("Успешное подключение к SQLite через Sequelize."))
-    User.belongsTo(Clinic, { foreignKey: 'ClinicId', onDelete: 'SET NULL' });
-    Clinic.hasMany(User, { foreignKey: 'ClinicId' });
-    UserAddress.belongsTo(User, { foreignKey: 'UserId', onDelete: 'CASCADE' });
-    User.hasOne(UserAddress, { foreignKey: 'UserId' });
-    Appointment.belongsTo(User, { as: 'Patient', foreignKey: 'PatientId', onDelete: 'CASCADE' });
-    Appointment.belongsTo(User, { as: 'Doctor', foreignKey: 'DoctorId', onDelete: 'CASCADE' });
-    Appointment.belongsTo(Disease, { foreignKey: 'DiseaseId', onDelete: 'SET NULL' });
+    console.log(logger.DatabaseMedInfo("Успешное подключение к SQLite через Sequelize."));
+
+    // 1. Импортируем функции моделей и сразу инициализируем их инстансом sequelize
+    const models = {
+      Clinic: require(path.join(__dirname, '..', 'models', 'clinics'))(instance, DataTypes),
+      User: require(path.join(__dirname, '..', 'models', 'users'))(instance, DataTypes),
+      UserAddress: require(path.join(__dirname, '..', 'models', 'user-addresses'))(instance, DataTypes),
+      Disease: require(path.join(__dirname, '..', 'models', 'diseases'))(instance, DataTypes),
+      Appointment: require(path.join(__dirname, '..', 'models', 'appointments'))(instance, DataTypes)
+    };
+
+    // 2. Автоматически запускаем связи, которые мы прописали внутри файлов таблиц
+    Object.keys(models).forEach((modelName) => {
+      if (models[modelName].associate) {
+        models[modelName].associate(models);
+      }
+    });
+
     await instance.sync({ alter: true });
-    console.log(logger.DatabaseMedInfo("Все таблицы базы данных успешно синхронизированы."))
+    console.log(logger.DatabaseMedInfo("Все таблицы базы данных успешно синхронизированы."));
   } catch (error) {
-    console.log(logger.DatabaseMedError('Ошибка инициализации базы данных:', error))
+    console.log(logger.DatabaseMedError('Ошибка инициализации базы данных:', error));
     throw error;
   }
 }
-module.exports = {
-  get sequelize() { return sequelize; },
+
+// В самом конце вашего database/config/db-init.js вместо старого exports:
+
+const db = {
   getSequelizeInstance,
-  initDatabase
-};
+  initDatabase,
+  get sequelize() { return sequelize; },
+  // Динамически прокидываем модели наружу, чтобы они были доступны как db.User, db.Clinic и т.д.
+  models: {} 
+};
+
+// Перепишем функцию initDatabase, чтобы она сохраняла модели в db.models и самом объекте db
+async function initDatabase(dbPath) {
+  const instance = getSequelizeInstance(dbPath);
+  
+  try {
+    await instance.authenticate();
+    console.log(logger.DatabaseMedInfo("Успешное подключение к SQLite через Sequelize."));
+
+    // Инициализируем и сохраняем в объект
+    db.models.Clinic = db.Clinic = require(path.join(__dirname, '..', 'models', 'clinics'))(instance, DataTypes);
+    db.models.User = db.User = require(path.join(__dirname, '..', 'models', 'users'))(instance, DataTypes);
+    db.models.UserAddress = db.UserAddress = require(path.join(__dirname, '..', 'models', 'user-addresses'))(instance, DataTypes);
+    db.models.Disease = db.Disease = require(path.join(__dirname, '..', 'models', 'diseases'))(instance, DataTypes);
+    db.models.Appointment = db.Appointment = require(path.join(__dirname, '..', 'models', 'appointments'))(instance, DataTypes);
+
+    // Запускаем связи
+    Object.keys(db.models).forEach((modelName) => {
+      if (db.models[modelName].associate) {
+        db.models[modelName].associate(db.models);
+      }
+    });
+
+    await instance.sync({ alter: true });
+    console.log(logger.DatabaseMedInfo("Все таблицы базы данных успешно синхронизированы."));
+  } catch (error) {
+    console.log(logger.DatabaseMedError('Ошибка инициализации базы данных:', error));
+    throw error;
+  }
+}
+
+module.exports = db;

package/database/models/appointments.js

@@ -1,39 +1,29 @@
-const { DataTypes } = require('sequelize');
-const path = require("path");
-const { getSequelizeInstance } = require(path.join(__dirname, '..', 'config', 'db-init.js'));
-const sequelize = getSequelizeInstance();
-const Appointment = sequelize.define('Appointment', {
-  id: {
-    type: DataTypes.UUID,
-    defaultValue: DataTypes.UUIDV4,
-    primaryKey: true
-  },
-  date: {
-    type: DataTypes.DATEONLY,
-    allowNull: false
-  },
-  time: {
-    type: DataTypes.STRING,
-    allowNull: false
-  },
-  status: {
-    type: DataTypes.ENUM('ожидается', 'завершен', 'отменен'),
-    defaultValue: 'ожидается',
-    allowNull: false
-  },
-  complaints: {
-    type: DataTypes.TEXT,
-    allowNull: true
-  },
-  objectively: {
-    type: DataTypes.TEXT,
-    allowNull: true
-  },
-  doctorNotes: {
-    type: DataTypes.TEXT,
-    allowNull: true
-  }
-}, {
-  timestamps: true
-});
-module.exports = Appointment;
+module.exports = (sequelize, DataTypes) => {
+  const Appointment = sequelize.define('Appointment', {
+    id: {
+      type: DataTypes.UUID,
+      defaultValue: DataTypes.UUIDV4,
+      primaryKey: true
+    },
+    date: { type: DataTypes.DATEONLY, allowNull: false },
+    time: { type: DataTypes.STRING, allowNull: false },
+    status: {
+      type: DataTypes.ENUM('ожидается', 'завершен', 'отменен'),
+      defaultValue: 'ожидается',
+      allowNull: false
+    },
+    complaints: { type: DataTypes.TEXT, allowNull: true },
+    objectively: { type: DataTypes.TEXT, allowNull: true },
+    doctorNotes: { type: DataTypes.TEXT, allowNull: true }
+  }, {
+    timestamps: true
+  });
+
+  Appointment.associate = (models) => {
+    Appointment.belongsTo(models.User, { as: 'Patient', foreignKey: 'PatientId', onDelete: 'CASCADE' });
+    Appointment.belongsTo(models.User, { as: 'Doctor', foreignKey: 'DoctorId', onDelete: 'CASCADE' });
+    Appointment.belongsTo(models.Disease, { foreignKey: 'DiseaseId', onDelete: 'SET NULL' });
+  };
+
+  return Appointment;
+};

package/database/models/clinics.js

@@ -1,18 +1,22 @@
-const { DataTypes } = require('sequelize');
-const path = require("path")
-const { getSequelizeInstance } = require(path.join(__dirname, '..', 'config', 'db-init.js'));
-const sequelize = getSequelizeInstance();
-const Clinic = sequelize.define('Clinic', {
-  id: {
-    type: DataTypes.INTEGER,
-    autoIncrement: true,
-    primaryKey: true
-  },
-  name: { type: DataTypes.STRING, allowNull: false, unique: true },
-  type: { type: DataTypes.ENUM('больница', 'поликлиника', 'станция скорой помощи', 'частный медицинский центр'), allowNull: false },
-  address: { type: DataTypes.STRING, allowNull: false },
-  phone: { type: DataTypes.STRING, allowNull: true }
-}, { 
-  timestamps: true 
-});
-module.exports = Clinic;
+module.exports = (sequelize, DataTypes) => {
+  const Clinic = sequelize.define('Clinic', {
+    id: {
+      type: DataTypes.INTEGER,
+      autoIncrement: true,
+      primaryKey: true
+    },
+    name: { type: DataTypes.STRING, allowNull: false, unique: true },
+    type: { type: DataTypes.ENUM('больница', 'поликлиника', 'станция скорой помощи', 'частный медицинский центр'), allowNull: false },
+    address: { type: DataTypes.STRING, allowNull: false },
+    phone: { type: DataTypes.STRING, allowNull: true }
+  }, { 
+    timestamps: true 
+  });
+
+  // Настройка связи прямо в таблице клиник
+  Clinic.associate = (models) => {
+    Clinic.hasMany(models.User, { foreignKey: 'ClinicId' });
+  };
+
+  return Clinic;
+};

package/database/models/diseases.js

@@ -1,37 +1,19 @@
-const { DataTypes } = require('sequelize');
-const path = require("path");
-const { getSequelizeInstance } = require(path.join(__dirname, '..', 'config', 'db-init.js'));
-const sequelize = getSequelizeInstance();
-const Disease = sequelize.define('Disease', {
-  id: {
-    type: DataTypes.INTEGER,
-    autoIncrement: true,
-    primaryKey: true
-  },
-  name: { 
-    type: DataTypes.STRING, 
-    allowNull: false, 
-    unique: true 
-  },
-  code: { 
-    type: DataTypes.STRING, 
-    allowNull: false, 
-    unique: true
-  },
-  treatmentRecommendations: { 
-    type: DataTypes.TEXT, 
-    allowNull: true 
-  },
-  recommendedMedications: { 
-    type: DataTypes.TEXT, 
-    allowNull: true 
-  },
-  casesCount: { 
-    type: DataTypes.INTEGER, 
-    defaultValue: 0, 
-    allowNull: false 
-  }
-}, {
-  timestamps: true
-});
-module.exports = Disease;
+module.exports = (sequelize, DataTypes) => {
+  const Disease = sequelize.define('Disease', {
+    id: {
+      type: DataTypes.INTEGER,
+      autoIncrement: true,
+      primaryKey: true
+    },
+    name: { type: DataTypes.STRING, allowNull: false, unique: true },
+    code: { type: DataTypes.STRING, allowNull: false, unique: true },
+    treatmentRecommendations: { type: DataTypes.TEXT, allowNull: true },
+    recommendedMedications: { type: DataTypes.TEXT, allowNull: true },
+    casesCount: { type: DataTypes.INTEGER, defaultValue: 0, allowNull: false }
+  }, {
+    timestamps: true
+  });
+
+  // У этой модели нет прямых исходящих связей (зависит от Appointment, но связь прописана там)
+  return Disease;
+};

package/database/models/user-addresses.js

@@ -1,34 +1,22 @@
-const { DataTypes } = require('sequelize');
-const path = require("path")
-const { getSequelizeInstance } = require(path.join('..', 'config', 'db-init.js'));
-const sequelize = getSequelizeInstance();
-const UserAddress = sequelize.define('UserAddress', {
-  id: {
-    type: DataTypes.UUID,
-    defaultValue: DataTypes.UUIDV4,
-    primaryKey: true
-  },
-  city: {
-    type: DataTypes.STRING,
-    allowNull: false
-  },
-  street: {
-    type: DataTypes.STRING,
-    allowNull: false
-  },
-  houseNumber: {
-    type: DataTypes.STRING,
-    allowNull: false
-  },
-  assignedDistrict: {
-    type: DataTypes.STRING,
-    allowNull: true
-  },
-  assignedCabinet: {
-    type: DataTypes.STRING,
-    allowNull: true
-  }
-}, {
-  timestamps: true
-});
-module.exports = UserAddress;
+module.exports = (sequelize, DataTypes) => {
+  const UserAddress = sequelize.define('UserAddress', {
+    id: {
+      type: DataTypes.UUID,
+      defaultValue: DataTypes.UUIDV4,
+      primaryKey: true
+    },
+    city: { type: DataTypes.STRING, allowNull: false },
+    street: { type: DataTypes.STRING, allowNull: false },
+    houseNumber: { type: DataTypes.STRING, allowNull: false },
+    assignedDistrict: { type: DataTypes.STRING, allowNull: true },
+    assignedCabinet: { type: DataTypes.STRING, allowNull: true }
+  }, {
+    timestamps: true
+  });
+
+  UserAddress.associate = (models) => {
+    UserAddress.belongsTo(models.User, { foreignKey: 'UserId', onDelete: 'CASCADE' });
+  };
+
+  return UserAddress;
+};

package/database/models/users.js

@@ -1,31 +1,36 @@
-const { DataTypes } = require('sequelize');
-const path = require("path");
-const { getSequelizeInstance } = require(path.join(__dirname, '..', 'config', 'db-init.js'));
-const sequelize = getSequelizeInstance();
-const User = sequelize.define('User', {
-  id: {
-    type: DataTypes.INTEGER,
-    autoIncrement: true,
-    primaryKey: true
-  },
-  email: { type: DataTypes.STRING, allowNull: false, unique: true, validate: { isEmail: true } },
-  password: { type: DataTypes.STRING, allowNull: false },
-  fullName: { type: DataTypes.STRING, allowNull: false },
-  role: { type: DataTypes.ENUM('patient', 'doctor', 'admin'), defaultValue: 'patient', allowNull: false },
-  specialty: {
-    type: DataTypes.ENUM(
-      'Терапевт', 'Педиатр', 'Врач общей практики', 'Кардиолог', 'Невролог', 
-      'Эндокринолог', 'Гастроэнтеролог', 'Пульмонолог', 'Нефролог', 'Ревматолог', 
-      'Гематолог', 'Хирург', 'Травматолог-ортопед', 'Сосудистый хирург', 'Нейрохирург', 
-      'Кардиохирург', 'Пластический хирург', 'Офтальмолог', 'Отоларинголог', 'Дерматолог', 
-      'Стоматолог', 'Гинеколог', 'Уролог', 'Онколог', 'Инфекционист', 'Аллерголог-иммунолог', 
-      'Психиатр', 'Психотерапевт', 'Нарколог', 'Анестезиолог-реаниматолог', 'Рентгенолог', 
-      'Врач УЗД', 'Эндоскопист', 'Патологоанатом'
-    ),
-    allowNull: true 
-  },
-  isTemporaryPassword: { type: DataTypes.BOOLEAN, defaultValue: false }
-}, { 
-  timestamps: true 
-});
-module.exports = User;
+module.exports = (sequelize, DataTypes) => {
+  const User = sequelize.define('User', {
+    id: {
+      type: DataTypes.INTEGER,
+      autoIncrement: true,
+      primaryKey: true
+    },
+    email: { type: DataTypes.STRING, allowNull: false, unique: true, validate: { isEmail: true } },
+    password: { type: DataTypes.STRING, allowNull: false },
+    fullName: { type: DataTypes.STRING, allowNull: false },
+    role: { type: DataTypes.ENUM('patient', 'doctor', 'admin'), defaultValue: 'patient', allowNull: false },
+    specialty: {
+      type: DataTypes.ENUM(
+        'Терапевт', 'Педиатр', 'Врач общей практики', 'Кардиолог', 'Невролог', 
+        'Эндокринолог', 'Гастроэнтеролог', 'Пульмонолог', 'Нефролог', 'Ревматолог', 
+        'Гематолог', 'Хирург', 'Травматолог-ортопед', 'Сосудистый хирург', 'Нейрохирург', 
+        'Кардиохирург', 'Пластический хирург', 'Офтальмолог', 'Отоларинголог', 'Дерматолог', 
+        'Стоматолог', 'Гинеколог', 'Уролог', 'Онколог', 'Инфекционист', 'Аллерголог-иммунолог', 
+        'Психиатр', 'Психотерапевт', 'Нарколог', 'Анестезиолог-реаниматолог', 'Рентгенолог', 
+        'Врач УЗД', 'Эндоскопист', 'Патологоанатом'
+      ),
+      allowNull: true 
+    },
+    isTemporaryPassword: { type: DataTypes.BOOLEAN, defaultValue: false }
+  }, { 
+    timestamps: true 
+  });
+
+  // Настройка связей пользователя
+  User.associate = (models) => {
+    User.belongsTo(models.Clinic, { foreignKey: 'ClinicId', onDelete: 'SET NULL' });
+    User.hasOne(models.UserAddress, { foreignKey: 'UserId' });
+  };
+
+  return User;
+};

package/index.js

@@ -5,33 +5,43 @@ const chalk = require("chalk-palette");
 const logger = require("custom-color-logs").print;
 const path = require('path');
 const fs = require('fs');
-const { initDatabase } = require(path.join(__dirname, "database", "config", "db-init.js"));
+
+// Оставляем только импорт самого модуля базы данных
+const dbConfig = require(path.join(__dirname, "database", "config", "db-init.js"));
 const server = require('./server/server');
-const User = require(path.join(__dirname, "database", "models", "users.js")); 
 const bcrypt = require('bcrypt');
+
 async function init(app) {
   await chalk.animation.textShimmer("MED-CMS");
   console.log(logger.ServerMedInfo("Запуск сервера..."));
   await chalk.animation.retroLines({duration:4000, linesCount:4, offset:3});
+
   if (app && typeof app === 'function' && typeof app.handle === 'function') {
     console.log(logger.ServerMedInfo("Проверка на app пройдена успешно!"));
   } else {
     console.log(logger.ServerMedError("app не передан или повреждён!"));
     return;
   }
+
   try {
     const dbPath = path.join(__dirname, "db", "med-cms.sqlite");
     const dbDir = path.dirname(dbPath);
     if (!fs.existsSync(dbDir)){
         fs.mkdirSync(dbDir, { extended: true });
     }
-    await initDatabase(dbPath);
+    
+    // Инициализируем БД
+    await dbConfig.initDatabase(dbPath);
     console.log(logger.ServerMedInfo("База данных успешно инициализирована"));
   } catch (err) {
     console.log(logger.DatabaseError("Критическая ошибка запуска базы данных med-cms:", err));
     return;
   }
+
   try {
+    // ИСПРАВЛЕНИЕ: Достаем User из проинициализированного объекта базы данных ОНЛАЙН
+    const User = dbConfig.User; 
+
     const adminExists = await User.findOne({ where: { role: 'admin' } });
     if (!adminExists) {
       console.log(logger.ServerMedInfo("Администратор не найден. Создаю аккаунт по умолчанию..."));
@@ -44,19 +54,20 @@ async function init(app) {
         role: "admin",           
         specialty: null          
       });
-      console.log(logger.ServerMedInfo(`Аккаунт суперадмина успешно создан в SQLite!`));
-    }
- else {
+      console.log(logger.ServerMedInfo(`Аккаунт суперадмина успешно создан in SQLite!`));
+    } else {
       console.log(logger.ServerMedInfo("Администратор уже существует в базе данных."));
     }
   } catch (error) {
     console.log(logger.ServerMedError("Ошибка при автоматическом создании админа: " + error.message));
   }
+
   console.log(logger.ServerMedInfo("Подключение роутов..."));
   const rout = express.Router();
   const med = server(process.env.JWT_SECRET);
   const r_api = med.api;
   const r_web = med.web;
+
   rout.use(cookieParser());
   rout.use(express.json());
   rout.use(express.urlencoded({ extended: true }));
@@ -64,4 +75,5 @@ async function init(app) {
   rout.use("/med/api", r_api);
   app.use("/", rout);
 }
-module.exports = init;
+
+module.exports = init;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "med-cms",
-  "version": "1.0.0-beta.1",
+  "version": "1.0.0-beta.2",
   "description": "Медицинская мультитендантная CMS на Express и Sequelize (SQLite3) с системой ролей и автоматическим расчетом участков",
   "main": "index.js",
   "types": "index.d.ts",

package/server/server.js

@@ -2,18 +2,26 @@ const express = require('express');
 const path = require('path');
 const bcrypt = require('bcrypt');
 const jwt = require('jsonwebtoken');
-const User = require(path.join(__dirname, '..', 'database', 'models', 'users'));
-const Disease = require(path.join(__dirname, '..', 'database', 'models', 'diseases'));
+
+// Импортируем проинициализированный объект базы со всеми готовыми моделями
+const db = require(path.join(__dirname, '..', 'database', 'config', 'db-init.js'));
+
 const createMiddleware = require(path.join(__dirname, 'midleware'));
 const { MED_PERMISSIONS } = require(path.join(__dirname, 'permissions'));
 const AdminService = require(path.join(__dirname, '..', 'database', 'services', 'admin'));
 const DoctorService = require(path.join(__dirname, '..', 'database', 'services', 'doctor'));
 const PatientService = require(path.join(__dirname, '..', 'database', 'services', 'patient'));
+
 function createMedRouter(jwtSecret) {
   const api = express.Router();
   const web = express.Router();
+  
+  // Достаем готовые к работе модели из объекта db
+  const { User, Disease, Clinic } = db;
+
   web.use("/", express.static(path.join(__dirname, "..", "public")));
   const { verifyCookie, requireRole, checkPermission } = createMiddleware(jwtSecret);
+
   api.post('/auth/register', async (req, res) => {
     try {
       const { email, password, fullName } = req.body;
@@ -27,6 +35,7 @@ function createMedRouter(jwtSecret) {
       res.status(400).json({ success: false, error: err.message });
     }
   });
+
   api.post('/auth/login', async (req, res) => {
     try {
       const { email, password } = req.body;
@@ -50,13 +59,16 @@ function createMedRouter(jwtSecret) {
       res.status(500).json({ success: false, error: err.message });
     }
   });
+
   api.post('/auth/logout', (req, res) => {
     res.clearCookie('med_auth_token');
     res.json({ success: true, message: 'Успешный выход' });
   });
+
   web.get('/med-patient', verifyCookie, requireRole(['patient']), (req, res) => {
     res.sendFile(path.join(__dirname, '..', 'public', 'html', 'dashboard-patient.html'));
   });
+
   api.get('/patient/me', verifyCookie, async (req, res) => {
     try {
       const fullData = await PatientService.getFullMyData(req.user.id);
@@ -65,6 +77,7 @@ function createMedRouter(jwtSecret) {
       res.status(500).json({ success: false, error: err.message });
     }
   });
+
   api.post('/patient/address', verifyCookie, async (req, res) => {
     try {
       const updatedAddress = await PatientService.savePatientAddress(req.user.id, req.body);
@@ -73,9 +86,11 @@ function createMedRouter(jwtSecret) {
       res.status(400).json({ success: false, error: err.message });
     }
   });
+
   web.get('/med-doctor', verifyCookie, requireRole(['doctor']), (req, res) => {
     res.sendFile(path.join(__dirname, '..', 'public', 'html', 'dashboard-doctor.html'));
   });
+
   api.get('/doctor/schedule', verifyCookie, requireRole(['doctor']), async (req, res) => {
     try {
       const schedule = await DoctorService.getMySchedule(req.user.id);
@@ -84,6 +99,7 @@ function createMedRouter(jwtSecret) {
       res.status(500).json({ success: false, error: err.message });
     }
   });
+
   api.get('/doctor/patient-history/:id', verifyCookie, requireRole(['doctor']), async (req, res) => {
     try {
       const history = await DoctorService.getPatientHistory(req.params.id);
@@ -92,6 +108,7 @@ function createMedRouter(jwtSecret) {
       res.status(404).json({ success: false, error: err.message });
     }
   });
+
   api.post('/doctor/complete-examination', verifyCookie, requireRole(['doctor']), async (req, res) => {
     try {
       const result = await DoctorService.saveExamination(req.body);
@@ -100,12 +117,15 @@ function createMedRouter(jwtSecret) {
       res.status(400).json({ success: false, error: err.message });
     }
   });
+
   api.post('/doctor/schedule-surgery', verifyCookie, requireRole(['doctor']), checkPermission(MED_PERMISSIONS.SCHEDULE_SURGERY), (req, res) => {
     res.json({ success: true, message: 'Операция успешно добавлена в график хирургического отделения.' });
   });
+
   web.get('/med-admin', verifyCookie, requireRole(['admin']), (req, res) => {
     res.sendFile(path.join(__dirname, '..', 'public', 'html', 'dashboard-admin.html'));
   });
+
   api.post('/admin/clinics', verifyCookie, requireRole(['admin']), async (req, res) => {
     try {
       const newClinic = await AdminService.createClinic(req.body);
@@ -114,18 +134,19 @@ function createMedRouter(jwtSecret) {
       res.status(400).json({ success: false, error: err.message });
     }
   });
+
   api.post('/admin/staff', verifyCookie, requireRole(['admin']), async (req, res) => {
     try {
       if (req.body.clinicId && !req.body.ClinicId) {
         req.body.ClinicId = req.body.clinicId;
       }
-
       const staffUser = await AdminService.createStaffAccount(req.body);
       res.status(201).json({ success: true, data: staffUser });
     } catch (err) {
       res.status(400).json({ success: false, error: err.message });
     }
   });
+
   api.delete('/admin/users/:id', verifyCookie, requireRole(['admin']), async (req, res) => {
     try {
       const result = await AdminService.deleteAccount(req.params.id);
@@ -134,6 +155,7 @@ function createMedRouter(jwtSecret) {
       res.status(400).json({ success: false, error: err.message });
     }
   });
+
   api.get('/admin/stats', verifyCookie, requireRole(['admin']), async (req, res) => {
     try {
       const stats = await AdminService.getSystemStats();
@@ -142,35 +164,33 @@ function createMedRouter(jwtSecret) {
       res.status(500).json({ success: false, error: err.message });
     }
   });
+
   api.get('/admin/list-clinics', verifyCookie, requireRole(['admin']), async (req, res) => {
-  try {
-    const Clinic = require('../database/models/clinics');
-    const clinics = await Clinic.findAll({ order: [['name', 'ASC']] });
-    res.json({ success: true, data: clinics });
-  } catch (err) {
-    res.status(500).json({ success: false, error: err.message });
-  }
-});
-api.get('/admin/list-staff', verifyCookie, requireRole(['admin']), async (req, res) => {
-  try {
-    const User = require('../database/models/users');
-    const Clinic = require('../database/models/clinics');
-    const staff = await User.findAll({
-      where: { role: 'doctor' },
-      include: [{ model: Clinic, attributes: ['name'] }],
-      order: [['fullName', 'ASC']]
-    });
-    res.json({ success: true, data: staff });
-  } catch (err) {
-    res.status(500).json({ success: false, error: err.message });
-  }
-});
-  // 1. Получить список всех доступных врачей для записи (Публично для пациентов)
+    try {
+      // ИСПРАВЛЕНИЕ: берем Clinic из инстанса базы данных, а не сырой файл функции
+      const clinics = await Clinic.findAll({ order: [['name', 'ASC']] });
+      res.json({ success: true, data: clinics });
+    } catch (err) {
+      res.status(500).json({ success: false, error: err.message });
+    }
+  });
+
+  api.get('/admin/list-staff', verifyCookie, requireRole(['admin']), async (req, res) => {
+    try {
+      // ИСПРАВЛЕНИЕ: Используем проинициализированные модули для include отношений
+      const staff = await User.findAll({
+        where: { role: 'doctor' },
+        include: [{ model: Clinic, attributes: ['name'] }],
+        order: [['fullName', 'ASC']]
+      });
+      res.json({ success: true, data: staff });
+    } catch (err) {
+      res.status(500).json({ success: false, error: err.message });
+    }
+  });
+
   api.get('/patient/doctors-list', verifyCookie, requireRole(['patient']), async (req, res) => {
     try {
-      const User = require('../database/models/users');
-      const Clinic = require('../database/models/clinics');
-      
       const doctors = await User.findAll({
         where: { role: 'doctor' },
         attributes: ['id', 'fullName', 'specialty'],
@@ -182,52 +202,45 @@ api.get('/admin/list-staff', verifyCookie, requireRole(['admin']), async (req, r
     }
   });
 
-  // 2. Создать новую запись на прием (Бронирование талона)
   api.post('/patient/book', verifyCookie, requireRole(['patient']), async (req, res) => {
     try {
-      // ID пациента безопасно берем из расшифрованной HttpOnly-куки (req.user.id)
       const patientId = req.user.id;
-      
       const appointment = await PatientService.bookAppointment(patientId, req.body);
       res.status(212).json({ success: true, data: appointment });
     } catch (err) {
       res.status(400).json({ success: false, error: err.message });
     }
   });
-  // ИСПРАВЛЕНИЕ: Добавляем 'admin' в requireRole, чтобы при тесте под админом справочник подгружался!
+
   api.get('/doctor/diseases-list', verifyCookie, requireRole(['doctor', 'admin']), async (req, res) => {
     try {
-      const Disease = require('../database/models/diseases');
+      // ИСПРАВЛЕНИЕ: Используем готовую модель Disease
       const diseases = await Disease.findAll({ order: [['name', 'ASC']] });
       res.json({ success: true, data: diseases });
     } catch (err) {
       res.status(500).json({ success: false, error: err.message });
     }
   });
-  // API Смены пароля для любого авторизованного пользователя (Врач, Пациент, Админ)
+
   api.post('/auth/change-password', verifyCookie, async (req, res) => {
     try {
       const { oldPassword, newPassword } = req.body;
-      const userId = req.user.id; // Берем ID строго из HttpOnly куки
+      const userId = req.user.id;
 
       if (!oldPassword || !newPassword) {
         throw new Error('Необходимо указать старый и новый пароли');
       }
 
-      // Ищем пользователя в базе
       const user = await User.findByPk(userId);
       if (!user) throw new Error('Пользователь не найден');
 
-      // Сверяем старый пароль с хешем в БД
       const isMatch = await bcrypt.compare(oldPassword, user.password);
       if (!isMatch) {
         return res.status(400).json({ success: false, message: 'Старый пароль введен неверно' });
       }
 
-      // Хешируем новый пароль перед записью в SQLite
       const hashedNewPassword = await bcrypt.hash(newPassword, 10);
       
-      // Обновляем пароль и снимаем флаг временного пароля
       await user.update({
         password: hashedNewPassword,
         isTemporaryPassword: false
@@ -238,18 +251,14 @@ api.get('/admin/list-staff', verifyCookie, requireRole(['admin']), async (req, r
     }
   });
 
-  // Обновим также роут выгрузки расписания, чтобы он отдавал данные о вошедшем враче для шапки кабинета
   api.get('/doctor/me', verifyCookie, requireRole(['doctor']), async (req, res) => {
     try {
       const doctorData = await User.findByPk(req.user.id, { attributes: ['fullName', 'position', 'specialty'] });
       res.json({ success: true, doctor: doctorData });
-    } catch (err) {
-      res.status(500).json({ success: false, error: err.message });
-    }
-  });
-
-
-  return {web:web, api:api};
+} catch (err) {
+res.status(500).json({ success: false, error: err.message });
 }
-
-module.exports = createMedRouter;
+});
+return {web:web, api:api};
+}
+module.exports = createMedRouter;