@mashka818/exam-de-template 1.0.0

package/exam-project/server/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "exam-template-server",
+  "type": "module",
+  "scripts": {
+    "dev": "node --watch index.js",
+    "start": "node index.js",
+    "db:init": "node db/init.js"
+  },
+  "dependencies": {
+    "bcryptjs": "^3.0.2",
+    "cors": "^2.8.5",
+    "dotenv": "^16.5.0",
+    "express": "^5.1.0",
+    "jsonwebtoken": "^9.0.2",
+    "pg": "^8.16.0"
+  }
+}

package/exam-project/server/routes/admin.js

@@ -0,0 +1,76 @@
+
+import { Router } from 'express';
+import { pool } from '../db/pool.js';
+import { authRequired, adminRequired } from '../middleware/auth.js';
+
+const router = Router();
+
+const ALLOWED_STATUSES = ['in_progress', 'completed', 'cancelled'];
+
+// GET /api/admin/requests — все заявки для панели администратора
+router.get('/requests', authRequired, adminRequired, async (_req, res) => {
+  try {
+    const { rows } = await pool.query(
+      `SELECT r.*, st.name AS service_name, u.full_name AS user_full_name,
+              u.phone AS user_phone, u.email AS user_email
+       FROM requests r
+       LEFT JOIN service_types st ON st.id = r.service_type_id
+       JOIN users u ON u.id = r.user_id
+       ORDER BY r.created_at DESC`
+    );
+    res.json(
+      rows.map((row) => ({
+        id: row.id,
+        userFullName: row.user_full_name,
+        userPhone: row.user_phone,
+        userEmail: row.user_email,
+        address: row.address,
+        contactPhone: row.contact_phone,
+        serviceName: row.service_name || row.custom_service,
+        scheduledAt: row.scheduled_at,
+        paymentType: row.payment_type,
+        paymentLabel: row.payment_type === 'cash' ? 'Наличные' : 'Банковская карта',
+        status: row.status,
+        statusLabel:
+          { new: 'Новая', in_progress: 'В работе', completed: 'Выполнено', cancelled: 'Отменено' }[
+            row.status
+          ] || row.status,
+        cancelReason: row.cancel_reason,
+        createdAt: row.created_at,
+      }))
+    );
+  } catch (err) {
+    console.error(err);
+    res.status(500).json({ message: 'Ошибка сервера' });
+  }
+});
+
+// PATCH /api/admin/requests/:id/status — смена статуса админом
+router.patch('/requests/:id/status', authRequired, adminRequired, async (req, res) => {
+  const { status, cancelReason } = req.body;
+  const id = Number(req.params.id);
+
+  if (!ALLOWED_STATUSES.includes(status)) {
+    return res.status(400).json({ message: 'Недопустимый статус' });
+  }
+  if (status === 'cancelled' && !cancelReason?.trim()) {
+    return res.status(400).json({ message: 'Укажите причину отмены' });
+  }
+
+  try {
+    const { rows } = await pool.query(
+      `UPDATE requests
+       SET status = $1, cancel_reason = $2
+       WHERE id = $3
+       RETURNING *`,
+      [status, status === 'cancelled' ? cancelReason.trim() : null, id]
+    );
+    if (!rows[0]) return res.status(404).json({ message: 'Заявка не найдена' });
+    res.json({ ok: true });
+  } catch (err) {
+    console.error(err);
+    res.status(500).json({ message: 'Ошибка сервера' });
+  }
+});
+
+export default router;

package/exam-project/server/routes/auth.js

