Kurs JavaScript i TypeScript · Moduł 5: Zaawansowany JavaScript
Implementacja aplikacji z wykorzystaniem poznanych technik
W tej lekcji6
Witaj w końcowej fazie naszej przygody w Parku Jurajskim! W tym ćwiczeniu połączymy wszystkie poznane dotychczas techniki, aby stworzyć kompletną aplikację do monitorowania i zarządzania ekosystemem Parku Jurajskiego. To nasz "wielki finał" przed przejściem do strukturyzacji większych projektów.
Cel projektu
Stworzymy aplikację "JurassicTracker" - system do monitorowania, śledzenia i zarządzania dinozaurami w parku. Nasza aplikacja będzie wykorzystywać:
- Modularny kod (ES Modules)
- Asynchroniczne operacje (Promises, async/await)
- Obsługę błędów (try/catch, własne klasy błędów)
- Serwisy działające w tle (setInterval)
- Zarządzanie stanem aplikacji
Struktura projektu
Zanim przejdziemy do implementacji, zaplanujmy strukturę naszego projektu:
jurassic-tracker/
├── index.js # Główny plik aplikacji
├── modules/
│ ├── api.js # Moduł komunikacji z API
│ ├── dinosaurs.js # Moduł zarządzania dinozaurami
│ ├── enclosures.js # Moduł zarządzania wybiegami
│ ├── security.js # Moduł systemów bezpieczeństwa
│ ├── monitoring.js # Moduł monitorowania parku
│ ├── utils.js # Narzędzia pomocnicze
│ └── errors/ # Katalog z klasami błędów
│ ├── index.js # Eksportuje wszystkie błędy
│ ├── APIError.js # Błędy związane z API
│ ├── DinoError.js # Błędy związane z dinozaurami
│ └── SecurityError.js # Błędy związane z bezpieczeństwem
└── data/
└── config.js # Konfiguracja aplikacjiImplementacja modułów
Zacznijmy od zaimplementowania każdego z modułów. Pamiętaj, że w praktyce te pliki znalazłyby się w oddzielnych plikach zgodnie z powyższą strukturą.
1. Moduł błędów (errors/index.js)
Najpierw zdefiniujmy nasze niestandardowe klasy błędów:
// errors/APIError.js
export class APIError extends Error {
constructor(message, statusCode, endpoint) {
super(message);
this.name = 'APIError';
this.statusCode = statusCode;
this.endpoint = endpoint;
this.timestamp = new Date();
}
isServerError() {
return this.statusCode >= 500;
}
isClientError() {
return this.statusCode >= 400 && this.statusCode < 500;
}
}
// errors/DinoError.js
export class DinoError extends Error {
constructor(message, dinoId, species) {
super(message);
this.name = 'DinoError';
this.dinoId = dinoId;
this.species = species;
this.timestamp = new Date();
}
}
export class DinoNotFoundError extends DinoError {
constructor(dinoId) {
super(`Dinozaur o ID ${dinoId} nie został znaleziony`, dinoId, null);
this.name = 'DinoNotFoundError';
}
}
export class DinoBehaviorError extends DinoError {
constructor(message, dinoId, species, behaviorType, dangerLevel) {
super(message, dinoId, species);
this.name = 'DinoBehaviorError';
this.behaviorType = behaviorType;
this.dangerLevel = dangerLevel; // 1-10
}
requiresIntervention() {
return this.dangerLevel >= 7;
}
}
// errors/SecurityError.js
export class SecurityError extends Error {
constructor(message, sector, systemType) {
super(message);
this.name = 'SecurityError';
this.sector = sector;
this.systemType = systemType;
this.timestamp = new Date();
}
}
export class EnclosureBreachError extends SecurityError {
constructor(sector, dinoSpecies, count) {
super(`Naruszenie wybiegu w sektorze ${sector}: ${count} okazów ${dinoSpecies}`, sector, 'enclosure');
this.name = 'EnclosureBreachError';
this.dinoSpecies = dinoSpecies;
this.count = count;
}
}
// errors/index.js
export * from './APIError.js';
export * from './DinoError.js';
export * from './SecurityError.js';2. Moduł API (api.js)
Nasz moduł API będzie odpowiedzialny za komunikację z (hipotetycznym) serwerem Parku Jurajskiego:
// modules/api.js
import { APIError } from '../errors/index.js';
// Symulacja bazy danych (w rzeczywistości byłoby to API)
const API_DELAY = 500; // ms - symulacja opóźnienia sieciowego
const API_ERROR_RATE = 0.1; // 10% szans na błąd API dla realizmu
// Symulowane dane dinozaurów
let dinosaursData = [
{ id: 'trx1', name: 'Rex', species: 'Tyrannosaurus', enclosureId: 'enc1', health: 98, lastFed: new Date(Date.now() - 3600000), behavior: 'calm' },
{ id: 'rap1', name: 'Blue', species: 'Velociraptor', enclosureId: 'enc2', health: 95, lastFed: new Date(Date.now() - 7200000), behavior: 'agitated' },
{ id: 'rap2', name: 'Delta', species: 'Velociraptor', enclosureId: 'enc2', health: 92, lastFed: new Date(Date.now() - 7200000), behavior: 'hunting' },
{ id: 'tri1', name: 'Sarah', species: 'Triceratops', enclosureId: 'enc3', health: 88, lastFed: new Date(Date.now() - 1800000), behavior: 'sleeping' },
{ id: 'bro1', name: 'Bronty', species: 'Brontosaurus', enclosureId: 'enc4', health: 100, lastFed: new Date(Date.now() - 900000), behavior: 'grazing' },
];
// Symulowane dane wybiegów
let enclosuresData = [
{ id: 'enc1', name: 'T-Rex Paddock', sector: 'A1', powerStatus: 'active', securityLevel: 10, lastInspection: new Date(Date.now() - 86400000) },
{ id: 'enc2', name: 'Raptor Containment', sector: 'B2', powerStatus: 'active', securityLevel: 9, lastInspection: new Date(Date.now() - 129600000) },
{ id: 'enc3', name: 'Triceratops Territory', sector: 'C3', powerStatus: 'active', securityLevel: 6, lastInspection: new Date(Date.now() - 172800000) },
{ id: 'enc4', name: 'Herbivore Valley', sector: 'D4', powerStatus: 'active', securityLevel: 4, lastInspection: new Date(Date.now() - 259200000) },
];
// Funkcja pomocnicza symulująca opóźnienie sieciowe
const simulateNetworkDelay = () => {
return new Promise(resolve => setTimeout(resolve, API_DELAY * (0.5 + Math.random())));
};
// Funkcja pomocnicza symulująca błędy API
const simulateApiError = (endpoint) => {
if (Math.random() < API_ERROR_RATE) {
const errorTypes = [
{ statusCode: 500, message: 'Internal Server Error' },
{ statusCode: 503, message: 'Service Unavailable' },
{ statusCode: 429, message: 'Too Many Requests' },
{ statusCode: 403, message: 'Forbidden - Insufficient permissions' }
];
const errorType = errorTypes[Math.floor(Math.random() * errorTypes.length)];
throw new APIError(`API Error: ${errorType.message}`, errorType.statusCode, endpoint);
}
};
// API do pobierania danych o dinozaurach
export async function getDinosaurs() {
const endpoint = '/api/dinosaurs';
try {
await simulateNetworkDelay();
simulateApiError(endpoint);
return [...dinosaursData]; // Zwracamy kopię, aby uniknąć mutacji
} catch (error) {
if (error instanceof APIError) {
throw error;
}
throw new APIError('Błąd podczas pobierania danych o dinozaurach', 500, endpoint);
}
}
export async function getDinosaurById(id) {
const endpoint = `/api/dinosaurs/${id}`;
try {
await simulateNetworkDelay();
simulateApiError(endpoint);
const dino = dinosaursData.find(d => d.id === id);
if (!dino) {
throw new APIError(`Dinozaur o ID ${id} nie został znaleziony`, 404, endpoint);
}
return { ...dino }; // Zwracamy kopię
} catch (error) {
if (error instanceof APIError) {
throw error;
}
throw new APIError(`Błąd podczas pobierania dinozaura ${id}`, 500, endpoint);
}
}
export async function updateDinosaur(id, updates) {
const endpoint = `/api/dinosaurs/${id}`;
try {
await simulateNetworkDelay();
simulateApiError(endpoint);
const dinoIndex = dinosaursData.findIndex(d => d.id === id);
if (dinoIndex === -1) {
throw new APIError(`Dinozaur o ID ${id} nie został znaleziony`, 404, endpoint);
}
// Aktualizacja danych
dinosaursData[dinoIndex] = {
...dinosaursData[dinoIndex],
...updates,
id // Upewniamy się, że ID się nie zmienia
};
return { ...dinosaursData[dinoIndex] };
} catch (error) {
if (error instanceof APIError) {
throw error;
}
throw new APIError(`Błąd podczas aktualizacji dinozaura ${id}`, 500, endpoint);
}
}
// API do pobierania danych o wybiegach
export async function getEnclosures() {
const endpoint = '/api/enclosures';
try {
await simulateNetworkDelay();
simulateApiError(endpoint);
return [...enclosuresData];
} catch (error) {
if (error instanceof APIError) {
throw error;
}
throw new APIError('Błąd podczas pobierania danych o wybiegach', 500, endpoint);
}
}
export async function getEnclosureById(id) {
const endpoint = `/api/enclosures/${id}`;
try {
await simulateNetworkDelay();
simulateApiError(endpoint);
const enclosure = enclosuresData.find(e => e.id === id);
if (!enclosure) {
throw new APIError(`Wybieg o ID ${id} nie został znaleziony`, 404, endpoint);
}
return { ...enclosure };
} catch (error) {
if (error instanceof APIError) {
throw error;
}
throw new APIError(`Błąd podczas pobierania wybiegu ${id}`, 500, endpoint);
}
}
export async function updateEnclosure(id, updates) {
const endpoint = `/api/enclosures/${id}`;
try {
await simulateNetworkDelay();
simulateApiError(endpoint);
const enclosureIndex = enclosuresData.findIndex(e => e.id === id);
if (enclosureIndex === -1) {
throw new APIError(`Wybieg o ID ${id} nie został znaleziony`, 404, endpoint);
}
// Aktualizacja danych
enclosuresData[enclosureIndex] = {
...enclosuresData[enclosureIndex],
...updates,
id
};
return { ...enclosuresData[enclosureIndex] };
} catch (error) {
if (error instanceof APIError) {
throw error;
}
throw new APIError(`Błąd podczas aktualizacji wybiegu ${id}`, 500, endpoint);
}
}
// API do logowania zdarzeń
export async function logEvent(eventType, details) {
const endpoint = '/api/events';
try {
await simulateNetworkDelay();
simulateApiError(endpoint);
// W rzeczywistości wysłalibyśmy zdarzenie do serwera
console.log(`[EVENT] ${eventType}:`, details);
return { success: true, timestamp: new Date() };
} catch (error) {
if (error instanceof APIError) {
throw error;
}
throw new APIError('Błąd podczas logowania zdarzenia', 500, endpoint);
}
}3. Moduł dinozaurów (dinosaurs.js)
Ten moduł będzie odpowiedzialny za zarządzanie danymi o dinozaurach i ich zachowaniami:
// modules/dinosaurs.js
import { getDinosaurs, getDinosaurById, updateDinosaur, logEvent } from './api.js';
import { DinoNotFoundError, DinoBehaviorError } from '../errors/index.js';
// Ocena ryzyka zachowania dinozaura
function assessBehaviorRisk(dino) {
const dangerousSpecies = ['Tyrannosaurus', 'Velociraptor', 'Spinosaurus'];
const riskBehaviors = {
'calm': 1,
'grazing': 1,
'sleeping': 2,
'exploring': 4,
'agitated': 6,
'hunting': 7,
'aggressive': 9
};
// Bazowy poziom ryzyka zależy od gatunku
let baseRisk = dangerousSpecies.includes(dino.species) ? 5 : 2;
// Modyfikacja ryzyka w zależności od zachowania
const behaviorRisk = riskBehaviors[dino.behavior] || 3;
// Modyfikacja ryzyka w zależności od czasu od ostatniego karmienia
const hoursSinceLastFed = (Date.now() - new Date(dino.lastFed).getTime()) / 3600000;
const hungerRisk = Math.min(5, Math.floor(hoursSinceLastFed / 3));
// Całkowity poziom ryzyka (1-10)
const totalRisk = Math.min(10, baseRisk + behaviorRisk + hungerRisk);
return {
risk: totalRisk,
factors: {
species: baseRisk,
behavior: behaviorRisk,
hunger: hungerRisk
}
};
}
// Pobieranie wszystkich dinozaurów
export async function getAllDinosaurs() {
try {
const dinosaurs = await getDinosaurs();
// Wzbogacamy dane o ocenę ryzyka
return dinosaurs.map(dino => ({
...dino,
riskAssessment: assessBehaviorRisk(dino)
}));
} catch (error) {
console.error('Błąd podczas pobierania listy dinozaurów:', error);
throw error;
}
}
// Pobieranie konkretnego dinozaura po ID
export async function getDinosaur(id) {
try {
const dino = await getDinosaurById(id);
return {
...dino,
riskAssessment: assessBehaviorRisk(dino)
};
} catch (error) {
if (error.statusCode === 404) {
throw new DinoNotFoundError(id);
}
console.error(`Błąd podczas pobierania dinozaura ${id}:`, error);
throw error;
}
}
// Karmienie dinozaura
export async function feedDinosaur(id) {
try {
const dino = await getDinosaur(id);
// Aktualizacja stanu dinozaura
const updatedDino = await updateDinosaur(id, {
lastFed: new Date(),
health: Math.min(100, dino.health + 5),
behavior: 'calm' // Dinozaury są spokojniejsze po karmieniu
});
// Logowanie zdarzenia
await logEvent('FEEDING', {
dinoId: id,
species: dino.species,
name: dino.name,
previousFeedingTime: dino.lastFed
});
return {
...updatedDino,
riskAssessment: assessBehaviorRisk(updatedDino)
};
} catch (error) {
console.error(`Błąd podczas karmienia dinozaura ${id}:`, error);
throw error;
}
}
// Monitorowanie zachowania dinozaura
export async function monitorBehavior(id) {
try {
const dino = await getDinosaur(id);
const { risk, factors } = assessBehaviorRisk(dino);
// Sprawdzamy, czy zachowanie wymaga interwencji
if (risk >= 8) {
const error = new DinoBehaviorError(
`Niebezpieczne zachowanie dinozaura ${dino.name}`,
id,
dino.species,
dino.behavior,
risk
);
// Logowanie zdarzenia wysokiego ryzyka
await logEvent('HIGH_RISK_BEHAVIOR', {
dinoId: id,
species: dino.species,
name: dino.name,
behavior: dino.behavior,
risk,
factors
});
throw error;
}
// Dla średniego ryzyka tylko logujemy
if (risk >= 5) {
await logEvent('MEDIUM_RISK_BEHAVIOR', {
dinoId: id,
species: dino.species,
name: dino.name,
behavior: dino.behavior,
risk,
factors
});
}
return { dino, risk, factors };
} catch (error) {
if (error instanceof DinoBehaviorError) {
throw error; // Przekazujemy dalej nasz własny błąd
}
console.error(`Błąd podczas monitorowania dinozaura ${id}:`, error);
throw error;
}
}
// Symulacja zmiany zachowania (używana przez moduł monitorowania)
export async function simulateBehaviorChange() {
try {
const allDinos = await getAllDinosaurs();
const randomIndex = Math.floor(Math.random() * allDinos.length);
const targetDino = allDinos[randomIndex];
// Możliwe zachowania zależne od gatunku i ostatniego karmienia
const possibleBehaviors = ['calm', 'grazing', 'sleeping', 'exploring', 'agitated', 'hunting', 'aggressive'];
const carnivores = ['Tyrannosaurus', 'Velociraptor', 'Spinosaurus'];
let behaviorPool;
if (carnivores.includes(targetDino.species)) {
// Drapieżniki mają większe szanse na agresywne zachowania
behaviorPool = ['calm', 'sleeping', 'exploring', 'agitated', 'hunting', 'aggressive'];
} else {
// Roślinożercy są generalnie spokojniejsi
behaviorPool = ['calm', 'grazing', 'sleeping', 'exploring', 'agitated'];
}
// Głodne dinozaury są bardziej agresywne
const hoursSinceLastFed = (Date.now() - new Date(targetDino.lastFed).getTime()) / 3600000;
if (hoursSinceLastFed > 8) {
if (carnivores.includes(targetDino.species)) {
behaviorPool = ['agitated', 'hunting', 'aggressive'];
} else {
behaviorPool = ['agitated', 'exploring'];
}
}
// Losowy wybór nowego zachowania
const newBehavior = behaviorPool[Math.floor(Math.random() * behaviorPool.length)];
// Aktualizacja stanu dinozaura
const updatedDino = await updateDinosaur(targetDino.id, {
behavior: newBehavior
});
await logEvent('BEHAVIOR_CHANGE', {
dinoId: targetDino.id,
species: targetDino.species,
name: targetDino.name,
previousBehavior: targetDino.behavior,
newBehavior
});
return {
...updatedDino,
riskAssessment: assessBehaviorRisk(updatedDino)
};
} catch (error) {
console.error('Błąd podczas symulacji zmiany zachowania:', error);
throw error;
}
}4. Moduł wybiegów (enclosures.js)
Ten moduł będzie zarządzał wybiegami i ich stanem bezpieczeństwa:
// modules/enclosures.js
import { getEnclosures, getEnclosureById, updateEnclosure, logEvent } from './api.js';
import { SecurityError, EnclosureBreachError } from '../errors/index.js';
import { getAllDinosaurs } from './dinosaurs.js';
// Ocena stanu bezpieczeństwa wybiegu
function assessSecurityStatus(enclosure, dinosaurs) {
// Sprawdzamy, ile dinozaurów jest w wybiegu
const enclosureDinosaurs = dinosaurs.filter(dino => dino.enclosureId === enclosure.id);
// Sprawdzamy, czy są drapieżniki
const carnivores = enclosureDinosaurs.filter(dino =>
['Tyrannosaurus', 'Velociraptor', 'Spinosaurus'].includes(dino.species)
);
// Sprawdzamy łączne ryzyko
const totalRisk = enclosureDinosaurs.reduce((sum, dino) =>
sum + (dino.riskAssessment ? dino.riskAssessment.risk : 3), 0);
// Stan zasilania
const powerStatus = enclosure.powerStatus === 'active' ? 10 :
enclosure.powerStatus === 'backup' ? 5 : 0;
// Czas od ostatniej inspekcji (w dniach)
const daysSinceInspection = (Date.now() - new Date(enclosure.lastInspection).getTime()) / (24 * 3600000);
const inspectionScore = daysSinceInspection < 1 ? 10 :
daysSinceInspection < 3 ? 7 :
daysSinceInspection < 7 ? 4 : 1;
// Obliczenie ogólnego wskaźnika bezpieczeństwa (0-100)
const securityScore = Math.max(0, Math.min(100,
enclosure.securityLevel * 10 - totalRisk + powerStatus + inspectionScore
));
return {
id: enclosure.id,
name: enclosure.name,
sector: enclosure.sector,
dinosaurCount: enclosureDinosaurs.length,
carnivoreCount: carnivores.length,
securityLevel: enclosure.securityLevel,
powerStatus: enclosure.powerStatus,
securityScore,
status: securityScore >= 80 ? 'secure' :
securityScore >= 60 ? 'normal' :
securityScore >= 40 ? 'warning' : 'danger',
dinosaurs: enclosureDinosaurs.map(d => ({
id: d.id,
name: d.name,
species: d.species,
risk: d.riskAssessment ? d.riskAssessment.risk : 3
}))
};
}
// Pobieranie wszystkich wybiegów z oceną bezpieczeństwa
export async function getAllEnclosures() {
try {
const [enclosures, dinosaurs] = await Promise.all([
getEnclosures(),
getAllDinosaurs()
]);
// Wzbogacamy dane o ocenę bezpieczeństwa
return enclosures.map(enclosure =>
assessSecurityStatus(enclosure, dinosaurs)
);
} catch (error) {
console.error('Błąd podczas pobierania listy wybiegów:', error);
throw error;
}
}
// Pobieranie konkretnego wybiegu po ID
export async function getEnclosure(id) {
try {
const [enclosure, dinosaurs] = await Promise.all([
getEnclosureById(id),
getAllDinosaurs()
]);
return assessSecurityStatus(enclosure, dinosaurs);
} catch (error) {
console.error(`Błąd podczas pobierania wybiegu ${id}:`, error);
throw error;
}
}
// Przeprowadzenie inspekcji wybiegu
export async function inspectEnclosure(id) {
try {
const enclosure = await getEnclosureById(id);
// Aktualizacja daty ostatniej inspekcji
const updatedEnclosure = await updateEnclosure(id, {
lastInspection: new Date()
});
// Logowanie zdarzenia
await logEvent('ENCLOSURE_INSPECTION', {
enclosureId: id,
name: enclosure.name,
sector: enclosure.sector,
previousInspection: enclosure.lastInspection
});
// Pobieramy dinozaury, aby zaktualizować ocenę bezpieczeństwa
const dinosaurs = await getAllDinosaurs();
return assessSecurityStatus(updatedEnclosure, dinosaurs);
} catch (error) {
console.error(`Błąd podczas inspekcji wybiegu ${id}:`, error);
throw error;
}
}
// Symulacja awarii systemu zasilania
export async function simulatePowerFailure() {
try {
const enclosures = await getEnclosures();
// Wybieramy losowy wybieg
const randomIndex = Math.floor(Math.random() * enclosures.length);
const targetEnclosure = enclosures[randomIndex];
if (targetEnclosure.powerStatus !== 'active') {
// Wybieg już ma problem z zasilaniem
return;
}
// 70% szans na przejście na zasilanie awaryjne, 30% na całkowitą awarię
const newPowerStatus = Math.random() < 0.7 ? 'backup' : 'failure';
// Aktualizacja stanu wybiegu
const updatedEnclosure = await updateEnclosure(targetEnclosure.id, {
powerStatus: newPowerStatus
});
// Logowanie zdarzenia
await logEvent('POWER_FAILURE', {
enclosureId: targetEnclosure.id,
name: targetEnclosure.name,
sector: targetEnclosure.sector,
powerStatus: newPowerStatus
});
// Sprawdzenie, czy awaria może prowadzić do naruszenia wybiegu
if (newPowerStatus === 'failure') {
const dinosaurs = await getAllDinosaurs();
const enclosureDinos = dinosaurs.filter(dino => dino.enclosureId === targetEnclosure.id);
// Ocena ryzyka naruszenia (zależy od gatunków dinozaurów)
const dangerousSpecies = ['Tyrannosaurus', 'Velociraptor', 'Spinosaurus'];
const hasDangerousDinos = enclosureDinos.some(dino =>
dangerousSpecies.includes(dino.species)
);
if (hasDangerousDinos && targetEnclosure.securityLevel >= 8) {
// Wysokie ryzyko naruszenia wybiegu
const breachingSpecies = enclosureDinos.find(dino =>
dangerousSpecies.includes(dino.species)
).species;
const breachingCount = enclosureDinos.filter(dino =>
dino.species === breachingSpecies
).length;
throw new EnclosureBreachError(
targetEnclosure.sector,
breachingSpecies,
breachingCount
);
}
}
const dinosaurs = await getAllDinosaurs();
return assessSecurityStatus(updatedEnclosure, dinosaurs);
} catch (error) {
if (error instanceof EnclosureBreachError) {
// Logujemy zdarzenie naruszenia wybiegu
await logEvent('ENCLOSURE_BREACH', {
sector: error.sector,
species: error.dinoSpecies,
count: error.count,
timestamp: error.timestamp
});
throw error; // Przekazujemy błąd dalej
}
console.error('Błąd podczas symulacji awarii zasilania:', error);
throw error;
}
}
// Naprawa systemu zasilania
export async function repairPowerSystem(id) {
try {
const enclosure = await getEnclosureById(id);
if (enclosure.powerStatus === 'active') {
throw new SecurityError(
'System zasilania jest już aktywny',
enclosure.sector,
'power'
);
}
// Aktualizacja stanu zasilania
const updatedEnclosure = await updateEnclosure(id, {
powerStatus: 'active'
});
// Logowanie zdarzenia
await logEvent('POWER_RESTORED', {
enclosureId: id,
name: enclosure.name,
sector: enclosure.sector,
previousStatus: enclosure.powerStatus
});
// Pobieramy dinozaury, aby zaktualizować ocenę bezpieczeństwa
const dinosaurs = await getAllDinosaurs();
return assessSecurityStatus(updatedEnclosure, dinosaurs);
} catch (error) {
console.error(`Błąd podczas naprawy systemu zasilania wybiegu ${id}:`, error);
throw error;
}
}5. Moduł monitorowania (monitoring.js)
Ten moduł będzie odpowiedzialny za ciągłe monitorowanie parku w tle:
// modules/monitoring.js
import { getAllDinosaurs, monitorBehavior, simulateBehaviorChange } from './dinosaurs.js';
import { getAllEnclosures, simulatePowerFailure } from './enclosures.js';
import { logEvent } from './api.js';
import { DinoBehaviorError, EnclosureBreachError } from '../errors/index.js';
// Przechowujemy identyfikatory interwałów, aby móc je później zatrzymać
const intervals = new Map();
// Aktywne alarmy
const activeAlerts = new Map();
// Rejestratory dla alertów
const alertListeners = [];
// Status systemu monitorowania
let monitoringStatus = 'idle'; // 'idle', 'running', 'error'
// Dodawanie listenera dla alertów
export function addAlertListener(callback) {
alertListeners.push(callback);
return function removeListener() {
const index = alertListeners.indexOf(callback);
if (index !== -1) {
alertListeners.splice(index, 1);
return true;
}
return false;
};
}
// Generowanie alertu
function triggerAlert(alertType, data) {
const alertId = `${alertType}-${Date.now()}`;
const alert = {
id: alertId,
type: alertType,
timestamp: new Date(),
data,
resolved: false
};
// Dodajemy do aktywnych alertów
activeAlerts.set(alertId, alert);
// Powiadamiamy wszystkich słuchaczy
alertListeners.forEach(listener => {
try {
listener(alert);
} catch (error) {
console.error('Błąd w listenerze alertów:', error);
}
});
return alertId;
}
// Oznaczanie alertu jako rozwiązanego
export function resolveAlert(alertId) {
if (!activeAlerts.has(alertId)) {
throw new Error(`Alert o ID ${alertId} nie istnieje`);
}
const alert = activeAlerts.get(alertId);
alert.resolved = true;
alert.resolutionTime = new Date();
// Powiadamiamy wszystkich słuchaczy
alertListeners.forEach(listener => {
try {
listener({ ...alert, status: 'resolved' });
} catch (error) {
console.error('Błąd w listenerze alertów:', error);
}
});
// Po 5 minutach usuwamy rozwiązany alert z pamięci
setTimeout(() => {
activeAlerts.delete(alertId);
}, 5 * 60 * 1000);
return alert;
}
// Pobieranie wszystkich aktywnych alertów
export function getActiveAlerts() {
return Array.from(activeAlerts.values())
.filter(alert => !alert.resolved)
.sort((a, b) => b.timestamp - a.timestamp);
}
// Uruchomienie monitorowania zachowań dinozaurów
function startDinoBehaviorMonitoring(interval = 60000) {
if (intervals.has('dinoBehavior')) {
clearInterval(intervals.get('dinoBehavior'));
}
// Funkcja monitorująca wszystkie dinozaury
async function monitorAllDinosaurs() {
try {
const allDinos = await getAllDinosaurs();
// Monitorujemy każdego dinozaura
const monitorPromises = allDinos.map(dino =>
monitorBehavior(dino.id).catch(error => {
if (error instanceof DinoBehaviorError && error.requiresIntervention()) {
// Generujemy alert dla niebezpiecznego zachowania
triggerAlert('DANGEROUS_BEHAVIOR', {
dinoId: error.dinoId,
species: error.species,
behavior: error.behaviorType,
dangerLevel: error.dangerLevel,
message: error.message
});
}
return { error, dino };
})
);
await Promise.all(monitorPromises);
// Symulujemy losową zmianę zachowania (dla jednego dinozaura)
if (Math.random() < 0.3) { // 30% szans na zmianę w każdym cyklu
await simulateBehaviorChange();
}
} catch (error) {
console.error('Błąd podczas monitorowania dinozaurów:', error);
monitoringStatus = 'error';
// Automatyczne ponowne uruchomienie po błędzie
setTimeout(() => {
if (monitoringStatus === 'error') {
monitoringStatus = 'running';
}
}, 5000);
}
}
// Pierwsze uruchomienie natychmiast
monitorAllDinosaurs();
// Następnie uruchamiamy cyklicznie
const intervalId = setInterval(monitorAllDinosaurs, interval);
intervals.set('dinoBehavior', intervalId);
return intervalId;
}
// Uruchomienie monitorowania zabezpieczeń wybiegów
function startEnclosureMonitoring(interval = 90000) {
if (intervals.has('enclosureSecurity')) {
clearInterval(intervals.get('enclosureSecurity'));
}
// Funkcja monitorująca stan wybiegów
async function monitorAllEnclosures() {
try {
const allEnclosures = await getAllEnclosures();
// Sprawdzamy stan bezpieczeństwa każdego wybiegu
for (const enclosure of allEnclosures) {
if (enclosure.status === 'danger') {
// Generujemy alert dla niebezpiecznego stanu wybiegu
triggerAlert('ENCLOSURE_SECURITY', {
enclosureId: enclosure.id,
name: enclosure.name,
sector: enclosure.sector,
securityScore: enclosure.securityScore,
powerStatus: enclosure.powerStatus,
dinosaurCount: enclosure.dinosaurCount
});
}
}
// Symulujemy losowe awarie zasilania
if (Math.random() < 0.2) { // 20% szans na awarię w każdym cyklu
try {
await simulatePowerFailure();
} catch (error) {
if (error instanceof EnclosureBreachError) {
// Generujemy alert dla naruszenia wybiegu
triggerAlert('ENCLOSURE_BREACH', {
sector: error.sector,
species: error.dinoSpecies,
count: error.count,
timestamp: error.timestamp,
message: error.message
});
}
throw error;
}
}
} catch (error) {
if (!(error instanceof EnclosureBreachError)) {
console.error('Błąd podczas monitorowania wybiegów:', error);
monitoringStatus = 'error';
// Automatyczne ponowne uruchomienie po błędzie
setTimeout(() => {
if (monitoringStatus === 'error') {
monitoringStatus = 'running';
}
}, 5000);
}
}
}
// Pierwsze uruchomienie po 10 sekundach (aby nie nakładało się z monitorowaniem dinozaurów)
setTimeout(() => {
monitorAllEnclosures();
}, 10000);
// Następnie uruchamiamy cyklicznie
const intervalId = setInterval(monitorAllEnclosures, interval);
intervals.set('enclosureSecurity', intervalId);
return intervalId;
}
// Uruchomienie systemu monitorowania
export function startMonitoring(options = {}) {
if (monitoringStatus === 'running') {
console.log('System monitorowania jest już uruchomiony.');
return;
}
monitoringStatus = 'running';
// Ustawienia domyślne
const settings = {
dinoBehaviorInterval: 60000, // 1 minuta
enclosureSecurityInterval: 90000, // 1.5 minuty
...options
};
// Uruchamiamy monitorowanie dinozaurów
startDinoBehaviorMonitoring(settings.dinoBehaviorInterval);
// Uruchamiamy monitorowanie wybiegów
startEnclosureMonitoring(settings.enclosureSecurityInterval);
// Logujemy uruchomienie
logEvent('MONITORING_STARTED', {
timestamp: new Date(),
settings
}).catch(error => console.error('Błąd podczas logowania zdarzenia:', error));
return monitoringStatus;
}
// Zatrzymanie systemu monitorowania
export function stopMonitoring() {
if (monitoringStatus !== 'running') {
console.log('System monitorowania nie jest uruchomiony.');
return;
}
// Zatrzymujemy wszystkie interwały
for (const [name, intervalId] of intervals.entries()) {
clearInterval(intervalId);
intervals.delete(name);
}
monitoringStatus = 'idle';
// Logujemy zatrzymanie
logEvent('MONITORING_STOPPED', {
timestamp: new Date()
}).catch(error => console.error('Błąd podczas logowania zdarzenia:', error));
return monitoringStatus;
}
// Zwracanie statusu systemu monitorowania
export function getMonitoringStatus() {
return {
status: monitoringStatus,
activeMonitors: Array.from(intervals.keys()),
alertsCount: getActiveAlerts().length
};
}6. Moduł pomocniczy (utils.js)
Ten moduł będzie zawierał przydatne funkcje pomocnicze:
// modules/utils.js
// Formatowanie daty
export function formatDate(date) {
if (!date) return 'N/A';
const d = new Date(date);
if (isNaN(d.getTime())) return 'Invalid Date';
return d.toLocaleString('pl-PL', {
year: 'numeric',
month: '2-digit',
day: '2-digit',
hour: '2-digit',
minute: '2-digit',
second: '2-digit'
});
}
// Formatowanie czasu, który upłynął
export function formatTimeAgo(date) {
if (!date) return 'N/A';
const d = new Date(date);
if (isNaN(d.getTime())) return 'Invalid Date';
const now = new Date();
const diffMs = now - d;
if (diffMs < 0) return 'w przyszłości';
const diffSec = Math.floor(diffMs / 1000);
if (diffSec < 60) return `${diffSec} sek. temu`;
const diffMin = Math.floor(diffSec / 60);
if (diffMin < 60) return `${diffMin} min. temu`;
const diffHour = Math.floor(diffMin / 60);
if (diffHour < 24) return `${diffHour} godz. temu`;
const diffDay = Math.floor(diffHour / 24);
if (diffDay < 30) return `${diffDay} dni temu`;
const diffMonth = Math.floor(diffDay / 30);
if (diffMonth < 12) return `${diffMonth} mies. temu`;
const diffYear = Math.floor(diffMonth / 12);
return `${diffYear} lat temu`;
}
// Kolorowanie poziomu zagrożenia
export function getDangerLevelColor(level) {
if (level <= 3) return 'green';
if (level <= 5) return 'yellow';
if (level <= 7) return 'orange';
return 'red';
}
// Formatowanie poziomu zagrożenia jako tekst
export function formatDangerLevel(level) {
if (level <= 2) return 'Niski';
if (level <= 5) return 'Umiarkowany';
if (level <= 7) return 'Podwyższony';
if (level <= 9) return 'Wysoki';
return 'Krytyczny';
}
// Retry utility - ponowne próby wykonania funkcji w przypadku awarii
export async function retry(fn, options = {}) {
const {
maxRetries = 3,
delay = 1000,
backoffFactor = 2,
retryCondition = error => true
} = options;
let lastError;
for (let attempt = 1; attempt <= maxRetries; attempt++) {
try {
return await fn();
} catch (error) {
// Sprawdzamy, czy ten błąd kwalifikuje się do ponownej próby
if (!retryCondition(error)) {
throw error;
}
lastError = error;
console.log(`Próba ${attempt}/${maxRetries} nie powiodła się. Powód: ${error.message}`);
// Jeśli to była ostatnia próba, nie czekamy
if (attempt === maxRetries) break;
// Czekamy z opóźnieniem eksponencjalnym
const waitTime = delay * Math.pow(backoffFactor, attempt - 1);
await new Promise(resolve => setTimeout(resolve, waitTime));
}
}
throw lastError;
}
// Memoizacja funkcji (buforowanie wyników)
export function memoize(fn, { maxSize = 100, ttl = 60000 } = {}) {
const cache = new Map();
const timestamps = new Map();
return async function(...args) {
// Tworzymy klucz z argumentów
const key = JSON.stringify(args);
// Sprawdzamy, czy wynik jest w pamięci podręcznej i czy nie wygasł
const now = Date.now();
if (cache.has(key)) {
const timestamp = timestamps.get(key);
if (now - timestamp < ttl) {
return cache.get(key);
}
}
// Jeśli pamięć podręczna jest za duża, usuwamy najstarszy element
if (cache.size >= maxSize) {
let oldestKey = null;
let oldestTime = now;
for (const [key, time] of timestamps.entries()) {
if (time < oldestTime) {
oldestKey = key;
oldestTime = time;
}
}
if (oldestKey) {
cache.delete(oldestKey);
timestamps.delete(oldestKey);
}
}
// Pobieramy wynik, dodajemy do pamięci podręcznej i zwracamy
const result = await fn(...args);
cache.set(key, result);
timestamps.set(key, now);
return result;
};
}7. Konfiguracja (config.js)
Plik konfiguracyjny dla naszej aplikacji:
// data/config.js
export const appConfig = {
// Ogólne ustawienia aplikacji
appName: 'Jurassic Tracker',
version: '1.0.0',
// Ustawienia monitorowania
monitoring: {
dinoBehaviorInterval: 60000, // Interwał monitorowania zachowań dinozaurów (ms)
enclosureSecurityInterval: 90000, // Interwał monitorowania bezpieczeństwa wybiegów (ms)
autoStart: true // Automatyczne uruchamianie monitorowania przy starcie
},
// Ustawienia API
api: {
baseUrl: 'https://jurassic-park-api.example.com', // W rzeczywistości używalibyśmy prawdziwego URL
timeout: 10000, // Timeout dla żądań API (ms)
retryCount: 3 // Liczba prób ponownego wykonania nieudanego żądania
},
// Ocena ryzyka dinozaurów
dinorisk: {
dangerousSpecies: ['Tyrannosaurus', 'Velociraptor', 'Spinosaurus', 'Allosaurus', 'Dilophosaurus'],
behaviorRiskMatrix: {
'calm': { base: 1, factor: 0.8 },
'grazing': { base: 1, factor: 0.9 },
'sleeping': { base: 2, factor: 0.7 },
'exploring': { base: 4, factor: 1.0 },
'agitated': { base: 6, factor: 1.2 },
'hunting': { base: 7, factor: 1.5 },
'aggressive': { base: 9, factor: 2.0 }
},
hungerRiskHours: 3, // Liczba godzin, po których głód zaczyna wpływać na ryzyko
hungerRiskFactor: 0.5 // Współczynnik wpływu głodu na ryzyko
},
// Poziomy bezpieczeństwa dla powiadomień
security: {
alertThresholds: {
low: 3,
medium: 5,
high: 7,
critical: 9
},
autoResolveAlerts: false // Czy automatycznie oznaczać alerty jako rozwiązane
}
};
export default appConfig;8. Główny plik aplikacji (index.js)
Na koniec, zapiszmy główny plik naszej aplikacji, który łączy wszystkie moduły:
// index.js
import { appConfig } from './data/config.js';
import * as DinosaurService from './modules/dinosaurs.js';
import * as EnclosureService from './modules/enclosures.js';
import * as MonitoringService from './modules/monitoring.js';
import { formatDate, formatTimeAgo, formatDangerLevel, getDangerLevelColor } from './modules/utils.js';
import { APIError, DinoError, SecurityError, EnclosureBreachError } from './modules/errors/index.js';
console.log(`==========================================`);
console.log(`Witaj w ${appConfig.appName} v${appConfig.version}!`);
console.log(`Inicjalizacja systemów Parku Jurajskiego...`);
console.log(`==========================================`);
// Obsługa błędów na poziomie globalnym
process.on('unhandledRejection', (reason, promise) => {
console.error('Nieobsłużone odrzucenie obietnicy:', reason);
});
process.on('uncaughtException', (error) => {
console.error('Nieobsłużony wyjątek:', error);
// Analiza typów błędów
if (error instanceof EnclosureBreachError) {
console.error(`KRYTYCZNY: Naruszenie wybiegu w sektorze ${error.sector}!`);
console.error(`${error.count} ${error.dinoSpecies} poza wybiegiem!`);
console.error('Uruchamianie protokołu awaryjnego...');
} else if (error instanceof SecurityError) {
console.error(`BEZPIECZEŃSTWO: Problem w sektorze ${error.sector}`);
} else if (error instanceof DinoError) {
console.error(`DINOZAUR: Problem z ${error.species} (ID: ${error.dinoId})`);
} else if (error instanceof APIError) {
console.error(`API: Błąd ${error.statusCode} podczas komunikacji z ${error.endpoint}`);
}
});
// Główna funkcja startowa
async function initializeApp() {
try {
// Rejestrowanie listenera dla alertów
const removeAlertListener = MonitoringService.addAlertListener(alert => {
const { type, data, timestamp } = alert;
console.log(`[ALERT] ${formatDate(timestamp)} - ${type}`);
switch (type) {
case 'DANGEROUS_BEHAVIOR':
console.log(`Dinozaur ${data.species} (ID: ${data.dinoId}) wykazuje niebezpieczne zachowanie: ${data.behavior}`);
console.log(`Poziom zagrożenia: ${formatDangerLevel(data.dangerLevel)}`);
break;
case 'ENCLOSURE_SECURITY':
console.log(`Problem z bezpieczeństwem wybiegu ${data.name} (Sektor ${data.sector})`);
console.log(`Wskaźnik bezpieczeństwa: ${data.securityScore}/100`);
console.log(`Status zasilania: ${data.powerStatus}`);
break;
case 'ENCLOSURE_BREACH':
console.log(`!!! NARUSZENIE WYBIEGU !!!`);
console.log(`Sektor: ${data.sector}, Gatunek: ${data.species}, Liczba: ${data.count}`);
console.log('UWAGA: Wymagana natychmiastowa interwencja!');
break;
default:
console.log('Otrzymano alert:', data);
}
});
// Pobieranie danych początkowych
console.log('Pobieranie danych o dinozaurach...');
const dinosaurs = await DinosaurService.getAllDinosaurs();
console.log(`Załadowano dane ${dinosaurs.length} dinozaurów.`);
console.log('Pobieranie danych o wybiegach...');
const enclosures = await EnclosureService.getAllEnclosures();
console.log(`Załadowano dane ${enclosures.length} wybiegów.`);
// Uruchomienie monitorowania, jeśli jest włączone w konfiguracji
if (appConfig.monitoring.autoStart) {
console.log('Uruchamianie systemu monitorowania...');
MonitoringService.startMonitoring({
dinoBehaviorInterval: appConfig.monitoring.dinoBehaviorInterval,
enclosureSecurityInterval: appConfig.monitoring.enclosureSecurityInterval
});
const status = MonitoringService.getMonitoringStatus();
console.log(`Status monitorowania: ${status.status}`);
console.log(`Aktywne monitory: ${status.activeMonitors.join(', ')}`);
}
console.log('\nSystemy Parku Jurajskiego zostały zainicjalizowane pomyślnie.');
console.log('Rozpoczynam monitorowanie...');
// Przykładowe wywołania API, które mogą zostać użyte przez użytkownika
setTimeout(async () => {
try {
// Karmienie dinozaura
const fedDino = await DinosaurService.feedDinosaur('trx1');
console.log(`Nakarmiono ${fedDino.name} (${fedDino.species})`);
// Inspekcja wybiegu
const inspectedEnclosure = await EnclosureService.inspectEnclosure('enc2');
console.log(`Przeprowadzono inspekcję wybiegu: ${inspectedEnclosure.name} (Sektor ${inspectedEnclosure.sector})`);
// Naprawa systemu zasilania (jeśli jakiś wybieg ma problem)
const enclosureWithPowerIssue = enclosures.find(e => e.powerStatus !== 'active');
if (enclosureWithPowerIssue) {
const repairedEnclosure = await EnclosureService.repairPowerSystem(enclosureWithPowerIssue.id);
console.log(`Naprawiono system zasilania w: ${repairedEnclosure.name}`);
}
} catch (error) {
console.error('Błąd podczas wykonywania operacji demonstracyjnych:', error);
}
}, 5000);
} catch (error) {
console.error('Błąd podczas inicjalizacji aplikacji:', error);
if (error instanceof APIError) {
console.error(`Nie można połączyć się z API: ${error.statusCode} ${error.message}`);
} else {
console.error('Nieoczekiwany błąd:', error.message);
}
console.error('Próba ponownej inicjalizacji za 10 sekund...');
setTimeout(initializeApp, 10000);
}
}
// Uruchomienie aplikacji
initializeApp();
// Funkcja do zatrzymania aplikacji przed zamknięciem
function cleanup() {
console.log('\nZamykanie aplikacji...');
// Zatrzymanie systemu monitorowania
MonitoringService.stopMonitoring();
console.log('Wszystkie systemy monitorowania zostały zatrzymane.');
console.log('Do widzenia!');
process.exit(0);
}
// Obsługa sygnałów zakończenia
process.on('SIGINT', cleanup);
process.on('SIGTERM', cleanup);Uruchomienie aplikacji
W rzeczywistym środowisku moglibyśmy uruchomić tę aplikację za pomocą:
node index.jsPo uruchomieniu, aplikacja:
- Zainicjalizuje wszystkie systemy
- Pobierze dane o dinozaurach i wybiegach
- Uruchomi monitorowanie w tle
- Rozpocznie reagowanie na zdarzenia
Podsumowanie zastosowanych technik
W naszej aplikacji JurassicTracker wykorzystaliśmy wszystkie najważniejsze techniki poznane w tym module:
- ES Modules - Cała aplikacja jest zorganizowana w moduły, które importują i eksportują funkcjonalności
- Asynchroniczność:
- Używamy async/await dla przejrzystej obsługi operacji asynchronicznych
- Wykorzystujemy Promise.all dla równoległego wykonywania operacji
- Obsługujemy opóźnienia i interwały czasowe
- Obsługa błędów:
- Stworzyliśmy hierarchię własnych klas błędów (APIError, DinoError, SecurityError)
- Używamy try/catch bloków dla lokalnej obsługi błędów
- Zaimplementowaliśmy globalną obsługę nieobsłużonych błędów
- Stosujemy technikę retry dla operacji, które mogą być ponowione
- Monitorowanie w tle:
- Używamy setInterval do cyklicznego wykonywania zadań monitorowania
- Implementujemy prosty system powiadomień oparty na wzorcu obserwatora (observer pattern)
- Zarządzanie stanem aplikacji:
- Przechowujemy stan w zmiennych modułowych
- Używamy Map dla efektywnego przechowywania danych
- Implementujemy system buforowania (memoization) dla optymalizacji
Ta aplikacja pokazuje, jak można połączyć wszystkie poznane techniki w funkcjonalny, modularny i odporny na błędy system.
W rzeczywistej aplikacji webowej moglibyśmy dodać warstwę UI (React, Vue, Angular) oraz prawdziwe API backendowe, ale podstawowa struktura i organizacja kodu pozostałyby podobne.
Wnioski
Budowa złożonej aplikacji JavaScript wymaga dobrego zrozumienia:
- Modularyzacji kodu dla łatwiejszego utrzymania
- Asynchronicznych wzorców dla wydajnych operacji
- Obsługi błędów dla odpornej aplikacji
- Monitorowania i logowania dla diagnostyki
Nasz system JurassicTracker, choć jest przykładem dydaktycznym, pokazuje, jak te wszystkie elementy współpracują ze sobą, tworząc solidną aplikację, która mogłaby - z odpowiednimi rozszerzeniami - zostać wykorzystana w prawdziwym Parku Jurajskim. Miejmy jednak nadzieję, że jej systemy bezpieczeństwa działałyby lepiej niż w filmie!
W następnym ćwiczeniu zagłębimy się w strukturyzację kodu w jeszcze większych projektach JavaScript, rozszerzając poznane techniki i wzorce.
Hasła z dokumentacji w tej lekcji
Widzisz błąd w tej lekcji?
Sprawdź się
Odpowiedz na pytania z tej lekcji. Wybierz odpowiedź, a od razu zobaczysz, czy jest poprawna.
1. Jaka jest najlepsza praktyka organizacji modułów w projekcie JavaScript?
Zadania praktyczne w grze
- Edytor kodu
Stwórz DinosaurDatabase z metodami i ParkMonitor z obsługą błędów.
- Układanie w pionie
Uporządkuj warstwy projektu od najniższej do najwyższej: