import { useDispatch } from 'react-redux';
import { AuthModule } from './modules/auth';
import { useState } from 'react';

const LoginPage = () => {
  const dispatch = useDispatch();
  const [email, setEmail] = useState('');
  const [password, setPassword] = useState('');
  const [error, setError] = useState('');

  const handleLogin = async (e) => {
    e.preventDefault();
    try {
      await dispatch(AuthModule.login(email, password));
      // Перенаправление на дашборд после успешной авторизации
      window.location.href = '/dashboard';
    } catch (err) {
      setError('Неверные учетные данные');
    }
  };

  return (
    <form onSubmit={handleLogin}>
      <div>
        <label>Email:</label>
        <input 
          type="email" 
          value={email} 
          onChange={(e) => setEmail(e.target.value)} 
          required 
        />
      </div>
      <div>
        <label>Password:</label>
        <input 
          type="password" 
          value={password} 
          onChange={(e) => setPassword(e.target.value)} 
          required 
        />
      </div>
      {error && <div className="error">{error}</div>}
      <button type="submit">Login</button>
    </form>
  );
};

import { useState } from 'react';
import { useDispatch } from 'react-redux';
import { createIncident } from './modules/incidents/incidentThunks';

const CreateIncidentForm = () => {
  const dispatch = useDispatch();
  const [formData, setFormData] = useState({
    title: '',
    description: '',
    priority: 'MEDIUM',
    equipmentId: '',
  });

  const handleChange = (e) => {
    const { name, value } = e.target;
    setFormData(prev => ({ ...prev, [name]: value }));
  };

  const handleSubmit = async (e) => {
    e.preventDefault();
    try {
      await dispatch(createIncident(formData));
      alert('Инцидент успешно создан!');
      // Сброс формы
      setFormData({
        title: '',
        description: '',
        priority: 'MEDIUM',
        equipmentId: '',
      });
    } catch (error) {
      alert('Ошибка при создании инцидента');
    }
  };

  return (
    <form onSubmit={handleSubmit}>
      <div>
        <label>Заголовок:</label>
        <input
          type="text"
          name="title"
          value={formData.title}
          onChange={handleChange}
          required
        />
      </div>
      <div>
        <label>Описание:</label>
        <textarea
          name="description"
          value={formData.description}
          onChange={handleChange}
          required
        />
      </div>
      <div>
        <label>Приоритет:</label>
        <select
          name="priority"
          value={formData.priority}
          onChange={handleChange}
        >
          <option value="LOW">Низкий</option>
          <option value="MEDIUM">Средний</option>
          <option value="HIGH">Высокий</option>
        </select>
      </div>
      <div>
        <label>ID оборудования (опционально):</label>
        <input
          type="text"
          name="equipmentId"
          value={formData.equipmentId}
          onChange={handleChange}
        />
      </div>
      <button type="submit">Создать инцидент</button>
    </form>
  );
};

import { useState } from 'react';
import { useDispatch } from 'react-redux';
import { ReportModule } from './modules/reports';
import { ReportType, ReportFormat } from './modules/reports/reportTypes';

const GenerateReportForm = () => {
  const dispatch = useDispatch();
  const [reportOptions, setReportOptions] = useState({
    type: ReportType.INCIDENTS,
    format: ReportFormat.PDF,
    title: 'Отчет по инцидентам',
    filters: {
      startDate: '',
      endDate: '',
      status: [],
      priority: []
    },
    includeCharts: true
  });

  const handleChange = (e) => {
    const { name, value } = e.target;
    setReportOptions(prev => ({
      ...prev,
      [name]: value
    }));
  };

  const handleFilterChange = (e) => {
    const { name, value } = e.target;
    setReportOptions(prev => ({
      ...prev,
      filters: {
        ...prev.filters,
        [name]: value
      }
    }));
  };

  const handleSubmit = async (e) => {
    e.preventDefault();
    try {
      await dispatch(ReportModule.generateReport(reportOptions));
      alert('Отчет успешно сгенерирован!');
    } catch (error) {
      alert('Ошибка при генерации отчета');
    }
  };

  return (
    <form onSubmit={handleSubmit}>
      <div>
        <label>Тип отчета:</label>
        <select
          name="type"
          value={reportOptions.type}
          onChange={handleChange}
        >
          <option value={ReportType.INCIDENTS}>Инциденты</option>
          <option value={ReportType.EQUIPMENT}>Оборудование</option>
          <option value={ReportType.USERS}>Пользователи</option>
          <option value={ReportType.PERFORMANCE}>Производительность</option>
        </select>
      </div>
      <div>
        <label>Формат:</label>
        <select
          name="format"
          value={reportOptions.format}
          onChange={handleChange}
        >
          <option value={ReportFormat.PDF}>PDF</option>
          <option value={ReportFormat.EXCEL}>Excel</option>
          <option value={ReportFormat.CSV}>CSV</option>
        </select>
      </div>
      <div>
        <label>Заголовок отчета:</label>
        <input
          type="text"
          name="title"
          value={reportOptions.title}
          onChange={handleChange}
          required
        />
      </div>
      <div>
        <label>Дата начала:</label>
        <input
          type="date"
          name="startDate"
          value={reportOptions.filters.startDate}
          onChange={handleFilterChange}
        />
      </div>
      <div>
        <label>Дата окончания:</label>
        <input
          type="date"
          name="endDate"
          value={reportOptions.filters.endDate}
          onChange={handleFilterChange}
        />
      </div>
      <div>
        <label>Включить диаграммы:</label>
        <input
          type="checkbox"
          name="includeCharts"
          checked={reportOptions.includeCharts}
          onChange={(e) => setReportOptions(prev => ({
            ...prev,
            includeCharts: e.target.checked
          }))}
        />
      </div>
      <button type="submit">Сгенерировать отчет</button>
    </form>
  );
};

// server/controllers/example.controller.js
const Example = require('../models/example.model');

exports.getAll = async (req, res, next) => {
  try {
    const examples = await Example.find();
    res.status(200).json({ examples });
  } catch (error) {
    next(error);
  }
};

exports.create = async (req, res, next) => {
  try {
    const example = new Example(req.body);
    await example.save();
    res.status(201).json(example);
  } catch (error) {
    next(error);
  }
};

// server/routes/example.routes.js
const express = require('express');
const router = express.Router();
const exampleController = require('../controllers/example.controller');
const { authMiddleware } = require('../middleware');

router.get('/', authMiddleware, exampleController.getAll);
router.post('/', authMiddleware, exampleController.create);

module.exports = router;

// server/routes/index.js
const express = require('express');
const router = express.Router();

const authRoutes = require('./auth.routes');
const incidentRoutes = require('./incident.routes');
const equipmentRoutes = require('./equipment.routes');
const exampleRoutes = require('./example.routes'); // Добавлено

router.use('/auth', authRoutes);
router.use('/incidents', incidentRoutes);
router.use('/equipment', equipmentRoutes);
router.use('/examples', exampleRoutes); // Добавлено

module.exports = router;

// client/src/modules/example/store/exampleSlice.js
import { createSlice } from '@reduxjs/toolkit';

const initialState = {
  examples: [],
  loading: false,
  error: null
};

const exampleSlice = createSlice({
  name: 'examples',
  initialState,
  reducers: {
    fetchExamplesStart: (state) => {
      state.loading = true;
      state.error = null;
    },
    fetchExamplesSuccess: (state, action) => {
      state.examples = action.payload;
      state.loading = false;
    },
    fetchExamplesFailure: (state, action) => {
      state.loading = false;
      state.error = action.payload;
    }
  }
});

export const {
  fetchExamplesStart,
  fetchExamplesSuccess,
  fetchExamplesFailure
} = exampleSlice.actions;

export default exampleSlice.reducer;

// client/src/store/rootReducer.js
import { combineReducers } from '@reduxjs/toolkit';
import authReducer from '../modules/auth/store/authSlice';
import incidentsReducer from '../modules/incidents/store/incidentsSlice';
import equipmentReducer from '../modules/equipment/store/equipmentSlice';
import exampleReducer from '../modules/example/store/exampleSlice'; // Добавлено

const rootReducer = combineReducers({
  auth: authReducer,
  incidents: incidentsReducer,
  equipment: equipmentReducer,
  examples: exampleReducer // Добавлено
});

export default rootReducer;

// server/tests/auth.test.js
const request = require('supertest');
const app = require('../app');
const User = require('../models/user.model');
const mongoose = require('mongoose');

describe('Auth API', () => {
  beforeAll(async () => {
    // Подключение к тестовой базе данных
    await mongoose.connect(process.env.MONGODB_URI_TEST);
  });

  afterAll(async () => {
    // Отключение от базы данных
    await mongoose.connection.close();
  });

  beforeEach(async () => {
    // Очистка коллекции пользователей перед каждым тестом
    await User.deleteMany({});
  });

  it('should register a new user', async () => {
    const res = await request(app)
      .post('/api/auth/register')
      .send({
        email: '[email protected]',
        password: 'password123',
        username: 'testuser'
      });

    expect(res.statusCode).toEqual(201);
    expect(res.body).toHaveProperty('token');
    expect(res.body.user).toHaveProperty('email', '[email protected]');
  });

  it('should login an existing user', async () => {
    // Создание пользователя
    await request(app)
      .post('/api/auth/register')
      .send({
        email: '[email protected]',
        password: 'password123',
        username: 'testuser'
      });

    // Логин
    const res = await request(app)
      .post('/api/auth/login')
      .send({
        email: '[email protected]',
        password: 'password123'
      });

    expect(res.statusCode).toEqual(200);
    expect(res.body).toHaveProperty('token');
    expect(res.body.user).toHaveProperty('email', '[email protected]');
  });
});