@@ -0,0 +1,109 @@
+
+import { Router } from 'express';
+import bcrypt from 'bcryptjs';
+import jwt from 'jsonwebtoken';
+import { pool } from '../db/pool.js';
+import { validateRegistration } from '../utils/validation.js';
+
+const router = Router();
+
+// POST /api/auth/register — регистрация заказчика
+router.post('/register', async (req, res) => {
+  const { login, password, fullName, phone, email } = req.body;
+  const errors = validateRegistration({ login, password, fullName, phone, email });
+  if (Object.keys(errors).length) {
+    return res.status(400).json({ errors });
+  }
+
+  try {
+    const exists = await pool.query('SELECT id FROM users WHERE login = $1', [login.trim()]);
+    if (exists.rows.length) {
+      return res.status(400).json({ errors: { login: 'Логин уже занят' } });
+    }
+
+    const passwordHash = await bcrypt.hash(password, 10);
+    const result = await pool.query(
+      `INSERT INTO users (login, password_hash, full_name, phone, email)
+       VALUES ($1, $2, $3, $4, $5)
+       RETURNING id, login, full_name, phone, email, role`,
+      [login.trim(), passwordHash, fullName.trim(), phone.trim(), email.trim()]
+    );
+
+    const user = result.rows[0];
+    const token = signToken(user);
+    res.status(201).json({ user: mapUser(user), token });
+  } catch (err) {
+    console.error(err);
+    res.status(500).json({ message: 'Ошибка сервера' });
+  }
+});
+
+// POST /api/auth/login — вход (и обычный пользователь, и adminka)
+router.post('/login', async (req, res) => {
+  const { login, password } = req.body;
+  if (!login?.trim() || !password) {
+    return res.status(400).json({ message: 'Введите логин и пароль' });
+  }
+
+  try {
+    const result = await pool.query(
+      'SELECT id, login, password_hash, full_name, phone, email, role FROM users WHERE login = $1',
+      [login.trim()]
+    );
+    const user = result.rows[0];
+    if (!user) {
+      return res.status(401).json({ message: 'Неверный логин или пароль' });
+    }
+
+    const ok = await bcrypt.compare(password, user.password_hash);
+    if (!ok) {
+      return res.status(401).json({ message: 'Неверный логин или пароль' });
+    }
+
+    const token = signToken(user);
+    res.json({ user: mapUser(user), token });
+  } catch (err) {
+    console.error(err);
+    res.status(500).json({ message: 'Ошибка сервера' });
+  }
+});
+
+// GET /api/auth/me — текущий пользователь по токену
+router.get('/me', async (req, res) => {
+  const header = req.headers.authorization;
+  if (!header?.startsWith('Bearer ')) {
+    return res.status(401).json({ message: 'Не авторизован' });
+  }
+  try {
+    const payload = jwt.verify(header.slice(7), process.env.JWT_SECRET);
+    const result = await pool.query(
+      'SELECT id, login, full_name, phone, email, role FROM users WHERE id = $1',
+      [payload.id]
+    );
+    if (!result.rows[0]) return res.status(401).json({ message: 'Пользователь не найден' });
+    res.json({ user: mapUser(result.rows[0]) });
+  } catch {
+    res.status(401).json({ message: 'Недействительный токен' });
+  }
+});
+
+function signToken(user) {
+  return jwt.sign(
+    { id: user.id, login: user.login, role: user.role },
+    process.env.JWT_SECRET,
+    { expiresIn: '24h' }
+  );
+}
+
+function mapUser(row) {
+  return {
+    id: row.id,
+    login: row.login,
+    fullName: row.full_name,
+    phone: row.phone,
+    email: row.email,
+    role: row.role,
+  };
+}
+
+export default router;

package/exam-project/server/routes/requests.js

@@ -0,0 +1,99 @@
+
+import { Router } from 'express';
+import { pool } from '../db/pool.js';
+import { authRequired } from '../middleware/auth.js';
+import { validateRequest } from '../utils/validation.js';
+
+const router = Router();
+
+const STATUS_LABELS = {
+  new: 'Новая',
+  in_progress: 'В работе',
+  completed: 'Выполнено',
+  cancelled: 'Отменено',
+};
+
+// GET /api/requests/mine — история заявок текущего пользователя
+router.get('/mine', authRequired, async (req, res) => {
+  try {
+    const { rows } = await pool.query(
+      `SELECT r.*, st.name AS service_name, u.full_name AS user_full_name
+       FROM requests r
+       LEFT JOIN service_types st ON st.id = r.service_type_id
+       JOIN users u ON u.id = r.user_id
+       WHERE r.user_id = $1
+       ORDER BY r.created_at DESC`,
+      [req.user.id]
+    );
+    res.json(rows.map(mapRequest));
+  } catch (err) {
+    console.error(err);
+    res.status(500).json({ message: 'Ошибка сервера' });
+  }
+});
+
+// POST /api/requests — новая заявка
+router.post('/', authRequired, async (req, res) => {
+  if (req.user.role === 'admin') {
+    return res.status(403).json({ message: 'Администратор не создаёт заявки через этот endpoint' });
+  }
+
+  const body = {
+    address: req.body.address,
+    contactPhone: req.body.contactPhone,
+    scheduledAt: req.body.scheduledAt,
+    paymentType: req.body.paymentType,
+    serviceTypeId: req.body.serviceTypeId,
+    isCustomService: req.body.isCustomService,
+    customService: req.body.customService,
+  };
+
+  const errors = validateRequest(body);
+  if (Object.keys(errors).length) {
+    return res.status(400).json({ errors });
+  }
+
+  try {
+    const { rows } = await pool.query(
+      `INSERT INTO requests (
+         user_id, address, contact_phone, service_type_id, custom_service,
+         scheduled_at, payment_type, status
+       ) VALUES ($1, $2, $3, $4, $5, $6, $7, 'new')
+       RETURNING *`,
+      [
+        req.user.id,
+        body.address.trim(),
+        body.contactPhone.trim(),
+        body.isCustomService ? null : Number(body.serviceTypeId),
+        body.isCustomService ? body.customService.trim() : null,
+        body.scheduledAt,
+        body.paymentType,
+      ]
+    );
+    res.status(201).json(mapRequest(rows[0]));
+  } catch (err) {
+    console.error(err);
+    res.status(500).json({ message: 'Ошибка сервера' });
+  }
+});
+
+function mapRequest(row) {
+  return {
+    id: row.id,
+    userId: row.user_id,
+    userFullName: row.user_full_name,
+    address: row.address,
+    contactPhone: row.contact_phone,
+    serviceName: row.service_name || row.custom_service,
+    customService: row.custom_service,
+    scheduledAt: row.scheduled_at,
+    paymentType: row.payment_type,
+    paymentLabel: row.payment_type === 'cash' ? 'Наличные' : 'Банковская карта',
+    status: row.status,
+    statusLabel: STATUS_LABELS[row.status] || row.status,
+    cancelReason: row.cancel_reason,
+    createdAt: row.created_at,
+  };
+}
+
+export default router;

