Merge branch 'master' of ssh://85.143.175.152:222/bro-students/multy-stub

Reviewed-on: #105

package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "multi-stub",
-  "version": "1.2.0",
+  "version": "1.2.1",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "multi-stub",
-      "version": "1.2.0",
+      "version": "1.2.1",
       "license": "MIT",
       "dependencies": {
         "ai": "^4.1.13",

package.json

@@ -1,6 +1,6 @@
 {
   "name": "multi-stub",
-  "version": "1.2.0",
+  "version": "1.2.1",
   "description": "",
   "main": "index.js",
   "scripts": {

server/routers/dogsitters-finder/const.js

@@ -0,0 +1,2 @@
+exports.DSF_AUTH_USER_MODEL_NAME = 'DSF_AUTH_USER'
+exports.DSF_INTERACTION_MODEL_NAME = 'DSF_INTERACTION'

server/routers/dogsitters-finder/index.js

@@ -8,20 +8,20 @@ router.post("/auth", (request, response) => {
   const { phoneNumber, password } = request.body;
   console.log(phoneNumber, password);
   if (phoneNumber === "89999999999" || phoneNumber === "89559999999") {
-    response.send(require("../json/auth/success.json"));
+    response.send(require("./json/auth/success.json"));
   } else {
-    response.status(401).send(require("../json/auth/error.json"));
+    response.status(401).send(require("./json/auth/error.json"));
   }
 });
 
 router.post("/auth/2fa", (request, response) => {
   const { phoneNumber, code } = request.body;
   if (code === "0000" && phoneNumber === "89999999999") {
-    response.send(require("../json/2fa/dogsitter.success.json"));
+    response.send(require("./json/2fa/dogsitter.success.json"));
   } else if (code === "0000" && phoneNumber === "89559999999") {
-    response.send(require("../json/2fa/owner.success.json"));
+    response.send(require("./json/2fa/owner.success.json"));
   } else {
-    response.status(401).send(require("../json/2fa/error.json"));
+    response.status(401).send(require("./json/2fa/error.json"));
   }
 });
 
@@ -29,11 +29,11 @@ router.post("/register", (request, response) => {
   const { firstName, secondName, phoneNumber, password, role } = request.body;
   console.log(phoneNumber, password, role);
   if (phoneNumber === "89999999999" || phoneNumber === "89559999999") {
-    response.status(401).send(require("../json/register/error.json"));
+    response.status(401).send(require("./json/register/error.json"));
   } else if (role === "dogsitter") {
-    response.send(require("../json/register/dogsitter.success.json"));
+    response.send(require("./json/register/dogsitter.success.json"));
   } else {
-    response.send(require("../json/register/owner.success.json"));
+    response.send(require("./json/register/owner.success.json"));
   }
 });
 
@@ -58,9 +58,9 @@ router.get("/auth/session", (request, response) => {
     const decoded = jwt.verify(token, secretKey);
 
     if (decoded.role === "dogsitter") {
-      response.send(require("../json/role/dogsitter.success.json"));
+      response.send(require("./json/role/dogsitter.success.json"));
     } else {
-      response.send(require("../json/role/owner.success.json"));
+      response.send(require("./json/role/owner.success.json"));
     }
   } catch (e) {
     console.log("token e:", e);
@@ -68,4 +68,161 @@ router.get("/auth/session", (request, response) => {
   }
 });
 
-module.exports = router;
+
+// Проверка взаимодействия между пользователем и догситтером
+router.get("/interactions/check", (req, res) => {
+  const { owner_id, dogsitter_id } = req.query;
+
+  const usersFilePath = path.resolve(__dirname, "./json/users/users.json");
+
+  delete require.cache[require.resolve(usersFilePath)];
+  const usersFile = require(usersFilePath);
+
+  const interactions = usersFile.interactions || [];
+
+  const exists = interactions.some(
+    (interaction) =>
+      interaction.owner_id === Number(owner_id) &&
+      interaction.dogsitter_id === Number(dogsitter_id)
+  );
+
+  res.json({ exists });
+});
+
+// Добавление нового взаимодействия
+router.post("/interactions", (req, res) => {
+  const { owner_id, dogsitter_id, interaction_type } = req.body;
+
+  if (!owner_id || !dogsitter_id || !interaction_type) {
+    return res.status(400).json({ error: "Missing required fields" });
+  }
+
+  const usersFilePath = path.resolve(__dirname, "./json/users/users.json");
+
+  delete require.cache[require.resolve(usersFilePath)];
+  const usersFile = require(usersFilePath);
+
+  if (!usersFile.interactions) {
+    usersFile.interactions = [];
+  }
+
+  // Проверяем, существует ли уже такое взаимодействие
+  const exists = usersFile.interactions.some(
+    (interaction) =>
+      interaction.owner_id === Number(owner_id) &&
+      interaction.dogsitter_id === Number(dogsitter_id)
+  );
+
+  if (!exists) {
+    usersFile.interactions.push({
+      owner_id: Number(owner_id),
+      dogsitter_id: Number(dogsitter_id),
+      interaction_type,
+    });
+
+    fs.writeFileSync(
+      usersFilePath,
+      JSON.stringify(usersFile, null, 2),
+      "utf8"
+    );
+
+    console.log(
+      `Добавлено взаимодействие: owner_id=${owner_id}, dogsitter_id=${dogsitter_id}`
+    );
+  }
+
+  res.json({ success: true });
+});
+
+router.get("/dogsitter-viewing", (req, res) => {
+  const { id } = req.query;
+  console.log(`Получен запрос для dogsitter с ID: ${id}`);
+
+  const usersFile = require("./json/users/users.json");
+  const users = usersFile.data; // Извлекаем массив из свойства "data"
+
+  const user = users.find((user) => user.id === Number(id));
+
+  if (user) {
+    res.json(user); // Возвращаем найденного пользователя
+  } else {
+    res.status(404).json({ error: "User not found" }); // Если пользователь не найден
+  }
+});
+
+const fs = require('fs');
+const path = require('path');
+
+
+router.post('/dogsitter-viewing/rating/:id', (req, res) => {
+  const { id } = req.params;
+  const { rating } = req.body;
+
+  if (!rating || rating < 1 || rating > 5) {
+    return res.status(400).json({ error: 'Некорректная оценка' });
+  }
+
+  const usersFilePath = path.resolve(__dirname, "./json/users/users.json");
+
+  delete require.cache[require.resolve(usersFilePath)];
+  const usersFile = require(usersFilePath);
+  const users = usersFile.data;
+
+  const userIndex = users.findIndex(user => user.id === Number(id));
+  if (userIndex === -1) {
+    return res.status(404).json({ error: 'Догситтер не найден' });
+  }
+
+  if (!users[userIndex].ratings) {
+    users[userIndex].ratings = [];
+  }
+  users[userIndex].ratings.push(rating);
+
+  if (users[userIndex].ratings.length > 100) {
+    users[userIndex].ratings.shift();
+  }
+
+  const total = users[userIndex].ratings.reduce((sum, r) => sum + r, 0);
+  users[userIndex].rating = parseFloat((total / users[userIndex].ratings.length).toFixed(2));
+
+  fs.writeFileSync(usersFilePath, JSON.stringify({ data: users }, null, 2), 'utf8');
+
+  console.log(`Обновлен рейтинг догситтера ${id}: ${users[userIndex].rating}`);
+
+  res.json({ rating: users[userIndex].rating, ratings: users[userIndex].ratings });
+});
+
+
+router.patch('/users/:id', (req, res) => {
+  const { id } = req.params;
+  const updateData = req.body;
+
+  console.log('Полученные данные для обновления:', updateData);
+
+
+  const usersFilePath = path.resolve(__dirname, "./json/users/users.json");
+
+  delete require.cache[require.resolve(usersFilePath)];
+  const usersFile = require(usersFilePath);
+  const users = usersFile.data;
+
+  const userIndex = users.findIndex((user) => user.id === Number(id));
+  if (userIndex === -1) {
+    return res.status(404).json({ error: 'User not found' });
+  }
+
+  users[userIndex] = { ...users[userIndex], ...updateData };
+
+  fs.writeFileSync(
+    usersFilePath,
+    JSON.stringify({ data: users }, null, 2),
+    'utf8'
+  );
+
+  console.log('Обновлённые данные пользователя:', users[userIndex]);
+
+  res.json(users[userIndex]);
+});
+
+
+module.exports = router

server/routers/dogsitters-finder/json/users/users.json

@@ -1,13 +1,20 @@
-[
+{
+    "data": [
         {
             "id": 1,
-        "phone_number": 89283244141,
+            "phone_number": "89999999999",
             "first_name": "Вася",
             "second_name": "Пупкин",
             "role": "dogsitter",
-        "location": "Россия, республика Татарстан, Казань, улица Пушкина, 12",
-        "price": 1500,
-        "about_me": "Я люблю собак"
+            "location": "Россия, республика Татарстан, Казань, Пушкина, 12",
+            "price": "1500",
+            "about_me": "Я люблю собак!",
+            "rating": 5,
+            "ratings": [
+                5,
+                5
+            ],
+            "tg": "jullllllie"
         },
         {
             "id": 2,
@@ -16,12 +23,18 @@
             "second_name": "Пуськин",
             "role": "dogsitter",
             "location": "Россия, республика Татарстан, Казань, улица Абсалямова, 19",
-        "price": 1000000,
-        "about_me": "Я не люблю собак. И вообще я котоман."
+            "price": 2000,
+            "about_me": "Я не люблю собак. И вообще я котоман.",
+            "rating": 4,
+            "ratings": [
+                4,
+                4
+            ],
+            "tg": "vanya006"
         },
         {
             "id": 3,
-        "phone_number": 89872855893,
+            "phone_number": 89559999999,
             "first_name": "Гадий",
             "second_name": "Петрович",
             "role": "owner"
@@ -33,7 +46,24 @@
             "second_name": "Максим",
             "role": "dogsitter",
             "location": "Россия, республика Татарстан, Казань, проспект Ямашева, 83",
-        "price": 1000000,
-        "about_me": "Миллион алых роз"
+            "price": 1750,
+            "about_me": "Миллион алых роз",
+            "rating": 4.5,
+            "ratings": [
+                4,
+                5
+            ],
+            "tg": "maks100500"
+        }
+    ],
+    "interactions": [
+        {
+            "owner_id": 3,
+            "dogsitter_id": 4
+        },
+        {
+            "owner_id": 1,
+            "dogsitter_id": 2
         }
     ]
+}

server/routers/dogsitters-finder/model/interaction.js

@@ -0,0 +1,24 @@
+const { Schema, model } = require("mongoose");
+
+const { DSF_AUTH_USER_MODEL_NAME, DSF_INTERACTION_MODEL_NAME } = require("../../const");
+
+const interactionSchema = new Schema({
+  owner_id: {
+    type: Schema.Types.ObjectId,
+    ref: DSF_AUTH_USER_MODEL_NAME,
+    required: true
+  },
+  dogsitter_id: {
+    type: Schema.Types.ObjectId,
+    ref: DSF_AUTH_USER_MODEL_NAME,
+    required: true
+  },
+  timestamp: {
+    type: Date,
+    default: Date.now
+  }
+});
+
+interactionSchema.index({ owner_id: 1, dogsitter_id: 1 });
+
+module.exports.Interaction = model(DSF_INTERACTION_MODEL_NAME, interactionSchema);

server/routers/dogsitters-finder/model/user.js

@@ -0,0 +1,83 @@
+const { Schema, model } = require("mongoose");
+
+const { DSF_AUTH_USER_MODEL_NAME } = require("../../const");
+
+const userSchema = new Schema({
+  phone_number: {
+    type: String,
+    required: true,
+    unique: true,
+    match: /^\+?\d{10,15}$/
+  },
+  first_name: {
+    type: String,
+    required: true,
+    trim: true
+  },
+  second_name: {
+    type: String,
+    required: true,
+    trim: true
+  },
+  role: {
+    type: String,
+    enum: ["dogsitter", "owner"],
+    required: true
+  },
+  location: {
+    type: String,
+    required: function() {
+      return this.role === "dogsitter";
+    }
+  },
+  price: {
+    type: Number,
+    min: 0,
+    required: function() {
+      return this.role === "dogsitter";
+    }
+  },
+  about_me: {
+    type: String,
+    maxlength: 500
+  },
+  rating: {
+    type: Number,
+    min: 0,
+    max: 5,
+    default: 0
+  },
+  ratings: {
+    type: [Number],
+    default: [],
+    validate: {
+      validator: function(arr) {
+        return arr.every(v => v >= 0 && v <= 5);
+      },
+      message: "Рейтинг должен быть в диапазоне от 0 до 5!"
+    }
+  },
+  tg: {
+    type: String,
+    match: /^[a-zA-Z0-9_]{5,32}$/
+  },
+  created: {
+    type: Date,
+    default: Date.now
+  }
+});
+
+userSchema.virtual("id").get(function() {
+  return this._id.toHexString();
+});
+
+userSchema.set("toJSON", {
+  virtuals: true,
+  versionKey: false,
+  transform: function(doc, ret) {
+    delete ret._id;
+    delete ret.__v;
+  }
+});
+
+module.exports.User = model(DSF_AUTH_USER_MODEL_NAME, userSchema);

server/routers/dogsitters-finder/routes.js

@@ -0,0 +1,149 @@
+const { Router } = require('express')
+const { expressjwt } = require('express-jwt')
+
+const { getAnswer } = require('../../utils/common')
+const { User, Interaction } = require('./model')
+const { TOKEN_KEY } = require('./const')
+const { requiredValidate } = require('./utils')
+
+const router = Router()
+
+// Получение списка пользователей
+router.get('/users', async (req, res) => {
+
+  const users = await User.find()
+    .select('-__v -ratings -phone_number')
+    .lean()
+  
+  console.log('get users successfull')
+
+  res.send(getAnswer(null, users))
+})
+
+// Получение конкретного пользователя
+router.get('/dogsitter-viewing', async (req, res) => {
+  const { userId } = req.params
+
+  const user = await User.findById(userId)
+    .select('-__v -ratings')
+    .lean()
+
+  if (!user) {
+    return res.status(404).send(getAnswer(new Error('Пользователь не найден')))
+  }
+
+  res.send(getAnswer(null, user))
+})
+
+router.use(expressjwt({ secret: TOKEN_KEY, algorithms: ['HS256'] }))
+
+// Добавление оценки пользователю
+router.post('/dogsitter-viewing/rating', requiredValidate('value'), async (req, res) => {
+  const { userId } = req.params
+  const { value } = req.body
+  const authUserId = req.auth.id
+
+  try {
+    const user = await User.findById(userId)
+    if (!user) throw new Error('Пользователь не найден')
+    if (user.role !== 'dogsitter') throw new Error('Нельзя оценивать этого пользователя')
+    if (user.id === authUserId) throw new Error('Нельзя оценивать самого себя')
+
+    user.ratings.push(Number(value))
+    user.rating = user.ratings.reduce((a, b) => a + b, 0) / user.ratings.length
+
+    const updatedUser = await user.save()
+    
+    res.send(getAnswer(null, {
+      id: updatedUser.id,
+      rating: updatedUser.rating.toFixed(1),
+      totalRatings: updatedUser.ratings.length
+    }))
+
+  } catch (error) {
+    res.status(400).send(getAnswer(error))
+  }
+})
+
+// Обновление информации пользователя
+router.patch('/users', async (req, res) => {
+  const { userId } = req.params
+  const updates = req.body
+
+  try {
+    const user = await User.findByIdAndUpdate(userId, updates, { new: true })
+      .select('-__v -ratings')
+    
+    if (!user) throw new Error('Пользователь не найден')
+    res.send(getAnswer(null, user))
+
+  } catch (error) {
+    res.status(400).send(getAnswer(error))
+  }
+})
+
+// Создание объекта взаимодействия
+router.post('/interactions', 
+  expressjwt({ secret: TOKEN_KEY, algorithms: ['HS256'] }),
+  requiredValidate('dogsitter_id'),
+  async (req, res) => {
+    try {
+      const { dogsitter_id } = req.body
+      const owner_id = req.auth.id // ID из JWT токена
+
+      // Проверка существования пользователей
+      const [owner, dogsitter] = await Promise.all([
+        User.findById(owner_id),
+        User.findById(dogsitter_id)
+      ])
+
+      if (!owner || owner.role !== 'owner') {
+        throw new Error('Владелец не найден или имеет неверную роль')
+      }
+
+      if (!dogsitter || dogsitter.role !== 'dogsitter') {
+        throw new Error('Догситтер не найден или имеет неверную роль')
+      }
+
+      // Создание взаимодействия
+      const interaction = await Interaction.create({
+        owner_id,
+        dogsitter_id
+      })
+
+      res.send(getAnswer(null, {
+        id: interaction.id,
+        timestamp: interaction.timestamp
+      }))
+
+    } catch (error) {
+      res.status(400).send(getAnswer(error))
+    }
+  }
+)
+
+router.get('/interactions/check', async (req, res) => {
+  const { owner_id, dogsitter_id } = req.query;
+
+  if (!owner_id || !dogsitter_id) {
+    return res.status(400).send(getAnswer('Missing owner_id or dogsitter_id'));
+  }
+
+  try {
+    // Поиск взаимодействий по owner_id и dogsitter_id
+    const interactions = await Interaction.find({ owner_id, dogsitter_id })
+      .select('-__v') // Выбираем только нужные поля
+      .lean();
+
+    if (interactions.length === 0) {
+      return res.status(404).send(getAnswer('No interactions found'));
+    }
+
+    res.send(getAnswer(null, interactions));
+  } catch (error) {
+    console.error('Error checking interactions:', error);
+    res.status(500).send(getAnswer('Internal Server Error'));
+  }
+});
+
+module.exports = router

server/routers/gamehub/index.js

@@ -8,6 +8,10 @@ router.get("/update-like", (request, response) => {
   response.send(require("./json/gamepage/success.json"));
 });
 
+router.get("/add-to-cart", (request, response) => {
+  response.send(require("./json/home-page-data/games-in-cart.json"));
+});
+
 router.get("/categories", (request, response) => {
   response.send(require("./json/home-page-data/all-games.json"));
 });
@@ -16,18 +20,32 @@ router.get("/favourites", (request, response) => {
   response.send(require("./json/home-page-data/all-games.json"));
 });
 
+// router.get("/shopping-cart", (request, response) => {
+//   response.send(require("./json/shopping-cart/success.json"));
+// });
+
 router.get("/shopping-cart", (request, response) => {
-  response.send(require("./json/shopping-cart/success.json"));
+  response.send(require("./json/home-page-data/games-in-cart.json"));
 });
 
-router.get("/home", (request, response) => {
-  response.send(require("./json/home-page-data/success.json"));
+// Добавляем поддержку разных ответов для /home
+router.get("/home", (req, res) => {
+  if (stubs.home === "success") {
+    res.send(require("./json/home-page-data/success.json"));
+  } else if (stubs.home === "empty") {
+    res.send({ data: [] }); // Отправляем пустой массив
+  } else {
+    res.status(500).json({ success: false, message: "Server error" });
+  }
 });
 
 router.get("/all-games", (request, response) => {
   response.send(require("./json/home-page-data/all-games.json"));
 });
 
+const stubs = {
+  home: "success",
+};
 
 // // Маршрут для обновления лайков
 // router.post("/update-like", (request, response) => {
@@ -42,7 +60,6 @@ router.get("/all-games", (request, response) => {
 //   });
 // });
 
-
 const fs = require("fs").promises;
 const path = require("path");
 
@@ -92,5 +109,149 @@ router.post("/update-like", async (req, res) => {
   }
 });
 
+// Путь к JSON-файлу с корзиной
+const cartFilePath = path.join(
+  __dirname,
+  "./json/home-page-data/games-in-cart.json"
+);
+
+// Функция для чтения JSON-файла
+async function readCart() {
+  const data = await fs.readFile(cartFilePath, "utf-8");
+  return JSON.parse(data);
+}
+
+// Функция для записи в JSON-файл
+async function writeCart(data) {
+  await fs.writeFile(cartFilePath, JSON.stringify(data, null, 2), "utf-8");
+}
+
+// Маршрут для добавления/удаления товара в корзине
+router.post("/add-to-cart", async (req, res) => {
+  const { id, action } = req.body;
+
+  // Проверка наличия id и action
+  if (id === undefined || action === undefined) {
+    return res
+      .status(400)
+      .json({ success: false, message: "Invalid id or action" });
+  }
+
+  try {
+    const cartData = await readCart();
+    let ids = cartData.data.ids;
+
+    if (action === "add") {
+      // Если action "add", добавляем товар, если его нет в корзине
+      if (!ids?.includes(id)) {
+        ids.push(id);
+      }
+    } else if (action === "remove") {
+      // Если action "remove", удаляем товар, если он есть в корзине
+      if (ids?.includes(id)) {
+        ids = ids.filter((item) => item !== id);
+      }
+    } else {
+      // Если action невалиден
+      return res
+        .status(400)
+        .json({ success: false, message: "Invalid action" });
+    }
+
+    // Записываем обновленные данные обратно в файл
+    cartData.data.ids = ids;
+    await writeCart(cartData);
+
+    res.status(200).json({
+      success: true,
+      message: "Cart updated successfully",
+      data: cartData.data, // Возвращаем обновленные данные
+    });
+  } catch (error) {
+    console.error("Error updating cart:", error);
+    res.status(500).json({ success: false, message: "Server error" });
+  }
+});
 
 module.exports = router;
+
+const createElement = (key, value, buttonTitle, basePath) => `
+    <label>
+        <input name="${key}" type="radio" ${
+  stubs[key] === value ? "checked" : ""
+} onclick="fetch('${basePath}/admin/set/${key}/${value}')"/>
+        ${buttonTitle || value}
+    </label>
+`;
+
+router.get("/admin/home", (request, response) => {
+  const basePath = request.baseUrl; // Получаем базовый путь маршрутизатора
+  response.send(`
+        <div>
+            <fieldset>
+                <legend>Настройка данных для /home</legend>
+                ${createElement("home", "success", "Отдать успешный ответ", basePath)}
+                ${createElement("home", "empty", "Отдать пустой массив", basePath)}
+                ${createElement("home", "error", "Отдать ошибку", basePath)}
+            </fieldset>
+        </div>    
+    `);
+});
+
+router.get("/admin/game-page", (request, response) => {
+  response.send(`
+        <div>
+            <fieldset>
+                <legend>Настройка данных для /game-page</legend>
+                ${createElement(
+                  "game-page",
+                  "success",
+                  "Отдать успешный ответ"
+                )}
+                ${createElement("game-page", "empty", "Отдать пустой массив")}
+                ${createElement("game-page", "error", "Отдать ошибку")}
+
+            </fieldset>
+        </div>    
+    `);
+});
+
+router.get("/admin/categories", (request, response) => {
+  response.send(`
+        <div>
+            <fieldset>
+                <legend>Настройка данных для /categories</legend>
+                ${createElement(
+                  "categories",
+                  "success",
+                  "Отдать успешный ответ"
+                )}
+                ${createElement("categories", "empty", "Отдать пустой массив")}
+                ${createElement("categories", "error", "Отдать ошибку")}
+                </fieldset>
+        </div>    
+    `);
+});
+
+router.get("/admin/favourites", (request, response) => {
+  response.send(`
+        <div>
+            <fieldset>
+                <legend>Настройка данных для /favourites</legend>
+                ${createElement(
+                  "favourites",
+                  "success",
+                  "Отдать успешный ответ"
+                )}
+                ${createElement("favourites", "empty", "Отдать пустой массив")}
+                ${createElement("favourites", "error", "Отдать ошибку")}
+            </fieldset>
+        </div>    
+    `);
+});
+
+router.get("/admin/set/:key/:value", (request, response) => {
+  const { key, value } = request.params;
+  stubs[key] = value;
+  response.send("Настройки обновлены!");
+});

server/routers/gamehub/json/gamepage/success.json

@@ -5,28 +5,28 @@
       {
         "username": "Пользователь1",
         "text": "Текст комментария 1",
-        "likes": 11,
+        "likes": 13,
         "rating": 8,
         "date": "2025-03-01T10:00:00Z"
       },
       {
         "username": "Пользователь2",
         "text": "Текст комментария 2",
-        "likes": 7,
+        "likes": 10,
         "rating": 7,
         "date": "2025-01-01T10:00:00Z"
       },
       {
         "username": "Пользователь3",
         "text": "Текст комментария 3",
-        "likes": 2,
+        "likes": 4,
         "rating": 3,
         "date": "2025-02-01T10:00:00Z"
       },
       {
         "username": "Пользователь4",
         "text": "Текст комментария 4",
-        "likes": 15,
+        "likes": 18,
         "rating": 2,
         "date": "2025-12-01T10:00:00Z"
       }

server/routers/gamehub/json/home-page-data/success.json

@@ -105,22 +105,26 @@
       {
         "image": "news1",
         "text": "Разработчики Delta Force: Hawk Ops представили крупномасштабный режим Havoc Warfare",
-        "imgPath": "img_news_1"
+        "imgPath": "img_news_1",
+        "link": "https://gamemag.ru/news/185583/delta-force-hawk-ops-gameplay-showcase-havoc-warfare"
       },
       {
         "image": "news2",
         "text": "Первый трейлер Assassin’s Creed Shadows — с темнокожим самураем в феодальной Японии",
-        "imgPath": "img_news_2"
+        "imgPath": "img_news_2",
+        "link": "https://stopgame.ru/newsdata/62686/pervyy_trailer_assassin_s_creed_shadows_s_temnokozhim_samuraem_v_feodalnoy_yaponii"
       },
       {
         "image": "news3",
         "text": "Призрак Цусимы» вышел на ПК — и уже ставит рекорды для Sony",
-        "imgPath": "img_news_3"
+        "imgPath": "img_news_3",
+        "link": "https://stopgame.ru/newsdata/62706/prizrak_cusimy_vyshel_na_pk_i_uzhe_stavit_rekordy_dlya_sony"
       },
       {
         "image": "news4",
-        "text": "Авторы Skull and Bones расширяют планы на второй сезо",
-        "imgPath": "img_news_4"
+        "text": "Авторы Skull and Bones расширяют планы на второй сезон",
+        "imgPath": "img_news_4",
+        "link": "https://stopgame.ru/newsdata/62711/avtory_skull_and_bones_rasshiryayut_plany_na_vtoroy_sezon"
       }
     ]
   }

server/routers/kfu-m-24-1/eng-it-lean/gigachat/gigachat.js

@@ -607,8 +607,7 @@ function createGigachat(options = {}) {
 }
 var gigachat = createGigachat();
 // Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
+module.exports = {
   createGigachat,
   gigachat
-});
-//# sourceMappingURL=index.js.map
+}

server/routers/kfu-m-24-1/eng-it-lean/gigachat/index.js

@@ -84,7 +84,7 @@ router.use(async (req, res, next) => {
       process.env.GIGACHAT_ACCESS_TOKEN = json.access_token;
       process.env.GIGACHAT_EXPIRES_AT = json.expires_at;
       console.log(JSON.stringify(response.data));
-    } catch {
+    } catch (error) {
       console.log(error);
     }
   }

server/routers/todo/index.js

@@ -5,9 +5,11 @@ const router = Router()
 const todoRouter = require('./routes')
 const authRouter = require('./auth')
 const commentRouter = require('./comment')
+const navRouter = require('./nav')
 
 router.use('/auth', authRouter)
 router.use('/comment', commentRouter)
+router.use('/nav', navRouter)
 
 router.use(todoRouter)
 

server/routers/todo/nav/index.js

@@ -0,0 +1,51 @@
+const router = require("express").Router();
+
+router.get("/users", (req, res) => {
+  res.send({
+    success: false,
+    body: [
+      {
+        id: "some-user-id",
+        name: "alexandr",
+        age: 38,
+        surname: null,
+        email: null,
+        rated: 4,
+        avatar:
+          "https://www.gravatar.com/avatar/6529e885535ef67a3fad810ad71167c2c03f79480936e9b3a714731753cbb47e?d=robohash",
+        friends: [
+          {
+            id: "2",
+            name: "not alexandr",
+            surname: null,
+            email: null,
+            rated: 2,
+            avatar: "https://www.gravatar.com/avatar/6e?d=robohash",
+          },
+        ],
+      },
+      {
+        id: "2",
+        name: "not alexandr",
+        surname: null,
+        email: null,
+        age: 24,
+        rated: 5,
+        avatar: "https://www.gravatar.com/avatar/6e?d=robohash",
+        friends: [
+          {
+            id: "some-user-id",
+            name: "alexandr",
+            surname: null,
+            email: null,
+            rated: 3,
+            avatar:
+              "https://www.gravatar.com/avatar/6529e885535ef67a3fad810ad71167c2c03f79480936e9b3a714731753cbb47e?d=robohash",
+          },
+        ],
+      },
+    ],
+  })
+})
+
+module.exports = router