package/exam-project/server/routes/services.js

@@ -0,0 +1,18 @@
+
+import { Router } from 'express';
+import { pool } from '../db/pool.js';
+
+const router = Router();
+
+// GET /api/services — список видов услуг для select на форме заявки
+router.get('/', async (_req, res) => {
+  try {
+    const { rows } = await pool.query('SELECT id, name FROM service_types ORDER BY id');
+    res.json(rows);
+  } catch (err) {
+    console.error(err);
+    res.status(500).json({ message: 'Ошибка сервера' });
+  }
+});
+
+export default router;

package/exam-project/server/utils/validation.js

@@ -0,0 +1,63 @@
+
+
+/** Формат телефона из задания — синхронизировать с formatPhoneInput на фронте */
+export const PHONE_REGEX = /^\+7\(\d{3}\)-\d{3}-\d{2}-\d{2}$/;
+export const EMAIL_REGEX = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+export const FIO_REGEX = /^[А-Яа-яЁё\s-]+$/;
+
+/** POST /api/auth/register */
+export function validateRegistration({ login, password, fullName, phone, email }) {
+  const errors = {};
+
+  if (!login?.trim()) errors.login = 'Логин обязателен';
+  else if (login.trim().length < 3) errors.login = 'Логин не короче 3 символов';
+
+  if (!password) errors.password = 'Пароль обязателен';
+  else if (password.length < 6) errors.password = 'Пароль не менее 6 символов';
+
+  if (!fullName?.trim()) errors.fullName = 'ФИО обязательно';
+  else if (!FIO_REGEX.test(fullName.trim())) errors.fullName = 'ФИО: только кириллица и пробелы';
+
+  if (!phone?.trim()) errors.phone = 'Телефон обязателен';
+  else if (!PHONE_REGEX.test(phone.trim())) errors.phone = 'Формат: +7(XXX)-XXX-XX-XX';
+
+  if (!email?.trim()) errors.email = 'Email обязателен';
+  else if (!EMAIL_REGEX.test(email.trim())) errors.email = 'Некорректный email';
+
+  return errors;
+}
+
+/** POST /api/requests */
+export function validateRequest(body) {
+  const errors = {};
+  const {
+    address,
+    contactPhone,
+    scheduledAt,
+    paymentType,
+    serviceTypeId,
+    isCustomService,
+    customService,
+  } = body;
+
+  if (!address?.trim()) errors.address = 'Адрес обязателен';
+  if (!contactPhone?.trim()) errors.contactPhone = 'Контактный телефон обязателен';
+  else if (!PHONE_REGEX.test(contactPhone.trim()))
+    errors.contactPhone = 'Формат: +7(XXX)-XXX-XX-XX';
+
+  if (!scheduledAt) errors.scheduledAt = 'Дата и время обязательны';
+  else if (new Date(scheduledAt) <= new Date())
+    errors.scheduledAt = 'Дата должна быть в будущем';
+
+  if (!paymentType) errors.paymentType = 'Укажите способ оплаты';
+  else if (!['cash', 'card'].includes(paymentType))
+    errors.paymentType = 'Некорректный способ оплаты';
+
+  if (isCustomService) {
+    if (!customService?.trim()) errors.customService = 'Опишите иную услугу';
+  } else if (!serviceTypeId) {
+    errors.serviceTypeId = 'Выберите вид услуги';
+  }
+
+  return errors;
+}

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "@mashka818/exam-de-template",
+  "version": "1.0.0",
+  "description": "Шаблон ДЭ: exam-project + exam-guides. Экзамен: npx @mashka818/exam-de-template init",
+  "license": "UNLICENSED",
+  "type": "module",
+  "publishConfig": {
+    "access": "public"
+  },
+  "bin": {
+    "exam-de-init": "./scripts/init-project.js"
+  },
+  "files": [
+    "exam-project",
+    "exam-guides",
+    "scripts"
+  ],
+  "keywords": [
+    "demo-exam",
+    "de",
+    "react",
+    "express",
+    "postgresql"
+  ]
+}

package/scripts/init-project.js

@@ -0,0 +1,86 @@
+#!/usr/bin/env node
+/**
+ * Экзамен: создать exam-project + exam-guides в текущей папке.
+ * npx @mashka818/exam-de-template@1.0.0 init
+ */
+import { execSync } from 'child_process';
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const PACKAGE_ROOT = path.resolve(__dirname, '..');
+
+const SKIP_DIRS = new Set(['node_modules', '.git', 'dist', '.pack-tmp']);
+
+function copyTree(src, dest) {
+  if (!fs.existsSync(src)) return;
+  fs.mkdirSync(dest, { recursive: true });
+  for (const entry of fs.readdirSync(src, { withFileTypes: true })) {
+    if (SKIP_DIRS.has(entry.name)) continue;
+    const s = path.join(src, entry.name);
+    const d = path.join(dest, entry.name);
+    if (entry.isDirectory()) copyTree(s, d);
+    else {
+      if (entry.name === '.env' && s.replace(/\\/g, '/').includes('/server/')) continue;
+      fs.mkdirSync(path.dirname(d), { recursive: true });
+      fs.copyFileSync(s, d);
+    }
+  }
+}
+
+const examRoot = process.argv.includes('--here')
+  ? process.cwd()
+  : process.argv[2]
+    ? path.resolve(process.argv[2])
+    : process.cwd();
+
+const skipInstall = process.argv.includes('--no-install');
+
+const srcProject = path.join(PACKAGE_ROOT, 'exam-project');
+const srcGuides = path.join(PACKAGE_ROOT, 'exam-guides');
+const destProject = path.join(examRoot, 'exam-project');
+const destGuides = path.join(examRoot, 'exam-guides');
+
+console.log('\n=== exam-de-init ===\n');
+console.log(`Папка экзамена: ${examRoot}\n`);
+
+if (!fs.existsSync(srcProject)) {
+  console.error('В пакете нет exam-project/. Обновите npm publish.');
+  process.exit(1);
+}
+
+if (fs.existsSync(destProject) && !process.argv.includes('--force')) {
+  console.log('Уже есть exam-project/. Добавьте --force для перезаписи.');
+  process.exit(1);
+}
+
+console.log('Копирую exam-project/ …');
+if (fs.existsSync(destProject)) fs.rmSync(destProject, { recursive: true, force: true });
+copyTree(srcProject, destProject);
+
+if (fs.existsSync(srcGuides)) {
+  console.log('Копирую exam-guides/ …');
+  if (fs.existsSync(destGuides)) fs.rmSync(destGuides, { recursive: true, force: true });
+  copyTree(srcGuides, destGuides);
+} else {
+  console.warn('В пакете нет exam-guides/ — только чистый проект.');
+}
+
+if (skipInstall) {
+  console.log('\nГотово (--no-install).\n');
+  process.exit(0);
+}
+
+console.log('\nУстановка зависимостей в exam-project/ …\n');
+execSync('npm install', { cwd: destProject, stdio: 'inherit' });
+execSync('npm run install:all', { cwd: destProject, stdio: 'inherit' });
+
+console.log('\n=== Готово ===\n');
+console.log('  exam-project/  — правите и запускаете здесь');
+console.log('  exam-guides/   — шпоры; удалите перед сдачей\n');
+console.log('Дальше:');
+console.log('  cd exam-project');
+console.log('  copy server\\.env.example server\\.env');
+console.log('  npm run db:init');
+console.log('  npm run dev\n');

package/scripts/prepack.js

@@ -0,0 +1,27 @@
+/**
+ * Проверка перед npm pack — в архив не должны попасть node_modules и .env
+ */
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+
+const bad = [];
+
+for (const sub of ['node_modules', 'client/node_modules', 'server/node_modules', 'client/dist']) {
+  if (fs.existsSync(path.join(root, sub))) {
+    bad.push(sub);
+  }
+}
+
+if (fs.existsSync(path.join(root, 'server/.env'))) {
+  console.warn('prepack: server/.env есть локально — в .npmignore, в архив не попадёт.');
+}
+
+if (bad.length) {
+  console.warn('prepack: в проекте есть (в .npmignore, в tgz не войдут):');
+  bad.forEach((b) => console.warn(`  - ${b}`));
+}
+
+console.log('prepack: ok — запускайте npm pack');

package/scripts/unpack-template.js

@@ -0,0 +1,105 @@
+#!/usr/bin/env node
+/**
+ * Распаковка шаблона из npm-пакета в папку проекта (экзамен / новый ПК).
+ * Вызов: npx exam-de-unpack
+ *        npx exam-de-unpack C:\DE\my-project
+ *        npx exam-de-unpack --here
+ */
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const PACKAGE_ROOT = path.resolve(__dirname, '..');
+
+const SKIP_DIRS = new Set([
+  'node_modules',
+  '.git',
+  'dist',
+  'exam-starter',
+  'design',
+]);
+
+const SKIP_ROOT_FILES = new Set([
+  'exam-template-moy-ne-sam-1.0.0.tgz',
+]);
+
+function shouldSkipDir(name) {
+  return SKIP_DIRS.has(name);
+}
+
+function shouldSkipFile(relPath) {
+  const base = path.basename(relPath);
+  if (SKIP_ROOT_FILES.has(base)) return true;
+  if (base.endsWith('.tgz')) return true;
+  if (relPath.replace(/\\/g, '/').includes('server/.env')) return true;
+  return false;
+}
+
+function parseTarget() {
+  const args = process.argv.slice(2).filter((a) => !a.startsWith('-'));
+  if (process.argv.includes('--here') || args.length === 0) {
+    return process.cwd();
+  }
+  return path.resolve(args[0]);
+}
+
+function copyRecursive(srcDir, destDir, relative = '') {
+  if (!fs.existsSync(srcDir)) return;
+
+  const entries = fs.readdirSync(srcDir, { withFileTypes: true });
+
+  for (const entry of entries) {
+    const rel = relative ? `${relative}/${entry.name}` : entry.name;
+    const src = path.join(srcDir, entry.name);
+    const dest = path.join(destDir, entry.name);
+
+    if (entry.isDirectory()) {
+      if (shouldSkipDir(entry.name)) continue;
+      if (!fs.existsSync(dest)) fs.mkdirSync(dest, { recursive: true });
+      copyRecursive(src, dest, rel);
+      continue;
+    }
+
+    if (shouldSkipFile(rel)) continue;
+
+    const destEnv = path.join(destDir, 'server', '.env');
+    if (rel === 'server/.env' && fs.existsSync(path.join(destDir, 'server', '.env'))) {
+      console.log('  пропуск (уже есть): server/.env');
+      continue;
+    }
+
+    fs.mkdirSync(path.dirname(dest), { recursive: true });
+    fs.copyFileSync(src, dest);
+  }
+}
+
+const target = parseTarget();
+const force = process.argv.includes('--force');
+
+console.log('');
+console.log('=== exam-de-unpack: шаблон ДЭ ===');
+console.log(`Из: ${PACKAGE_ROOT}`);
+console.log(`В:  ${target}`);
+console.log('');
+
+if (!fs.existsSync(target)) {
+  fs.mkdirSync(target, { recursive: true });
+}
+
+const marker = path.join(target, 'client', 'src', 'App.jsx');
+if (fs.existsSync(marker) && !force) {
+  console.log('В папке уже есть шаблон (client/src/App.jsx).');
+  console.log('Чтобы перезаписать: npx exam-de-unpack --force');
+  process.exit(0);
+}
+
+copyRecursive(PACKAGE_ROOT, target);
+
+console.log('Готово. Дальше в этой папке:');
+console.log('  npm install');
+console.log('  npm run install:all');
+console.log('  настроить server/.env');
+console.log('  npm run db:init');
+console.log('  npm run dev');
+console.log('');