diff --git a/fdev-ffrontend/.env.development b/fdev-ffrontend/.env.development
deleted file mode 100644
index b44b7f8f..00000000
--- a/fdev-ffrontend/.env.development
+++ /dev/null
@@ -1,23 +0,0 @@
-# API Configuration
-VITE_API_URL=http://localhost:8000/api/v1
-VITE_API_TIMEOUT=30000
-VITE_API_RETRIES=3
-VITE_API_RETRY_DELAY=1000
-VITE_API_LOGGING=true
-VITE_API_CACHING=true
-VITE_API_CACHE_TIMEOUT=300000
-
-# Feature Flags
-VITE_ENABLE_WEBSOCKETS=false
-VITE_ENABLE_OFFLINE=false
-VITE_ENABLE_OPTIMISTIC_UPDATES=true
-VITE_ENABLE_DEDUPLICATION=true
-VITE_ENABLE_METRICS=false
-
-# Stripe Configuration (Spanish Market)
-VITE_STRIPE_PUBLISHABLE_KEY=pk_test_example_key_for_development
-VITE_STRIPE_WEBHOOK_SECRET=whsec_example_webhook_secret_for_development
-
-# Development Flags
-VITE_BYPASS_PAYMENT=true
-VITE_DEV_MODE=true
\ No newline at end of file
diff --git a/fdev-ffrontend/.env.production b/fdev-ffrontend/.env.production
deleted file mode 100644
index f6bda9e6..00000000
--- a/fdev-ffrontend/.env.production
+++ /dev/null
@@ -1,23 +0,0 @@
-# API Configuration
-VITE_API_URL=https://api.pania.es/api/v1
-VITE_API_TIMEOUT=30000
-VITE_API_RETRIES=3
-VITE_API_RETRY_DELAY=1000
-VITE_API_LOGGING=false
-VITE_API_CACHING=true
-VITE_API_CACHE_TIMEOUT=300000
-
-# Feature Flags
-VITE_ENABLE_WEBSOCKETS=true
-VITE_ENABLE_OFFLINE=true
-VITE_ENABLE_OPTIMISTIC_UPDATES=true
-VITE_ENABLE_DEDUPLICATION=true
-VITE_ENABLE_METRICS=true
-
-# Stripe Configuration (Spanish Market)
-VITE_STRIPE_PUBLISHABLE_KEY=pk_live_your_production_stripe_key
-VITE_STRIPE_WEBHOOK_SECRET=whsec_your_production_webhook_secret
-
-# Development Flags (DISABLED IN PRODUCTION)
-VITE_BYPASS_PAYMENT=false
-VITE_DEV_MODE=false
\ No newline at end of file
diff --git a/fdev-ffrontend/Dockerfile.development b/fdev-ffrontend/Dockerfile.development
deleted file mode 100644
index 6069bda8..00000000
--- a/fdev-ffrontend/Dockerfile.development
+++ /dev/null
@@ -1,38 +0,0 @@
-# frontend/Dockerfile.development - FIXED VERSION
-FROM node:18-alpine
-
-# Install curl for healthchecks
-RUN apk add --no-cache curl
-
-# Set working directory
-WORKDIR /app
-
-# Create non-root user for security but don't switch yet
-RUN addgroup -g 1001 -S nodejs && \
- adduser -S reactjs -u 1001 -G nodejs
-
-# Copy package files first (better caching)
-COPY package*.json ./
-
-# Install all dependencies (including dev dependencies) as root
-RUN npm ci --verbose && \
- npm cache clean --force
-
-# Copy source code
-COPY . .
-
-# Change ownership of all files to the non-root user
-RUN chown -R reactjs:nodejs /app
-
-# Now switch to non-root user
-USER reactjs
-
-# Expose port 3000 (Vite default)
-EXPOSE 3000
-
-# Add healthcheck
-HEALTHCHECK --interval=30s --timeout=10s --start-period=30s --retries=3 \
- CMD curl -f http://localhost:3000/ || exit 1
-
-# Start development server with host binding
-CMD ["npm", "run", "dev", "--", "--host", "0.0.0.0"]
\ No newline at end of file
diff --git a/fdev-ffrontend/Dockerfile.production b/fdev-ffrontend/Dockerfile.production
deleted file mode 100644
index 98ba917c..00000000
--- a/fdev-ffrontend/Dockerfile.production
+++ /dev/null
@@ -1,41 +0,0 @@
-# frontend/Dockerfile.production
-# Multi-stage build for production
-
-# Build stage
-FROM node:18-alpine as builder
-
-WORKDIR /app
-
-# Copy package files
-COPY package*.json ./
-
-# Install dependencies
-RUN npm ci --only=production
-
-# Copy source code
-COPY . .
-
-# Build the application
-RUN npm run build
-
-# Production stage
-FROM nginx:alpine
-
-# Install curl for healthchecks
-RUN apk add --no-cache curl
-
-# Copy built app from builder stage
-COPY --from=builder /app/dist /usr/share/nginx/html
-
-# Copy nginx configuration
-COPY nginx.conf /etc/nginx/nginx.conf
-
-# Expose port 80
-EXPOSE 80
-
-# Add healthcheck
-HEALTHCHECK --interval=30s --timeout=3s --start-period=10s --retries=3 \
- CMD curl -f http://localhost/ || exit 1
-
-# Start nginx
-CMD ["nginx", "-g", "daemon off;"]
\ No newline at end of file
diff --git a/fdev-ffrontend/index.html b/fdev-ffrontend/index.html
deleted file mode 100644
index 66ef8f1b..00000000
--- a/fdev-ffrontend/index.html
+++ /dev/null
@@ -1,170 +0,0 @@
-
-
-
-
-
-
-
- PanIA - Inteligencia Artificial para tu Panadería en Madrid
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
🥖
-
Cargando PanIA...
-
-
-
-
- {/* Global Toast Notifications */}
-
-
-
- );
-};
-
-const App: React.FC = () => {
- return (
-
-
-
- );
-};
-
-export default App;
\ No newline at end of file
diff --git a/fdev-ffrontend/src/api/README.md b/fdev-ffrontend/src/api/README.md
deleted file mode 100644
index 45a6e599..00000000
--- a/fdev-ffrontend/src/api/README.md
+++ /dev/null
@@ -1,85 +0,0 @@
-frontend/src/api/
-├── client/ # HTTP client configuration
-│ ├── index.ts # Main API client
-│ ├── config.ts # Client configuration
-│ ├── interceptors.ts # Request/response interceptors
-│ └── types.ts # Client-specific types
-├── services/ # Service-specific API calls
-│ ├── index.ts # Export all services
-│ ├── auth.service.ts # Authentication operations
-│ ├── tenant.service.ts # Tenant management
-│ ├── data.service.ts # Data operations
-│ ├── training.service.ts # ML training operations
-│ ├── forecasting.service.ts # Forecasting operations
-│ └── notification.service.ts # Notification operations
-├── types/ # TypeScript definitions
-│ ├── index.ts # Re-export all types
-│ ├── common.ts # Common API types
-│ ├── auth.ts # Authentication types
-│ ├── tenant.ts # Tenant types
-│ ├── data.ts # Data types
-│ ├── training.ts # Training types
-│ ├── forecasting.ts # Forecasting types
-│ └── notification.ts # Notification types
-├── hooks/ # React hooks for API calls
-│ ├── index.ts # Export all hooks
-│ ├── useAuth.ts # Authentication hooks
-│ ├── useTenant.ts # Tenant hooks
-│ ├── useData.ts # Data hooks
-│ ├── useTraining.ts # Training hooks
-│ ├── useForecast.ts # Forecasting hooks
-│ └── useNotification.ts # Notification hooks
-├── utils/ # API utilities
-│ ├── index.ts # Export utilities
-│ ├── response.ts # Response handling
-│ ├── error.ts # Error handling
-│ ├── validation.ts # Request validation
-│ └── transform.ts # Data transformation
-├── websocket/ # WebSocket management
-│ ├── index.ts # WebSocket exports
-│ ├── manager.ts # WebSocket manager
-│ ├── types.ts # WebSocket types
-│ └── hooks.ts # WebSocket hooks
-└── index.ts # Main API exports
-```
-
-## 🎯 Key Improvements
-
-### 1. **Modern Architecture Patterns**
-- **Service Layer Pattern**: Clean separation of concerns
-- **Repository Pattern**: Consistent data access layer
-- **Factory Pattern**: Flexible service instantiation
-- **Observer Pattern**: Event-driven updates
-
-### 2. **Type Safety**
-- **Strict TypeScript**: Full type coverage
-- **Schema Validation**: Runtime type checking
-- **Generic Types**: Reusable type definitions
-- **Union Types**: Precise API responses
-
-### 3. **Error Handling**
-- **Centralized Error Management**: Consistent error handling
-- **Error Recovery**: Automatic retry mechanisms
-- **User-Friendly Messages**: Localized error messages
-- **Error Boundaries**: Component-level error isolation
-
-### 4. **Performance Optimization**
-- **Request Caching**: Intelligent cache management
-- **Request Deduplication**: Prevent duplicate calls
-- **Optimistic Updates**: Immediate UI feedback
-- **Background Sync**: Offline-first approach
-
-### 5. **Developer Experience**
-- **Auto-completion**: Full IntelliSense support
-- **Type-safe Hooks**: React hooks with types
-- **Error Prevention**: Compile-time error detection
-- **Documentation**: Comprehensive JSDoc comments
-
-## 🚀 Implementation Benefits
-
-1. **Maintainability**: Modular structure for easy updates
-2. **Scalability**: Easy to add new services and endpoints
-3. **Testability**: Isolated services for unit testing
-4. **Reusability**: Shared utilities and types
-5. **Type Safety**: Prevent runtime errors
-6. **Developer Productivity**: IntelliSense and auto-completion
\ No newline at end of file
diff --git a/fdev-ffrontend/src/api/client/config.ts b/fdev-ffrontend/src/api/client/config.ts
deleted file mode 100644
index 0b4b9c8f..00000000
--- a/fdev-ffrontend/src/api/client/config.ts
+++ /dev/null
@@ -1,142 +0,0 @@
-// frontend/src/api/client/config.ts
-/**
- * API Client Configuration
- * Centralized configuration for all API clients
- */
-
-export interface ApiConfig {
- baseURL: string;
- timeout: number;
- retries: number;
- retryDelay: number;
- enableLogging: boolean;
- enableCaching: boolean;
- cacheTimeout: number;
-}
-
-export interface ServiceEndpoints {
- auth: string;
- tenant: string;
- data: string;
- training: string;
- forecasting: string;
- notification: string;
-}
-
-// Environment-based configuration
-const getEnvironmentConfig = (): ApiConfig => {
- // Use import.meta.env instead of process.env for Vite
- const isDevelopment = import.meta.env.DEV;
- const isProduction = import.meta.env.PROD;
-
- return {
- baseURL: import.meta.env.VITE_API_URL || 'http://localhost:8000/api/v1',
- timeout: parseInt(import.meta.env.VITE_API_TIMEOUT || '30000'),
- retries: parseInt(import.meta.env.VITE_API_RETRIES || '3'),
- retryDelay: parseInt(import.meta.env.VITE_API_RETRY_DELAY || '1000'),
- enableLogging: isDevelopment || import.meta.env.VITE_API_LOGGING === 'true',
- enableCaching: import.meta.env.VITE_API_CACHING !== 'false',
- cacheTimeout: parseInt(import.meta.env.VITE_API_CACHE_TIMEOUT || '300000'), // 5 minutes
- };
-};
-
-export const apiConfig: ApiConfig = getEnvironmentConfig();
-
-// Service endpoint configuration
-export const serviceEndpoints: ServiceEndpoints = {
- auth: '/auth',
- tenant: '/tenants',
- data: '/tenants', // Data operations are tenant-scoped
- training: '/tenants', // Training operations are tenant-scoped
- forecasting: '/tenants', // Forecasting operations are tenant-scoped
- notification: '/tenants', // Notification operations are tenant-scoped
-};
-
-// HTTP status codes
-export const HttpStatus = {
- OK: 200,
- CREATED: 201,
- NO_CONTENT: 204,
- BAD_REQUEST: 400,
- UNAUTHORIZED: 401,
- FORBIDDEN: 403,
- NOT_FOUND: 404,
- CONFLICT: 409,
- UNPROCESSABLE_ENTITY: 422,
- INTERNAL_SERVER_ERROR: 500,
- BAD_GATEWAY: 502,
- SERVICE_UNAVAILABLE: 503,
-} as const;
-
-// Request timeout configuration
-export const RequestTimeouts = {
- SHORT: 5000, // 5 seconds - for quick operations
- MEDIUM: 15000, // 15 seconds - for normal operations
- LONG: 60000, // 1 minute - for file uploads
- EXTENDED: 300000, // 5 minutes - for training operations
-} as const;
-
-// Cache configuration
-export interface CacheConfig {
- defaultTTL: number;
- maxSize: number;
- strategies: {
- user: number;
- tenant: number;
- data: number;
- forecast: number;
- };
-}
-
-export const cacheConfig: CacheConfig = {
- defaultTTL: 300000, // 5 minutes
- maxSize: 100, // Maximum cached items
- strategies: {
- user: 600000, // 10 minutes
- tenant: 1800000, // 30 minutes
- data: 300000, // 5 minutes
- forecast: 600000, // 10 minutes
- },
-};
-
-// Retry configuration
-export interface RetryConfig {
- attempts: number;
- delay: number;
- backoff: number;
- retryCondition: (error: any) => boolean;
-}
-
-export const retryConfig: RetryConfig = {
- attempts: 3,
- delay: 1000,
- backoff: 2, // Exponential backoff multiplier
- retryCondition: (error: any) => {
- // Retry on network errors and specific HTTP status codes
- if (!error.response) return true; // Network error
- const status = error.response.status;
- return status >= 500 || status === 408 || status === 429;
- },
-};
-
-// API versioning
-export const ApiVersion = {
- V1: 'v1',
- CURRENT: 'v1',
-} as const;
-
-export interface FeatureFlags {
- enableWebSockets: boolean;
- enableOfflineMode: boolean;
- enableOptimisticUpdates: boolean;
- enableRequestDeduplication: boolean;
- enableMetrics: boolean;
-}
-
-export const featureFlags: FeatureFlags = {
- enableWebSockets: import.meta.env.VITE_ENABLE_WEBSOCKETS === 'true',
- enableOfflineMode: import.meta.env.VITE_ENABLE_OFFLINE === 'true',
- enableOptimisticUpdates: import.meta.env.VITE_ENABLE_OPTIMISTIC_UPDATES !== 'false',
- enableRequestDeduplication: import.meta.env.VITE_ENABLE_DEDUPLICATION !== 'false',
- enableMetrics: import.meta.env.VITE_ENABLE_METRICS === 'true',
-};
diff --git a/fdev-ffrontend/src/api/client/index.ts b/fdev-ffrontend/src/api/client/index.ts
deleted file mode 100644
index 23959b2b..00000000
--- a/fdev-ffrontend/src/api/client/index.ts
+++ /dev/null
@@ -1,578 +0,0 @@
-// frontend/src/api/client/index.ts
-/**
- * Enhanced API Client with modern features
- * Supports caching, retries, optimistic updates, and more
- */
-
-import {
- ApiResponse,
- ApiError,
- RequestConfig,
- UploadConfig,
- UploadProgress,
- RequestInterceptor,
- ResponseInterceptor,
- CacheEntry,
- RequestMetrics,
-} from './types';
-import { apiConfig, retryConfig, cacheConfig, featureFlags } from './config';
-
-export class ApiClient {
- private baseURL: string;
- private cache = new Map();
- private pendingRequests = new Map>();
- private requestInterceptors: RequestInterceptor[] = [];
- private responseInterceptors: ResponseInterceptor[] = [];
- private metrics: RequestMetrics[] = [];
-
-constructor(baseURL?: string) {
- this.baseURL = baseURL || apiConfig.baseURL;
- // ✅ CRITICAL FIX: Remove trailing slash
- this.baseURL = this.baseURL.replace(/\/+$/, '');
- console.log('🔧 API Client initialized with baseURL:', this.baseURL);
-}
-
-private buildURL(endpoint: string): string {
- // Remove leading slash from endpoint if present to avoid double slashes
- const cleanEndpoint = endpoint.startsWith('/') ? endpoint : `/${endpoint}`;
- const fullURL = `${this.baseURL}${cleanEndpoint}`;
-
- // ✅ DEBUG: Log URL construction
- console.log('🔗 Building URL:', {
- baseURL: this.baseURL,
- endpoint: cleanEndpoint,
- fullURL: fullURL
- });
-
- return fullURL;
- }
-
- /**
- * Add request interceptor
- */
- addRequestInterceptor(interceptor: RequestInterceptor): void {
- this.requestInterceptors.push(interceptor);
- }
-
- /**
- * Add response interceptor
- */
- addResponseInterceptor(interceptor: ResponseInterceptor): void {
- this.responseInterceptors.push(interceptor);
- }
-
- /**
- * Generate cache key for request
- */
- private getCacheKey(url: string, config?: RequestConfig): string {
- const method = config?.method || 'GET';
- const params = config?.params ? JSON.stringify(config.params) : '';
- return `${method}:${url}:${params}`;
- }
-
- /**
- * Check if response is cached and valid
- */
- private getCachedResponse(key: string): T | null {
- if (!featureFlags.enableRequestDeduplication && !apiConfig.enableCaching) {
- return null;
- }
-
- const cached = this.cache.get(key);
- if (!cached) return null;
-
- const now = Date.now();
- if (now - cached.timestamp > cached.ttl) {
- this.cache.delete(key);
- return null;
- }
-
- return cached.data;
- }
-
- /**
- * Cache response data
- */
- private setCachedResponse(key: string, data: T, ttl?: number): void {
- if (!apiConfig.enableCaching) return;
-
- const cacheTTL = ttl || cacheConfig.defaultTTL;
- this.cache.set(key, {
- data,
- timestamp: Date.now(),
- ttl: cacheTTL,
- key,
- });
-
- // Cleanup old cache entries if cache is full
- if (this.cache.size > cacheConfig.maxSize) {
- const oldestKey = this.cache.keys().next().value;
- this.cache.delete(oldestKey);
- }
- }
-
- /**
- * Apply request interceptors
- */
- private async applyRequestInterceptors(config: RequestConfig): Promise {
- let modifiedConfig = { ...config };
-
- for (const interceptor of this.requestInterceptors) {
- if (interceptor.onRequest) {
- try {
- modifiedConfig = await interceptor.onRequest(modifiedConfig);
- } catch (error) {
- if (interceptor.onRequestError) {
- await interceptor.onRequestError(error);
- }
- throw error;
- }
- }
- }
-
- return modifiedConfig;
- }
-
- /**
- * Apply response interceptors
- */
- private async applyResponseInterceptors(response: ApiResponse): Promise> {
- let modifiedResponse = { ...response };
-
- for (const interceptor of this.responseInterceptors) {
- if (interceptor.onResponse) {
- try {
- modifiedResponse = await interceptor.onResponse(modifiedResponse);
- } catch (error) {
- if (interceptor.onResponseError) {
- await interceptor.onResponseError(error);
- }
- throw error;
- }
- }
- }
-
- return modifiedResponse;
- }
-
- /**
- * Retry failed requests with exponential backoff
- */
- private async retryRequest(
- requestFn: () => Promise,
- attempts: number = retryConfig.attempts
- ): Promise {
- try {
- return await requestFn();
- } catch (error) {
- if (attempts <= 0 || !retryConfig.retryCondition(error)) {
- throw error;
- }
-
- const delay = retryConfig.delay * Math.pow(retryConfig.backoff, retryConfig.attempts - attempts);
- await new Promise(resolve => setTimeout(resolve, delay));
-
- return this.retryRequest(requestFn, attempts - 1);
- }
- }
-
- /**
- * Record request metrics
- */
- private recordMetrics(metrics: Partial): void {
- if (!featureFlags.enableMetrics) return;
-
- const completeMetrics: RequestMetrics = {
- url: '',
- method: 'GET',
- duration: 0,
- status: 0,
- size: 0,
- timestamp: Date.now(),
- cached: false,
- retries: 0,
- ...metrics,
- };
-
- this.metrics.push(completeMetrics);
-
- // Keep only recent metrics (last 1000 requests)
- if (this.metrics.length > 1000) {
- this.metrics = this.metrics.slice(-1000);
- }
- }
-
- /**
- * Core request method with all features
- */
- async request(endpoint: string, config: RequestConfig = {}): Promise {
- const startTime = Date.now();
- const url = this.buildURL(endpoint);
- const method = config.method || 'GET';
-
- console.log('🚀 Making API request:', {
- method,
- endpoint,
- url,
- config
- });
-
- // Apply request interceptors
- const modifiedConfig = await this.applyRequestInterceptors(config);
-
- // Generate cache key
- const cacheKey = this.getCacheKey(endpoint, modifiedConfig);
-
- // Check cache for GET requests
- if (method === 'GET' && (config.cache !== false)) {
- const cached = this.getCachedResponse(cacheKey);
- if (cached) {
- this.recordMetrics({
- url: endpoint,
- method,
- duration: Date.now() - startTime,
- status: 200,
- cached: true,
- });
- return cached;
- }
- }
-
- // Request deduplication for concurrent requests
- if (featureFlags.enableRequestDeduplication && method === 'GET') {
- const pendingRequest = this.pendingRequests.get(cacheKey);
- if (pendingRequest) {
- return pendingRequest;
- }
- }
-
- // Create request promise
- const requestPromise = this.retryRequest(async () => {
- const headers: Record = {
- 'Content-Type': 'application/json',
- ...modifiedConfig.headers,
- };
-
- const fetchConfig: RequestInit = {
- method,
- headers,
- signal: AbortSignal.timeout(modifiedConfig.timeout || apiConfig.timeout),
- };
-
- // Add body for non-GET requests
- if (method !== 'GET' && modifiedConfig.body) {
- if (modifiedConfig.body instanceof FormData) {
- // Remove Content-Type for FormData (let browser set it with boundary)
- delete headers['Content-Type'];
- fetchConfig.body = modifiedConfig.body;
- } else {
- fetchConfig.body = typeof modifiedConfig.body === 'string'
- ? modifiedConfig.body
- : JSON.stringify(modifiedConfig.body);
- }
- }
-
- // Add query parameters
- const urlWithParams = new URL(url);
- if (modifiedConfig.params) {
- Object.entries(modifiedConfig.params).forEach(([key, value]) => {
- if (value !== undefined && value !== null) {
- urlWithParams.searchParams.append(key, String(value));
- }
- });
- }
-
- const response = await fetch(urlWithParams.toString(), fetchConfig);
-
- if (!response.ok) {
- const errorText = await response.text();
- let errorData: ApiError;
-
- try {
- errorData = JSON.parse(errorText);
- } catch {
- errorData = {
- message: `HTTP ${response.status}: ${response.statusText}`,
- detail: errorText,
- code: `HTTP_${response.status}`,
- };
- }
-
- const error = new Error(errorData.message || 'Request failed');
- (error as any).response = { status: response.status, data: errorData };
- throw error;
- }
-
- const responseData = await response.json();
- console.log('🔍 Raw responseData from fetch:', responseData);
-
- // Apply response interceptors
- const processedResponse = await this.applyResponseInterceptors(responseData);
- console.log('🔍 processedResponse after interceptors:', processedResponse);
-
- return processedResponse;
- });
-
- // Store pending request for deduplication
- if (featureFlags.enableRequestDeduplication && method === 'GET') {
- this.pendingRequests.set(cacheKey, requestPromise);
- }
-
- try {
- const result = await requestPromise;
-
- // Cache successful GET responses
- if (method === 'GET' && config.cache !== false) {
- this.setCachedResponse(cacheKey, result, config.cacheTTL);
- }
-
- // Record metrics
- this.recordMetrics({
- url: endpoint,
- method,
- duration: Date.now() - startTime,
- status: 200,
- size: JSON.stringify(result).length,
- });
-
- // Handle both wrapped and unwrapped responses
- // If result has a 'data' property, return it; otherwise return the result itself
- console.log('🔍 Final result before return:', result);
- console.log('🔍 Result has data property?', result && typeof result === 'object' && 'data' in result);
-
- if (result && typeof result === 'object' && 'data' in result) {
- console.log('🔍 Returning result.data:', result.data);
- return result.data as T;
- }
- console.log('🔍 Returning raw result:', result);
- return result as T;
- } catch (error) {
- // Record error metrics
- this.recordMetrics({
- url: endpoint,
- method,
- duration: Date.now() - startTime,
- status: (error as any).response?.status || 0,
- });
-
- throw error;
- } finally {
- // Clean up pending request
- if (featureFlags.enableRequestDeduplication && method === 'GET') {
- this.pendingRequests.delete(cacheKey);
- }
- }
- }
-
- /**
- * Convenience methods for HTTP verbs
- */
- async get(endpoint: string, config?: RequestConfig): Promise {
- return this.request(endpoint, { ...config, method: 'GET' });
- }
-
- async post(endpoint: string, data?: any, config?: RequestConfig): Promise {
- return this.request(endpoint, {
- ...config,
- method: 'POST',
- body: data
- });
- }
-
- async put(endpoint: string, data?: any, config?: RequestConfig): Promise {
- return this.request(endpoint, {
- ...config,
- method: 'PUT',
- body: data
- });
- }
-
- async patch(endpoint: string, data?: any, config?: RequestConfig): Promise {
- return this.request(endpoint, {
- ...config,
- method: 'PATCH',
- body: data
- });
- }
-
- async delete(endpoint: string, config?: RequestConfig): Promise {
- return this.request(endpoint, { ...config, method: 'DELETE' });
- }
-
- /**
- * Raw request that returns the Response object for binary data
- */
- async getRaw(endpoint: string, config?: RequestConfig): Promise {
- const url = this.buildURL(endpoint);
- const modifiedConfig = await this.applyRequestInterceptors(config || {});
-
- const headers: Record = {
- ...modifiedConfig.headers,
- };
-
- const fetchConfig: RequestInit = {
- method: 'GET',
- headers,
- signal: AbortSignal.timeout(modifiedConfig.timeout || apiConfig.timeout),
- };
-
- // Add query parameters
- const urlWithParams = new URL(url);
- if (modifiedConfig.params) {
- Object.entries(modifiedConfig.params).forEach(([key, value]) => {
- if (value !== undefined && value !== null) {
- urlWithParams.searchParams.append(key, String(value));
- }
- });
- }
-
- const response = await fetch(urlWithParams.toString(), fetchConfig);
-
- if (!response.ok) {
- const errorText = await response.text();
- let errorData: ApiError;
-
- try {
- errorData = JSON.parse(errorText);
- } catch {
- errorData = {
- message: `HTTP ${response.status}: ${response.statusText}`,
- detail: errorText,
- code: `HTTP_${response.status}`,
- };
- }
-
- const error = new Error(errorData.message || 'Request failed');
- (error as any).response = { status: response.status, data: errorData };
- throw error;
- }
-
- return response;
- }
-
- /**
- * File upload with progress tracking
- */
- async upload(
- endpoint: string,
- file: File,
- additionalData?: Record,
- config?: UploadConfig
- ): Promise {
- const formData = new FormData();
- formData.append('file', file);
-
- if (additionalData) {
- Object.entries(additionalData).forEach(([key, value]) => {
- formData.append(key, String(value));
- });
- }
-
- // For file uploads, we need to use XMLHttpRequest for progress tracking
- if (config?.onProgress) {
- return new Promise((resolve, reject) => {
- const xhr = new XMLHttpRequest();
-
- xhr.upload.addEventListener('progress', (event) => {
- if (event.lengthComputable && config.onProgress) {
- const progress: UploadProgress = {
- loaded: event.loaded,
- total: event.total,
- percentage: Math.round((event.loaded / event.total) * 100),
- };
- config.onProgress(progress);
- }
- });
-
- xhr.addEventListener('load', () => {
- if (xhr.status >= 200 && xhr.status < 300) {
- try {
- const result = JSON.parse(xhr.responseText);
- resolve(result);
- } catch {
- resolve(xhr.responseText as any);
- }
- } else {
- reject(new Error(`Upload failed: ${xhr.status} ${xhr.statusText}`));
- }
- });
-
- xhr.addEventListener('error', () => {
- reject(new Error('Upload failed'));
- });
-
- xhr.open('POST', `${this.baseURL}${endpoint}`);
-
- // Add headers (excluding Content-Type for FormData)
- if (config?.headers) {
- Object.entries(config.headers).forEach(([key, value]) => {
- if (key.toLowerCase() !== 'content-type') {
- xhr.setRequestHeader(key, value);
- }
- });
- }
-
- xhr.send(formData);
- });
- }
-
- // Fallback to regular request for uploads without progress
- return this.request(endpoint, {
- ...config,
- method: 'POST',
- body: formData,
- });
- }
-
- /**
- * Clear cache
- */
- clearCache(pattern?: string): void {
- if (pattern) {
- // Clear cache entries matching pattern
- const regex = new RegExp(pattern);
- Array.from(this.cache.keys())
- .filter(key => regex.test(key))
- .forEach(key => this.cache.delete(key));
- } else {
- // Clear all cache
- this.cache.clear();
- }
- }
-
- /**
- * Get client metrics
- */
- getMetrics() {
- if (!featureFlags.enableMetrics) {
- return {
- totalRequests: 0,
- successfulRequests: 0,
- failedRequests: 0,
- averageResponseTime: 0,
- cacheHitRate: 0,
- errorRate: 0,
- };
- }
-
- const total = this.metrics.length;
- const successful = this.metrics.filter(m => m.status >= 200 && m.status < 300).length;
- const cached = this.metrics.filter(m => m.cached).length;
- const averageTime = total > 0
- ? this.metrics.reduce((sum, m) => sum + m.duration, 0) / total
- : 0;
-
- return {
- totalRequests: total,
- successfulRequests: successful,
- failedRequests: total - successful,
- averageResponseTime: Math.round(averageTime),
- cacheHitRate: total > 0 ? Math.round((cached / total) * 100) : 0,
- errorRate: total > 0 ? Math.round(((total - successful) / total) * 100) : 0,
- };
- }
-}
-
-// Default API client instance
-console.log('🔧 Creating default API client...');
-export const apiClient = new ApiClient();
\ No newline at end of file
diff --git a/fdev-ffrontend/src/api/client/interceptors.ts b/fdev-ffrontend/src/api/client/interceptors.ts
deleted file mode 100644
index 59c87a11..00000000
--- a/fdev-ffrontend/src/api/client/interceptors.ts
+++ /dev/null
@@ -1,488 +0,0 @@
-// frontend/src/api/client/interceptors.ts
-/**
- * Request and Response Interceptors
- * Handles authentication, logging, error handling, etc.
- */
-
-import { apiClient } from './index';
-import type { RequestConfig, ApiResponse } from './types';
-import { ApiErrorHandler } from '../utils';
-
-/**
- * Authentication Interceptor
- * Automatically adds authentication headers to requests
- */
-class AuthInterceptor {
- static isTokenExpired(token: string): boolean {
- try {
- const payload = JSON.parse(atob(token.split('.')[1]));
- const currentTime = Math.floor(Date.now() / 1000);
- return payload.exp <= currentTime;
- } catch (error) {
- console.warn('Error parsing token:', error);
- return true; // Treat invalid tokens as expired
- }
- }
-
- static isTokenExpiringSoon(token: string, bufferMinutes: number = 5): boolean {
- try {
- const payload = JSON.parse(atob(token.split('.')[1]));
- const currentTime = Math.floor(Date.now() / 1000);
- const bufferSeconds = bufferMinutes * 60;
- return payload.exp <= (currentTime + bufferSeconds);
- } catch (error) {
- console.warn('Error parsing token for expiration check:', error);
- return true;
- }
- }
-
- static async refreshTokenIfNeeded(): Promise {
- const token = localStorage.getItem('auth_token');
- const refreshToken = localStorage.getItem('refresh_token');
-
- if (!token || !refreshToken) {
- return;
- }
-
- // If token is expiring within 5 minutes, proactively refresh
- if (this.isTokenExpiringSoon(token, 5)) {
- try {
- const baseURL = (apiClient as any).baseURL || window.location.origin;
- const response = await fetch(`${baseURL}/api/v1/auth/refresh`, {
- method: 'POST',
- headers: { 'Content-Type': 'application/json' },
- body: JSON.stringify({ refresh_token: refreshToken }),
- });
-
- if (response.ok) {
- const data = await response.json();
- localStorage.setItem('auth_token', data.access_token);
- if (data.refresh_token) {
- localStorage.setItem('refresh_token', data.refresh_token);
- }
- } else {
- console.warn('Token refresh failed:', response.status);
- }
- } catch (error) {
- console.warn('Token refresh error:', error);
- }
- }
- }
-
- static setup() {
- apiClient.addRequestInterceptor({
- onRequest: async (config: RequestConfig) => {
- // Proactively refresh token if needed
- await this.refreshTokenIfNeeded();
-
- let token = localStorage.getItem('auth_token');
-
- if (token) {
- // Check if token is expired
- if (this.isTokenExpired(token)) {
- console.warn('Token expired, removing from storage');
- localStorage.removeItem('auth_token');
- token = null;
- }
- }
-
- if (token) {
- config.headers = {
- ...config.headers,
- Authorization: `Bearer ${token}`,
- };
- } else {
- console.warn('No valid auth token found - authentication required');
- }
-
- return config;
- },
-
- onRequestError: async (error: any) => {
- console.error('Request interceptor error:', error);
- throw error;
- },
- });
- }
-}
-
-/**
- * Logging Interceptor
- * Logs API requests and responses for debugging
- */
-class LoggingInterceptor {
- static setup() {
- apiClient.addRequestInterceptor({
- onRequest: async (config: RequestConfig) => {
- const requestId = `req_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
-
- console.group(`🚀 API Request [${requestId}]`);
- console.log('Method:', config.method);
- console.log('URL:', config.url);
- console.log('Headers:', config.headers);
- if (config.body && config.method !== 'GET') {
- console.log('Body:', config.body);
- }
- if (config.params) {
- console.log('Params:', config.params);
- }
- console.groupEnd();
-
- // Add request ID to config for response correlation
- config.headers = {
- ...config.headers,
- 'X-Request-ID': requestId,
- };
-
- return config;
- },
- });
-
- apiClient.addResponseInterceptor({
- onResponse: async (response: ApiResponse) => {
- const requestId = response.meta?.requestId || 'unknown';
-
- console.group(`✅ API Response [${requestId}]`);
- console.log('Status:', response.status);
- console.log('Data:', response.data);
- if (response.message) {
- console.log('Message:', response.message);
- }
- console.groupEnd();
-
- return response;
- },
-
- onResponseError: async (error: any) => {
- const requestId = error?.config?.headers?.[`X-Request-ID`] || 'unknown';
-
- console.group(`❌ API Error [${requestId}]`);
- console.error('Status:', error?.response?.status);
- console.error('Error:', ApiErrorHandler.formatError(error));
- console.error('Full Error:', error);
- console.groupEnd();
-
- throw error;
- },
- });
- }
-}
-
-/**
- * Tenant Context Interceptor
- * Automatically adds tenant context to tenant-scoped requests
- */
-class TenantInterceptor {
- private static currentTenantId: string | null = null;
-
- static setCurrentTenant(tenantId: string | null) {
- this.currentTenantId = tenantId;
- }
-
- static getCurrentTenant(): string | null {
- return this.currentTenantId;
- }
-
- static setup() {
- apiClient.addRequestInterceptor({
- onRequest: async (config: RequestConfig) => {
- // Add tenant context to tenant-scoped endpoints
- if (this.currentTenantId && this.isTenantScopedEndpoint(config.url)) {
- config.headers = {
- ...config.headers,
- 'X-Tenant-ID': this.currentTenantId,
- };
- }
-
- return config;
- },
- });
- }
-
- private static isTenantScopedEndpoint(url?: string): boolean {
- if (!url) return false;
- return url.includes('/tenants/') ||
- url.includes('/training/') ||
- url.includes('/forecasts/') ||
- url.includes('/notifications/');
- }
-}
-
-/**
- * Error Recovery Interceptor
- * Handles automatic token refresh and retry logic
- */
-class ErrorRecoveryInterceptor {
- private static isRefreshing = false;
- private static failedQueue: Array<{
- resolve: (token: string) => void;
- reject: (error: any) => void;
- }> = [];
-
- static setup() {
- apiClient.addResponseInterceptor({
- onResponseError: async (error: any) => {
- const originalRequest = error.config;
-
- // Handle 401 errors with token refresh
- if (error?.response?.status === 401 && !originalRequest._retry) {
- if (this.isRefreshing) {
- // Queue the request while refresh is in progress
- return new Promise((resolve, reject) => {
- this.failedQueue.push({ resolve, reject });
- }).then(token => {
- return this.retryRequestWithNewToken(originalRequest, token as string);
- }).catch(err => {
- throw err;
- });
- }
-
- originalRequest._retry = true;
- this.isRefreshing = true;
-
- try {
- const refreshToken = localStorage.getItem('refresh_token');
-
- if (!refreshToken) {
- throw new Error('No refresh token available');
- }
-
- // Use direct fetch to avoid interceptor recursion
- const baseURL = (apiClient as any).baseURL || window.location.origin;
- const response = await fetch(`${baseURL}/api/v1/auth/refresh`, {
- method: 'POST',
- headers: {
- 'Content-Type': 'application/json',
- },
- body: JSON.stringify({ refresh_token: refreshToken }),
- });
-
- if (!response.ok) {
- throw new Error(`Token refresh failed: ${response.status}`);
- }
-
- const data = await response.json();
- const newToken = data.access_token;
-
- if (!newToken) {
- throw new Error('No access token received');
- }
-
- localStorage.setItem('auth_token', newToken);
-
- // Update new refresh token if provided
- if (data.refresh_token) {
- localStorage.setItem('refresh_token', data.refresh_token);
- }
-
- // Process failed queue
- this.processQueue(null, newToken);
-
- // Retry original request with new token
- return this.retryRequestWithNewToken(originalRequest, newToken);
-
- } catch (refreshError) {
- console.warn('Token refresh failed:', refreshError);
- this.processQueue(refreshError, null);
-
- // Clear auth data and redirect to login
- localStorage.removeItem('auth_token');
- localStorage.removeItem('refresh_token');
- localStorage.removeItem('user_data');
-
- // Only redirect if we're not already on the login page
- if (typeof window !== 'undefined' && !window.location.pathname.includes('/login')) {
- window.location.href = '/login';
- }
-
- throw refreshError;
- } finally {
- this.isRefreshing = false;
- }
- }
-
- throw error;
- },
- });
- }
-
- private static async retryRequestWithNewToken(originalRequest: any, token: string) {
- try {
- // Use direct fetch instead of apiClient to avoid interceptor recursion
- const url = originalRequest.url || originalRequest.endpoint;
- const method = originalRequest.method || 'GET';
-
- const fetchOptions: RequestInit = {
- method,
- headers: {
- 'Content-Type': 'application/json',
- 'Authorization': `Bearer ${token}`,
- ...originalRequest.headers
- }
- };
-
- // Add body for non-GET requests
- if (method !== 'GET' && originalRequest.body) {
- fetchOptions.body = typeof originalRequest.body === 'string'
- ? originalRequest.body
- : JSON.stringify(originalRequest.body);
- }
-
- // Add query parameters if present
- let fullUrl = url;
- if (originalRequest.params) {
- const urlWithParams = new URL(fullUrl, (apiClient as any).baseURL);
- Object.entries(originalRequest.params).forEach(([key, value]) => {
- if (value !== undefined && value !== null) {
- urlWithParams.searchParams.append(key, String(value));
- }
- });
- fullUrl = urlWithParams.toString();
- }
-
- // Retry request with refreshed token
-
- const response = await fetch(fullUrl, fetchOptions);
-
- if (!response.ok) {
- throw new Error(`Request failed: ${response.status}`);
- }
-
- return await response.json();
- } catch (retryError) {
- console.warn('Request retry failed:', retryError);
- throw retryError;
- }
- }
-
- private static processQueue(error: any, token: string | null) {
- this.failedQueue.forEach(({ resolve, reject }) => {
- if (error) {
- reject(error);
- } else {
- resolve(token!);
- }
- });
-
- this.failedQueue = [];
- }
-}
-
-/**
- * Performance Monitoring Interceptor
- * Tracks API performance metrics
- */
-class PerformanceInterceptor {
- private static metrics: Array<{
- url: string;
- method: string;
- duration: number;
- status: number;
- timestamp: number;
- }> = [];
-
- static setup() {
- apiClient.addRequestInterceptor({
- onRequest: async (config: RequestConfig) => {
- config.metadata = {
- ...config.metadata,
- startTime: Date.now(),
- };
-
- return config;
- },
- });
-
- apiClient.addResponseInterceptor({
- onResponse: async (response: ApiResponse) => {
- const startTime = response.metadata?.startTime;
- if (startTime) {
- const duration = Date.now() - startTime;
- this.recordMetric({
- url: response.metadata?.url || 'unknown',
- method: response.metadata?.method || 'unknown',
- duration,
- status: 200,
- timestamp: Date.now(),
- });
- }
-
- return response;
- },
-
- onResponseError: async (error: any) => {
- const startTime = error.config?.metadata?.startTime;
- if (startTime) {
- const duration = Date.now() - startTime;
- this.recordMetric({
- url: error.config?.url || 'unknown',
- method: error.config?.method || 'unknown',
- duration,
- status: error?.response?.status || 0,
- timestamp: Date.now(),
- });
- }
-
- throw error;
- },
- });
- }
-
- private static recordMetric(metric: any) {
- this.metrics.push(metric);
-
- // Keep only last 1000 metrics
- if (this.metrics.length > 1000) {
- this.metrics = this.metrics.slice(-1000);
- }
- }
-
- static getMetrics() {
- return [...this.metrics];
- }
-
- static getAverageResponseTime(): number {
- if (this.metrics.length === 0) return 0;
-
- const total = this.metrics.reduce((sum, metric) => sum + metric.duration, 0);
- return Math.round(total / this.metrics.length);
- }
-
- static getErrorRate(): number {
- if (this.metrics.length === 0) return 0;
-
- const errorCount = this.metrics.filter(metric => metric.status >= 400).length;
- return Math.round((errorCount / this.metrics.length) * 100);
- }
-}
-
-/**
- * Setup all interceptors
- * IMPORTANT: Order matters! ErrorRecoveryInterceptor must be first to handle token refresh
- */
-export const setupInterceptors = () => {
- // 1. Error recovery first (handles 401 and token refresh)
- ErrorRecoveryInterceptor.setup();
-
- // 2. Authentication (adds Bearer tokens)
- AuthInterceptor.setup();
-
- // 3. Tenant context
- TenantInterceptor.setup();
-
- // 4. Development-only interceptors
- const isDevelopment = true; // Temporarily set to true for development
- if (isDevelopment) {
- LoggingInterceptor.setup();
- PerformanceInterceptor.setup();
- }
-};
-
-// Export interceptor classes for manual setup if needed
-export {
- AuthInterceptor,
- LoggingInterceptor,
- TenantInterceptor,
- ErrorRecoveryInterceptor,
- PerformanceInterceptor,
-};
\ No newline at end of file
diff --git a/fdev-ffrontend/src/api/client/types.ts b/fdev-ffrontend/src/api/client/types.ts
deleted file mode 100644
index 2b54af5f..00000000
--- a/fdev-ffrontend/src/api/client/types.ts
+++ /dev/null
@@ -1,115 +0,0 @@
-// frontend/src/api/client/types.ts
-/**
- * Core API Client Types
- */
-
-export interface RequestConfig {
- method?: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
- headers?: Record;
- params?: Record;
- body?: any;
- url?: string;
- timeout?: number;
- retries?: number;
- cache?: boolean;
- cacheTTL?: number;
- optimistic?: boolean;
- background?: boolean;
- metadata?: any;
-}
-
-export interface ApiResponse {
- data: T;
- message?: string;
- status: string;
- timestamp?: string;
- metadata?: any;
- meta?: {
- page?: number;
- limit?: number;
- total?: number;
- hasNext?: boolean;
- hasPrev?: boolean;
- requestId?: string;
- };
-}
-
-export interface ApiError {
- message: string;
- detail?: string;
- code?: string;
- field?: string;
- timestamp?: string;
- service?: string;
- requestId?: string;
-}
-
-export interface PaginatedResponse {
- data: T[];
- pagination: {
- page: number;
- limit: number;
- total: number;
- totalPages: number;
- hasNext: boolean;
- hasPrev: boolean;
- };
-}
-
-export interface UploadProgress {
- loaded: number;
- total: number;
- percentage: number;
-}
-
-export interface UploadConfig extends RequestConfig {
- onProgress?: (progress: UploadProgress) => void;
- maxFileSize?: number;
- allowedTypes?: string[];
-}
-
-// Request/Response interceptor types
-export interface RequestInterceptor {
- onRequest?: (config: RequestConfig) => RequestConfig | Promise;
- onRequestError?: (error: any) => any;
-}
-
-export interface ResponseInterceptor {
- onResponse?: (response: ApiResponse) => ApiResponse | Promise>;
- onResponseError?: (error: any) => any;
-}
-
-// Cache types
-export interface CacheEntry {
- data: T;
- timestamp: number;
- ttl: number;
- key: string;
-}
-
-export interface CacheStrategy {
- key: (url: string, params?: any) => string;
- ttl: number;
- enabled: boolean;
-}
-
-// Metrics types
-export interface RequestMetrics {
- url: string;
- method: string;
- duration: number;
- status: number;
- size: number;
- timestamp: number;
- cached: boolean;
- retries: number;
-}
-
-export interface ClientMetrics {
- totalRequests: number;
- successfulRequests: number;
- failedRequests: number;
- averageResponseTime: number;
- cacheHitRate: number;
- errorRate: number;
-}
\ No newline at end of file
diff --git a/fdev-ffrontend/src/api/hooks/index.ts b/fdev-ffrontend/src/api/hooks/index.ts
deleted file mode 100644
index bb855104..00000000
--- a/fdev-ffrontend/src/api/hooks/index.ts
+++ /dev/null
@@ -1,66 +0,0 @@
-// frontend/src/api/hooks/index.ts
-/**
- * Main Hooks Export
- */
-
-export { useAuth, useAuthHeaders } from './useAuth';
-export { useTenant } from './useTenant';
-export { useSales } from './useSales';
-export { useExternal } from './useExternal';
-export { useTraining } from './useTraining';
-export { useForecast } from './useForecast';
-export { useNotification } from './useNotification';
-export { useOnboarding, useOnboardingStep } from './useOnboarding';
-export { useInventory, useInventoryDashboard, useInventoryItem, useInventoryProducts } from './useInventory';
-export { useRecipes, useProduction } from './useRecipes';
-export {
- useCurrentProcurementPlan,
- useProcurementPlanByDate,
- useProcurementPlan,
- useProcurementPlans,
- usePlanRequirements,
- useCriticalRequirements,
- useProcurementDashboard,
- useGenerateProcurementPlan,
- useUpdatePlanStatus,
- useTriggerDailyScheduler,
- useProcurementHealth,
- useProcurementPlanDashboard,
- useProcurementPlanActions
-} from './useProcurement';
-
-// Import hooks for combined usage
-import { useAuth } from './useAuth';
-import { useTenant } from './useTenant';
-import { useSales } from './useSales';
-import { useExternal } from './useExternal';
-import { useTraining } from './useTraining';
-import { useForecast } from './useForecast';
-import { useNotification } from './useNotification';
-import { useOnboarding } from './useOnboarding';
-import { useInventory } from './useInventory';
-
-// Combined hook for common operations
-export const useApiHooks = () => {
- const auth = useAuth();
- const tenant = useTenant();
- const sales = useSales();
- const external = useExternal();
- const training = useTraining({ disablePolling: true }); // Disable polling by default
- const forecast = useForecast();
- const notification = useNotification();
- const onboarding = useOnboarding();
- const inventory = useInventory();
-
- return {
- auth,
- tenant,
- sales,
- external,
- training,
- forecast,
- notification,
- onboarding,
- inventory
- };
-};
\ No newline at end of file
diff --git a/fdev-ffrontend/src/api/hooks/useAuth.ts b/fdev-ffrontend/src/api/hooks/useAuth.ts
deleted file mode 100644
index 6cb6ba15..00000000
--- a/fdev-ffrontend/src/api/hooks/useAuth.ts
+++ /dev/null
@@ -1,205 +0,0 @@
-// frontend/src/api/hooks/useAuth.ts
-/**
- * Authentication Hooks
- * React hooks for authentication operations
- */
-
-import { useState, useEffect, useCallback } from 'react';
-import { authService } from '../services';
-import type {
- LoginRequest,
- LoginResponse,
- RegisterRequest,
- UserResponse,
- PasswordResetRequest,
-} from '../types';
-
-// Token management
-const TOKEN_KEY = 'auth_token';
-const REFRESH_TOKEN_KEY = 'refresh_token';
-const USER_KEY = 'user_data';
-
-export const useAuth = () => {
- const [user, setUser] = useState(null);
- const [isAuthenticated, setIsAuthenticated] = useState(false);
- const [isLoading, setIsLoading] = useState(true);
- const [error, setError] = useState(null);
-
- // Initialize auth state from localStorage
- useEffect(() => {
- const initializeAuth = async () => {
- try {
- const token = localStorage.getItem(TOKEN_KEY);
- const userData = localStorage.getItem(USER_KEY);
-
- if (token && userData) {
- setUser(JSON.parse(userData));
- setIsAuthenticated(true);
-
- // Verify token is still valid
- try {
- const currentUser = await authService.getCurrentUser();
- setUser(currentUser);
- } catch (error) {
- // Token might be expired - let interceptors handle refresh
- // Only logout if refresh also fails (handled by ErrorRecoveryInterceptor)
- console.log('Token verification failed, interceptors will handle refresh if possible');
-
- // Check if we have a refresh token - if not, logout immediately
- const refreshToken = localStorage.getItem(REFRESH_TOKEN_KEY);
- if (!refreshToken) {
- console.log('No refresh token available, logging out');
- logout();
- }
- }
- }
- } catch (error) {
- console.error('Auth initialization error:', error);
- logout();
- } finally {
- setIsLoading(false);
- }
- };
-
- initializeAuth();
- }, []);
-
- const login = useCallback(async (credentials: LoginRequest): Promise => {
- try {
- setIsLoading(true);
- setError(null);
-
- const response = await authService.login(credentials);
-
- // Store tokens and user data
- localStorage.setItem(TOKEN_KEY, response.access_token);
- if (response.refresh_token) {
- localStorage.setItem(REFRESH_TOKEN_KEY, response.refresh_token);
- }
- if (response.user) {
- localStorage.setItem(USER_KEY, JSON.stringify(response.user));
- setUser(response.user);
- }
-
- setIsAuthenticated(true);
- } catch (error) {
- const message = error instanceof Error ? error.message : 'Login failed';
- setError(message);
- throw error;
- } finally {
- setIsLoading(false);
- }
- }, []);
-
- const register = useCallback(async (data: RegisterRequest): Promise => {
- try {
- setIsLoading(true);
- setError(null);
-
- const response = await authService.register(data);
-
- // Auto-login after successful registration
- if (response && response.user) {
- await login({ email: data.email, password: data.password });
- } else {
- // If response doesn't have user property, registration might still be successful
- // Try to login anyway in case the user was created but response format is different
- await login({ email: data.email, password: data.password });
- }
- } catch (error) {
- const message = error instanceof Error ? error.message : 'Registration failed';
- setError(message);
- throw error;
- } finally {
- setIsLoading(false);
- }
- }, [login]);
-
- const logout = useCallback(async (): Promise => {
- try {
- // Call logout endpoint if authenticated
- if (isAuthenticated) {
- await authService.logout();
- }
- } catch (error) {
- console.error('Logout error:', error);
- } finally {
- // Clear local state regardless of API call success
- localStorage.removeItem(TOKEN_KEY);
- localStorage.removeItem(REFRESH_TOKEN_KEY);
- localStorage.removeItem(USER_KEY);
- setUser(null);
- setIsAuthenticated(false);
- setError(null);
- }
- }, [isAuthenticated]);
-
- const updateProfile = useCallback(async (data: Partial): Promise => {
- try {
- setIsLoading(true);
- setError(null);
-
- const updatedUser = await authService.updateProfile(data);
- setUser(updatedUser);
- localStorage.setItem(USER_KEY, JSON.stringify(updatedUser));
- } catch (error) {
- const message = error instanceof Error ? error.message : 'Profile update failed';
- setError(message);
- throw error;
- } finally {
- setIsLoading(false);
- }
- }, []);
-
- const requestPasswordReset = useCallback(async (data: PasswordResetRequest): Promise => {
- try {
- setIsLoading(true);
- setError(null);
- await authService.requestPasswordReset(data);
- } catch (error) {
- const message = error instanceof Error ? error.message : 'Password reset request failed';
- setError(message);
- throw error;
- } finally {
- setIsLoading(false);
- }
- }, []);
-
- const changePassword = useCallback(async (currentPassword: string, newPassword: string): Promise => {
- try {
- setIsLoading(true);
- setError(null);
- await authService.changePassword(currentPassword, newPassword);
- } catch (error) {
- const message = error instanceof Error ? error.message : 'Password change failed';
- setError(message);
- throw error;
- } finally {
- setIsLoading(false);
- }
- }, []);
-
- return {
- user,
- isAuthenticated,
- isLoading,
- error,
- login,
- register,
- logout,
- updateProfile,
- requestPasswordReset,
- changePassword,
- clearError: () => setError(null),
- };
-};
-
-// Hook for getting authentication headers
-export const useAuthHeaders = () => {
- const getAuthHeaders = useCallback(() => {
- const token = localStorage.getItem(TOKEN_KEY);
- return token ? { Authorization: `Bearer ${token}` } : {};
- }, []);
-
- return { getAuthHeaders };
-};
\ No newline at end of file
diff --git a/fdev-ffrontend/src/api/hooks/useExternal.ts b/fdev-ffrontend/src/api/hooks/useExternal.ts
deleted file mode 100644
index c7d72aa3..00000000
--- a/fdev-ffrontend/src/api/hooks/useExternal.ts
+++ /dev/null
@@ -1,238 +0,0 @@
-// frontend/src/api/hooks/useExternal.ts
-/**
- * External Data Management Hooks
- * Handles weather and traffic data operations
- */
-
-import { useState, useCallback } from 'react';
-import { externalService } from '../services/external.service';
-import type { WeatherData, TrafficData, WeatherForecast, HourlyForecast } from '../services/external.service';
-
-export const useExternal = () => {
- const [weatherData, setWeatherData] = useState(null);
- const [trafficData, setTrafficData] = useState(null);
- const [weatherForecast, setWeatherForecast] = useState([]);
- const [hourlyForecast, setHourlyForecast] = useState([]);
- const [trafficForecast, setTrafficForecast] = useState([]);
- const [isLoading, setIsLoading] = useState(false);
- const [error, setError] = useState(null);
-
- /**
- * Get Current Weather
- */
- const getCurrentWeather = useCallback(async (
- tenantId: string,
- lat: number,
- lon: number
- ): Promise => {
- try {
- setIsLoading(true);
- setError(null);
-
- const weather = await externalService.getCurrentWeather(tenantId, lat, lon);
- setWeatherData(weather);
-
- return weather;
- } catch (error) {
- const message = error instanceof Error ? error.message : 'Failed to get weather data';
- setError(message);
- throw error;
- } finally {
- setIsLoading(false);
- }
- }, []);
-
- /**
- * Get Weather Forecast
- */
- const getWeatherForecast = useCallback(async (
- tenantId: string,
- lat: number,
- lon: number,
- days: number = 7
- ): Promise => {
- try {
- setIsLoading(true);
- setError(null);
-
- const forecast = await externalService.getWeatherForecast(tenantId, lat, lon, days);
- setWeatherForecast(forecast);
-
- return forecast;
- } catch (error) {
- const message = error instanceof Error ? error.message : 'Failed to get weather forecast';
- setError(message);
- throw error;
- } finally {
- setIsLoading(false);
- }
- }, []);
-
- /**
- * Get Hourly Weather Forecast
- */
- const getHourlyWeatherForecast = useCallback(async (
- tenantId: string,
- lat: number,
- lon: number,
- hours: number = 48
- ): Promise => {
- try {
- setIsLoading(true);
- setError(null);
-
- const forecast = await externalService.getHourlyWeatherForecast(tenantId, lat, lon, hours);
- setHourlyForecast(forecast);
-
- return forecast;
- } catch (error) {
- const message = error instanceof Error ? error.message : 'Failed to get hourly weather forecast';
- setError(message);
- throw error;
- } finally {
- setIsLoading(false);
- }
- }, []);
-
- /**
- * Get Historical Weather Data
- */
- const getHistoricalWeather = useCallback(async (
- tenantId: string,
- lat: number,
- lon: number,
- startDate: string,
- endDate: string
- ): Promise => {
- try {
- setIsLoading(true);
- setError(null);
-
- const data = await externalService.getHistoricalWeather(tenantId, lat, lon, startDate, endDate);
-
- return data;
- } catch (error) {
- const message = error instanceof Error ? error.message : 'Failed to get historical weather';
- setError(message);
- throw error;
- } finally {
- setIsLoading(false);
- }
- }, []);
-
- /**
- * Get Current Traffic
- */
- const getCurrentTraffic = useCallback(async (
- tenantId: string,
- lat: number,
- lon: number
- ): Promise => {
- try {
- setIsLoading(true);
- setError(null);
-
- const traffic = await externalService.getCurrentTraffic(tenantId, lat, lon);
- setTrafficData(traffic);
-
- return traffic;
- } catch (error) {
- const message = error instanceof Error ? error.message : 'Failed to get traffic data';
- setError(message);
- throw error;
- } finally {
- setIsLoading(false);
- }
- }, []);
-
- /**
- * Get Traffic Forecast
- */
- const getTrafficForecast = useCallback(async (
- tenantId: string,
- lat: number,
- lon: number,
- hours: number = 24
- ): Promise => {
- try {
- setIsLoading(true);
- setError(null);
-
- const forecast = await externalService.getTrafficForecast(tenantId, lat, lon, hours);
- setTrafficForecast(forecast);
-
- return forecast;
- } catch (error) {
- const message = error instanceof Error ? error.message : 'Failed to get traffic forecast';
- setError(message);
- throw error;
- } finally {
- setIsLoading(false);
- }
- }, []);
-
- /**
- * Get Historical Traffic Data
- */
- const getHistoricalTraffic = useCallback(async (
- tenantId: string,
- lat: number,
- lon: number,
- startDate: string,
- endDate: string
- ): Promise => {
- try {
- setIsLoading(true);
- setError(null);
-
- const data = await externalService.getHistoricalTraffic(tenantId, lat, lon, startDate, endDate);
-
- return data;
- } catch (error) {
- const message = error instanceof Error ? error.message : 'Failed to get historical traffic';
- setError(message);
- throw error;
- } finally {
- setIsLoading(false);
- }
- }, []);
-
- /**
- * Test External Services Connectivity
- */
- const testConnectivity = useCallback(async (tenantId: string) => {
- try {
- setIsLoading(true);
- setError(null);
-
- const results = await externalService.testConnectivity(tenantId);
-
- return results;
- } catch (error) {
- const message = error instanceof Error ? error.message : 'Failed to test connectivity';
- setError(message);
- throw error;
- } finally {
- setIsLoading(false);
- }
- }, []);
-
- return {
- weatherData,
- trafficData,
- weatherForecast,
- hourlyForecast,
- trafficForecast,
- isLoading,
- error,
- getCurrentWeather,
- getWeatherForecast,
- getHourlyWeatherForecast,
- getHistoricalWeather,
- getCurrentTraffic,
- getTrafficForecast,
- getHistoricalTraffic,
- testConnectivity,
- clearError: () => setError(null),
- };
-};
\ No newline at end of file
diff --git a/fdev-ffrontend/src/api/hooks/useForecast.ts b/fdev-ffrontend/src/api/hooks/useForecast.ts
deleted file mode 100644
index 2fa628a0..00000000
--- a/fdev-ffrontend/src/api/hooks/useForecast.ts
+++ /dev/null
@@ -1,229 +0,0 @@
-// frontend/src/api/hooks/useForecast.ts
-/**
- * Forecasting Operations Hooks
- */
-
-import { useState, useCallback } from 'react';
-import { forecastingService } from '../services';
-import type {
- SingleForecastRequest,
- BatchForecastRequest,
- ForecastResponse,
- BatchForecastResponse,
- ForecastAlert,
- QuickForecast,
-} from '../types';
-
-export const useForecast = () => {
- const [forecasts, setForecasts] = useState([]);
- const [batchForecasts, setBatchForecasts] = useState([]);
- const [quickForecasts, setQuickForecasts] = useState([]);
- const [alerts, setAlerts] = useState([]);
- const [isLoading, setIsLoading] = useState(false);
- const [error, setError] = useState(null);
-
- const createSingleForecast = useCallback(async (
- tenantId: string,
- request: SingleForecastRequest
- ): Promise => {
- try {
- setIsLoading(true);
- setError(null);
-
- const newForecasts = await forecastingService.createSingleForecast(tenantId, request);
- setForecasts(prev => [...newForecasts, ...(prev || [])]);
-
- return newForecasts;
- } catch (error) {
- const message = error instanceof Error ? error.message : 'Failed to create forecast';
- setError(message);
- throw error;
- } finally {
- setIsLoading(false);
- }
- }, []);
-
- const createBatchForecast = useCallback(async (
- tenantId: string,
- request: BatchForecastRequest
- ): Promise => {
- try {
- setIsLoading(true);
- setError(null);
-
- const batchForecast = await forecastingService.createBatchForecast(tenantId, request);
- setBatchForecasts(prev => [batchForecast, ...(prev || [])]);
-
- return batchForecast;
- } catch (error) {
- const message = error instanceof Error ? error.message : 'Failed to create batch forecast';
- setError(message);
- throw error;
- } finally {
- setIsLoading(false);
- }
- }, []);
-
- const getForecasts = useCallback(async (tenantId: string): Promise => {
- try {
- setIsLoading(true);
- setError(null);
-
- const response = await forecastingService.getForecasts(tenantId);
- setForecasts(response.data);
-
- return response.data;
- } catch (error) {
- const message = error instanceof Error ? error.message : 'Failed to get forecasts';
- setError(message);
- throw error;
- } finally {
- setIsLoading(false);
- }
- }, []);
-
- const getBatchForecastStatus = useCallback(async (
- tenantId: string,
- batchId: string
- ): Promise => {
- try {
- const batchForecast = await forecastingService.getBatchForecastStatus(tenantId, batchId);
-
- // Update batch forecast in state
- setBatchForecasts(prev => (prev || []).map(bf =>
- bf.id === batchId ? batchForecast : bf
- ));
-
- return batchForecast;
- } catch (error) {
- const message = error instanceof Error ? error.message : 'Failed to get batch forecast status';
- setError(message);
- throw error;
- }
- }, []);
-
- const getQuickForecasts = useCallback(async (tenantId: string): Promise => {
- try {
- setIsLoading(true);
- setError(null);
-
- const quickForecastData = await forecastingService.getQuickForecasts(tenantId);
- setQuickForecasts(quickForecastData);
-
- return quickForecastData;
- } catch (error) {
- const message = error instanceof Error ? error.message : 'Failed to get quick forecasts';
- setError(message);
- throw error;
- } finally {
- setIsLoading(false);
- }
- }, []);
-
- const getForecastAlerts = useCallback(async (tenantId: string): Promise => {
- try {
- setIsLoading(true);
- setError(null);
-
- const response = await forecastingService.getForecastAlerts(tenantId);
-
- // Handle different response formats
- if (response && 'data' in response && response.data) {
- // Standard paginated format: { data: [...], pagination: {...} }
- setAlerts(response.data);
- return { alerts: response.data, ...response };
- } else if (response && Array.isArray(response)) {
- // Direct array format
- setAlerts(response);
- return { alerts: response };
- } else if (Array.isArray(response)) {
- // Direct array format
- setAlerts(response);
- return { alerts: response };
- } else {
- // Unknown format - return empty
- setAlerts([]);
- return { alerts: [] };
- }
- } catch (error) {
- const message = error instanceof Error ? error.message : 'Failed to get forecast alerts';
- setError(message);
- throw error;
- } finally {
- setIsLoading(false);
- }
- }, []);
-
- const acknowledgeForecastAlert = useCallback(async (
- tenantId: string,
- alertId: string
- ): Promise => {
- try {
- setIsLoading(true);
- setError(null);
-
- const acknowledgedAlert = await forecastingService.acknowledgeForecastAlert(tenantId, alertId);
- setAlerts(prev => (prev || []).map(alert =>
- alert.id === alertId ? acknowledgedAlert : alert
- ));
- } catch (error) {
- const message = error instanceof Error ? error.message : 'Failed to acknowledge alert';
- setError(message);
- throw error;
- } finally {
- setIsLoading(false);
- }
- }, []);
-
- const exportForecasts = useCallback(async (
- tenantId: string,
- format: 'csv' | 'excel' | 'json',
- params?: {
- inventory_product_id?: string; // Primary way to filter by product
- product_name?: string; // For backward compatibility
- start_date?: string;
- end_date?: string;
- }
- ): Promise => {
- try {
- setIsLoading(true);
- setError(null);
-
- const blob = await forecastingService.exportForecasts(tenantId, format, params);
-
- // Create download link
- const url = window.URL.createObjectURL(blob);
- const link = document.createElement('a');
- link.href = url;
- link.download = `forecasts.${format}`;
- document.body.appendChild(link);
- link.click();
- document.body.removeChild(link);
- window.URL.revokeObjectURL(url);
- } catch (error) {
- const message = error instanceof Error ? error.message : 'Export failed';
- setError(message);
- throw error;
- } finally {
- setIsLoading(false);
- }
- }, []);
-
- return {
- forecasts,
- batchForecasts,
- quickForecasts,
- alerts,
- isLoading,
- error,
- createSingleForecast,
- createBatchForecast,
- getForecasts,
- getBatchForecastStatus,
- getQuickForecasts,
- getForecastAlerts,
- acknowledgeForecastAlert,
- exportForecasts,
- clearError: () => setError(null),
- };
-};
diff --git a/fdev-ffrontend/src/api/hooks/useInventory.ts b/fdev-ffrontend/src/api/hooks/useInventory.ts
deleted file mode 100644
index 32919f76..00000000
--- a/fdev-ffrontend/src/api/hooks/useInventory.ts
+++ /dev/null
@@ -1,536 +0,0 @@
-// frontend/src/api/hooks/useInventory.ts
-/**
- * Inventory Management React Hook
- * Provides comprehensive state management for inventory operations
- */
-
-import { useState, useEffect, useCallback } from 'react';
-import toast from 'react-hot-toast';
-
-import {
- inventoryService,
- InventoryItem,
- StockLevel,
- StockMovement,
- InventorySearchParams,
- CreateInventoryItemRequest,
- UpdateInventoryItemRequest,
- StockAdjustmentRequest,
- PaginatedResponse,
- InventoryDashboardData
-} from '../services/inventory.service';
-import type { ProductInfo } from '../types';
-
-import { useTenantId } from '../../hooks/useTenantId';
-
-// ========== HOOK INTERFACES ==========
-
-interface UseInventoryReturn {
- // State
- items: InventoryItem[];
- stockLevels: Record;
- movements: StockMovement[];
- dashboardData: InventoryDashboardData | null;
- isLoading: boolean;
- error: string | null;
- pagination: {
- page: number;
- limit: number;
- total: number;
- totalPages: number;
- };
-
- // Actions
- loadItems: (params?: InventorySearchParams) => Promise;
- loadItem: (itemId: string) => Promise;
- createItem: (data: CreateInventoryItemRequest) => Promise;
- updateItem: (itemId: string, data: UpdateInventoryItemRequest) => Promise;
- deleteItem: (itemId: string) => Promise;
-
- // Stock operations
- loadStockLevels: () => Promise;
- adjustStock: (itemId: string, adjustment: StockAdjustmentRequest) => Promise;
- loadMovements: (params?: any) => Promise;
-
-
- // Dashboard
- loadDashboard: () => Promise;
-
- // Utility
- searchItems: (query: string) => Promise;
- refresh: () => Promise;
- clearError: () => void;
-}
-
-interface UseInventoryDashboardReturn {
- dashboardData: InventoryDashboardData | null;
- isLoading: boolean;
- error: string | null;
- refresh: () => Promise;
-}
-
-interface UseInventoryItemReturn {
- item: InventoryItem | null;
- stockLevel: StockLevel | null;
- recentMovements: StockMovement[];
- isLoading: boolean;
- error: string | null;
- updateItem: (data: UpdateInventoryItemRequest) => Promise;
- adjustStock: (adjustment: StockAdjustmentRequest) => Promise;
- refresh: () => Promise;
-}
-
-// ========== MAIN INVENTORY HOOK ==========
-
-export const useInventory = (autoLoad = true): UseInventoryReturn => {
- const { tenantId } = useTenantId();
-
- // State
- const [items, setItems] = useState([]);
- const [stockLevels, setStockLevels] = useState>({});
- const [movements, setMovements] = useState([]);
- const [dashboardData, setDashboardData] = useState(null);
- const [isLoading, setIsLoading] = useState(false);
- const [error, setError] = useState(null);
- const [pagination, setPagination] = useState({
- page: 1,
- limit: 20,
- total: 0,
- totalPages: 0
- });
-
- // Clear error
- const clearError = useCallback(() => setError(null), []);
-
- // Load inventory items
- const loadItems = useCallback(async (params?: InventorySearchParams) => {
- if (!tenantId) return;
-
- setIsLoading(true);
- setError(null);
-
- try {
- const response = await inventoryService.getInventoryItems(tenantId, params);
- console.log('🔄 useInventory: Loaded items:', response.items);
- setItems(response.items || []); // Ensure it's always an array
- setPagination({
- page: response.page || 1,
- limit: response.limit || 20,
- total: response.total || 0,
- totalPages: response.total_pages || 0
- });
- } catch (err: any) {
- console.error('❌ useInventory: Error loading items:', err);
- const errorMessage = err.response?.data?.detail || err.message || 'Error loading inventory items';
-
- setError(errorMessage);
- setItems([]); // Set empty array on error
-
- // Show appropriate error message
- if (err.response?.status === 401) {
- console.error('❌ useInventory: Authentication failed');
- } else if (err.response?.status === 403) {
- toast.error('No tienes permisos para acceder a este inventario');
- } else {
- toast.error(errorMessage);
- }
- } finally {
- setIsLoading(false);
- }
- }, [tenantId]);
-
- // Load single item
- const loadItem = useCallback(async (itemId: string): Promise => {
- if (!tenantId) return null;
-
- try {
- const item = await inventoryService.getInventoryItem(tenantId, itemId);
-
- // Update in local state if it exists
- setItems(prev => prev.map(i => i.id === itemId ? item : i));
-
- return item;
- } catch (err: any) {
- const errorMessage = err.response?.data?.detail || err.message || 'Error loading item';
- setError(errorMessage);
- return null;
- }
- }, [tenantId]);
-
- // Create item
- const createItem = useCallback(async (data: CreateInventoryItemRequest): Promise => {
- if (!tenantId) return null;
-
- setIsLoading(true);
-
- try {
- const newItem = await inventoryService.createInventoryItem(tenantId, data);
- setItems(prev => [newItem, ...prev]);
- toast.success(`Created ${newItem.name} successfully`);
- return newItem;
- } catch (err: any) {
- const errorMessage = err.response?.data?.detail || err.message || 'Error creating item';
- setError(errorMessage);
- toast.error(errorMessage);
- return null;
- } finally {
- setIsLoading(false);
- }
- }, [tenantId]);
-
- // Update item
- const updateItem = useCallback(async (
- itemId: string,
- data: UpdateInventoryItemRequest
- ): Promise => {
- if (!tenantId) return null;
-
- try {
- const updatedItem = await inventoryService.updateInventoryItem(tenantId, itemId, data);
- setItems(prev => prev.map(i => i.id === itemId ? updatedItem : i));
- toast.success(`Updated ${updatedItem.name} successfully`);
- return updatedItem;
- } catch (err: any) {
- const errorMessage = err.response?.data?.detail || err.message || 'Error updating item';
- setError(errorMessage);
- toast.error(errorMessage);
- return null;
- }
- }, [tenantId]);
-
- // Delete item
- const deleteItem = useCallback(async (itemId: string): Promise => {
- if (!tenantId) return false;
-
- try {
- await inventoryService.deleteInventoryItem(tenantId, itemId);
- setItems(prev => prev.filter(i => i.id !== itemId));
- toast.success('Item deleted successfully');
- return true;
- } catch (err: any) {
- const errorMessage = err.response?.data?.detail || err.message || 'Error deleting item';
- setError(errorMessage);
- toast.error(errorMessage);
- return false;
- }
- }, [tenantId]);
-
- // Load stock levels
- const loadStockLevels = useCallback(async () => {
- if (!tenantId) return;
-
- try {
- const levels = await inventoryService.getAllStockLevels(tenantId);
- const levelMap = levels.reduce((acc, level) => {
- acc[level.item_id] = level;
- return acc;
- }, {} as Record);
- setStockLevels(levelMap);
- } catch (err: any) {
- console.error('Error loading stock levels:', err);
- // Don't show toast error for this as it's not critical for forecast page
- }
- }, [tenantId]);
-
- // Adjust stock
- const adjustStock = useCallback(async (
- itemId: string,
- adjustment: StockAdjustmentRequest
- ): Promise => {
- if (!tenantId) return null;
-
- try {
- const movement = await inventoryService.adjustStock(tenantId, itemId, adjustment);
-
- // Update local movements
- setMovements(prev => [movement, ...prev.slice(0, 49)]); // Keep last 50
-
- // Reload stock level for this item
- const updatedLevel = await inventoryService.getStockLevel(tenantId, itemId);
- setStockLevels(prev => ({ ...prev, [itemId]: updatedLevel }));
-
- toast.success('Stock adjusted successfully');
- return movement;
- } catch (err: any) {
- const errorMessage = err.response?.data?.detail || err.message || 'Error adjusting stock';
- setError(errorMessage);
- toast.error(errorMessage);
- return null;
- }
- }, [tenantId]);
-
- // Load movements
- const loadMovements = useCallback(async (params?: any) => {
- if (!tenantId) return;
-
- try {
- const response = await inventoryService.getStockMovements(tenantId, params);
- setMovements(response.items);
- } catch (err: any) {
- console.error('Error loading movements:', err);
- }
- }, [tenantId]);
-
-
- // Load dashboard
- const loadDashboard = useCallback(async () => {
- if (!tenantId) return;
-
- try {
- const data = await inventoryService.getDashboardData(tenantId);
- setDashboardData(data);
- } catch (err: any) {
- console.error('Error loading dashboard:', err);
- // Don't show toast error for this as it's not critical for forecast page
- }
- }, [tenantId]);
-
- // Search items
- const searchItems = useCallback(async (query: string): Promise => {
- if (!tenantId || !query.trim()) return [];
-
- try {
- return await inventoryService.searchItems(tenantId, query);
- } catch (err: any) {
- console.error('Error searching items:', err);
- return [];
- }
- }, [tenantId]);
-
- // Refresh all data
- const refresh = useCallback(async () => {
- await Promise.all([
- loadItems(),
- loadStockLevels(),
- loadDashboard()
- ]);
- }, [loadItems, loadStockLevels, loadDashboard]);
-
- // Auto-load on mount
- useEffect(() => {
- if (autoLoad && tenantId) {
- refresh();
- }
- }, [autoLoad, tenantId, refresh]);
-
- return {
- // State
- items,
- stockLevels,
- movements,
- dashboardData,
- isLoading,
- error,
- pagination,
-
- // Actions
- loadItems,
- loadItem,
- createItem,
- updateItem,
- deleteItem,
-
- // Stock operations
- loadStockLevels,
- adjustStock,
- loadMovements,
-
- // Dashboard
- loadDashboard,
-
- // Utility
- searchItems,
- refresh,
- clearError
- };
-};
-
-// ========== DASHBOARD HOOK ==========
-
-export const useInventoryDashboard = (): UseInventoryDashboardReturn => {
- const { tenantId } = useTenantId();
- const [dashboardData, setDashboardData] = useState(null);
- const [isLoading, setIsLoading] = useState(false);
- const [error, setError] = useState(null);
-
- const refresh = useCallback(async () => {
- if (!tenantId) return;
-
- setIsLoading(true);
- setError(null);
-
- try {
- const dashboard = await inventoryService.getDashboardData(tenantId);
-
- setDashboardData(dashboard);
- } catch (err: any) {
- const errorMessage = err.response?.data?.detail || err.message || 'Error loading dashboard';
- setError(errorMessage);
- } finally {
- setIsLoading(false);
- }
- }, [tenantId]);
-
- useEffect(() => {
- if (tenantId) {
- refresh();
- }
- }, [tenantId, refresh]);
-
- return {
- dashboardData,
- isLoading,
- error,
- refresh
- };
-};
-
-// ========== SINGLE ITEM HOOK ==========
-
-export const useInventoryItem = (itemId: string): UseInventoryItemReturn => {
- const { tenantId } = useTenantId();
- const [item, setItem] = useState(null);
- const [stockLevel, setStockLevel] = useState(null);
- const [recentMovements, setRecentMovements] = useState([]);
- const [isLoading, setIsLoading] = useState(false);
- const [error, setError] = useState(null);
-
- const refresh = useCallback(async () => {
- if (!tenantId || !itemId) return;
-
- setIsLoading(true);
- setError(null);
-
- try {
- const [itemData, stockData, movementsData] = await Promise.all([
- inventoryService.getInventoryItem(tenantId, itemId),
- inventoryService.getStockLevel(tenantId, itemId),
- inventoryService.getStockMovements(tenantId, { item_id: itemId, limit: 10 })
- ]);
-
- setItem(itemData);
- setStockLevel(stockData);
- setRecentMovements(movementsData.items);
- } catch (err: any) {
- const errorMessage = err.response?.data?.detail || err.message || 'Error loading item';
- setError(errorMessage);
- } finally {
- setIsLoading(false);
- }
- }, [tenantId, itemId]);
-
- const updateItem = useCallback(async (data: UpdateInventoryItemRequest): Promise => {
- if (!tenantId || !itemId) return false;
-
- try {
- const updatedItem = await inventoryService.updateInventoryItem(tenantId, itemId, data);
- setItem(updatedItem);
- toast.success('Item updated successfully');
- return true;
- } catch (err: any) {
- const errorMessage = err.response?.data?.detail || err.message || 'Error updating item';
- setError(errorMessage);
- toast.error(errorMessage);
- return false;
- }
- }, [tenantId, itemId]);
-
- const adjustStock = useCallback(async (adjustment: StockAdjustmentRequest): Promise => {
- if (!tenantId || !itemId) return false;
-
- try {
- const movement = await inventoryService.adjustStock(tenantId, itemId, adjustment);
-
- // Refresh data
- const [updatedStock, updatedMovements] = await Promise.all([
- inventoryService.getStockLevel(tenantId, itemId),
- inventoryService.getStockMovements(tenantId, { item_id: itemId, limit: 10 })
- ]);
-
- setStockLevel(updatedStock);
- setRecentMovements(updatedMovements.items);
-
- toast.success('Stock adjusted successfully');
- return true;
- } catch (err: any) {
- const errorMessage = err.response?.data?.detail || err.message || 'Error adjusting stock';
- setError(errorMessage);
- toast.error(errorMessage);
- return false;
- }
- }, [tenantId, itemId]);
-
- useEffect(() => {
- if (tenantId && itemId) {
- refresh();
- }
- }, [tenantId, itemId, refresh]);
-
- return {
- item,
- stockLevel,
- recentMovements,
- isLoading,
- error,
- updateItem,
- adjustStock,
- refresh
- };
-};
-
-// ========== SIMPLE PRODUCTS HOOK FOR FORECASTING ==========
-
-export const useInventoryProducts = () => {
- const [isLoading, setIsLoading] = useState(false);
- const [error, setError] = useState(null);
-
- /**
- * Get Products List for Forecasting
- */
- const getProductsList = useCallback(async (tenantId: string): Promise => {
- try {
- setIsLoading(true);
- setError(null);
-
- const products = await inventoryService.getProductsList(tenantId);
-
- return products;
- } catch (error) {
- const message = error instanceof Error ? error.message : 'Failed to get products list';
- setError(message);
- throw error;
- } finally {
- setIsLoading(false);
- }
- }, []);
-
- /**
- * Get Product by ID
- */
- const getProductById = useCallback(async (tenantId: string, productId: string): Promise => {
- try {
- setIsLoading(true);
- setError(null);
-
- const product = await inventoryService.getProductById(tenantId, productId);
-
- return product;
- } catch (error) {
- const message = error instanceof Error ? error.message : 'Failed to get product';
- setError(message);
- throw error;
- } finally {
- setIsLoading(false);
- }
- }, []);
-
- return {
- // State
- isLoading,
- error,
-
- // Actions
- getProductsList,
- getProductById,
- };
-};
\ No newline at end of file
diff --git a/fdev-ffrontend/src/api/hooks/useNotification.ts b/fdev-ffrontend/src/api/hooks/useNotification.ts
deleted file mode 100644
index 43b059e7..00000000
--- a/fdev-ffrontend/src/api/hooks/useNotification.ts
+++ /dev/null
@@ -1,151 +0,0 @@
-// frontend/src/api/hooks/useNotification.ts
-/**
- * Notification Operations Hooks
- */
-
-import { useState, useCallback } from 'react';
-import { notificationService } from '../services';
-import type {
- NotificationCreate,
- NotificationResponse,
- NotificationTemplate,
- NotificationStats,
- BulkNotificationRequest,
-} from '../types';
-
-export const useNotification = () => {
- const [notifications, setNotifications] = useState([]);
- const [templates, setTemplates] = useState([]);
- const [stats, setStats] = useState(null);
- const [isLoading, setIsLoading] = useState(false);
- const [error, setError] = useState(null);
-
- const sendNotification = useCallback(async (
- tenantId: string,
- notification: NotificationCreate
- ): Promise => {
- try {
- setIsLoading(true);
- setError(null);
-
- const sentNotification = await notificationService.sendNotification(tenantId, notification);
- setNotifications(prev => [sentNotification, ...prev]);
-
- return sentNotification;
- } catch (error) {
- const message = error instanceof Error ? error.message : 'Failed to send notification';
- setError(message);
- throw error;
- } finally {
- setIsLoading(false);
- }
- }, []);
-
- const sendBulkNotifications = useCallback(async (
- tenantId: string,
- request: BulkNotificationRequest
- ): Promise => {
- try {
- setIsLoading(true);
- setError(null);
-
- await notificationService.sendBulkNotifications(tenantId, request);
- } catch (error) {
- const message = error instanceof Error ? error.message : 'Failed to send bulk notifications';
- setError(message);
- throw error;
- } finally {
- setIsLoading(false);
- }
- }, []);
-
- const getNotifications = useCallback(async (tenantId: string): Promise => {
- try {
- setIsLoading(true);
- setError(null);
-
- const response = await notificationService.getNotifications(tenantId);
- setNotifications(response.data);
-
- return response.data;
- } catch (error) {
- const message = error instanceof Error ? error.message : 'Failed to get notifications';
- setError(message);
- throw error;
- } finally {
- setIsLoading(false);
- }
- }, []);
-
- const getTemplates = useCallback(async (tenantId: string): Promise => {
- try {
- setIsLoading(true);
- setError(null);
-
- const response = await notificationService.getTemplates(tenantId);
- setTemplates(response.data);
-
- return response.data;
- } catch (error) {
- const message = error instanceof Error ? error.message : 'Failed to get templates';
- setError(message);
- throw error;
- } finally {
- setIsLoading(false);
- }
- }, []);
-
- const createTemplate = useCallback(async (
- tenantId: string,
- template: Omit
- ): Promise => {
- try {
- setIsLoading(true);
- setError(null);
-
- const newTemplate = await notificationService.createTemplate(tenantId, template);
- setTemplates(prev => [newTemplate, ...prev]);
-
- return newTemplate;
- } catch (error) {
- const message = error instanceof Error ? error.message : 'Failed to create template';
- setError(message);
- throw error;
- } finally {
- setIsLoading(false);
- }
- }, []);
-
- const getNotificationStats = useCallback(async (tenantId: string): Promise => {
- try {
- setIsLoading(true);
- setError(null);
-
- const notificationStats = await notificationService.getNotificationStats(tenantId);
- setStats(notificationStats);
-
- return notificationStats;
- } catch (error) {
- const message = error instanceof Error ? error.message : 'Failed to get notification stats';
- setError(message);
- throw error;
- } finally {
- setIsLoading(false);
- }
- }, []);
-
- return {
- notifications,
- templates,
- stats,
- isLoading,
- error,
- sendNotification,
- sendBulkNotifications,
- getNotifications,
- getTemplates,
- createTemplate,
- getNotificationStats,
- clearError: () => setError(null),
- };
-};
\ No newline at end of file
diff --git a/fdev-ffrontend/src/api/hooks/useOnboarding.ts b/fdev-ffrontend/src/api/hooks/useOnboarding.ts
deleted file mode 100644
index 492a55bf..00000000
--- a/fdev-ffrontend/src/api/hooks/useOnboarding.ts
+++ /dev/null
@@ -1,194 +0,0 @@
-// frontend/src/api/hooks/useOnboarding.ts
-/**
- * Onboarding Hook
- * React hook for managing user onboarding flow and progress
- */
-
-import { useState, useEffect } from 'react';
-import { onboardingService } from '../services/onboarding.service';
-import type { UserProgress, UpdateStepRequest } from '../services/onboarding.service';
-
-export interface UseOnboardingReturn {
- progress: UserProgress | null;
- isLoading: boolean;
- error: string | null;
- currentStep: string | null;
- nextStep: string | null;
- completionPercentage: number;
- isFullyComplete: boolean;
-
- // Actions
- updateStep: (data: UpdateStepRequest) => Promise;
- completeStep: (stepName: string, data?: Record) => Promise;
- resetStep: (stepName: string) => Promise;
- getNextStep: () => Promise;
- completeOnboarding: () => Promise;
- canAccessStep: (stepName: string) => Promise;
- refreshProgress: () => Promise;
-}
-
-export const useOnboarding = (): UseOnboardingReturn => {
- const [progress, setProgress] = useState(null);
- const [isLoading, setIsLoading] = useState(false);
- const [error, setError] = useState(null);
-
- // Derived state
- const currentStep = progress?.current_step || null;
- const nextStep = progress?.next_step || null;
- const completionPercentage = progress?.completion_percentage || 0;
- const isFullyComplete = progress?.fully_completed || false;
-
- // Load initial progress
- const loadProgress = async () => {
- setIsLoading(true);
- setError(null);
-
- try {
- const userProgress = await onboardingService.getUserProgress();
- setProgress(userProgress);
- } catch (err) {
- const message = err instanceof Error ? err.message : 'Failed to load onboarding progress';
- setError(message);
- console.error('Onboarding progress load error:', err);
- } finally {
- setIsLoading(false);
- }
- };
-
- // Update step
- const updateStep = async (data: UpdateStepRequest) => {
- setIsLoading(true);
- setError(null);
-
- try {
- const updatedProgress = await onboardingService.updateStep(data);
- setProgress(updatedProgress);
- } catch (err) {
- const message = err instanceof Error ? err.message : 'Failed to update step';
- setError(message);
- throw err; // Re-throw so calling component can handle it
- } finally {
- setIsLoading(false);
- }
- };
-
- // Complete step with data
- const completeStep = async (stepName: string, data?: Record) => {
- await updateStep({
- step_name: stepName,
- completed: true,
- data
- });
- };
-
- // Reset step
- const resetStep = async (stepName: string) => {
- await updateStep({
- step_name: stepName,
- completed: false
- });
- };
-
- // Get next step
- const getNextStep = async (): Promise => {
- try {
- const result = await onboardingService.getNextStep();
- return result.step;
- } catch (err) {
- const message = err instanceof Error ? err.message : 'Failed to get next step';
- setError(message);
- throw err;
- }
- };
-
- // Complete entire onboarding
- const completeOnboarding = async () => {
- setIsLoading(true);
- setError(null);
-
- try {
- await onboardingService.completeOnboarding();
- await loadProgress(); // Refresh progress after completion
- } catch (err) {
- const message = err instanceof Error ? err.message : 'Failed to complete onboarding';
- setError(message);
- throw err;
- } finally {
- setIsLoading(false);
- }
- };
-
- // Check if user can access step
- const canAccessStep = async (stepName: string): Promise => {
- try {
- const result = await onboardingService.canAccessStep(stepName);
- return result.can_access;
- } catch (err) {
- console.error('Can access step check failed:', err);
- return false;
- }
- };
-
- // Refresh progress
- const refreshProgress = async () => {
- await loadProgress();
- };
-
- // Load progress on mount
- useEffect(() => {
- loadProgress();
- }, []);
-
- return {
- progress,
- isLoading,
- error,
- currentStep,
- nextStep,
- completionPercentage,
- isFullyComplete,
- updateStep,
- completeStep,
- resetStep,
- getNextStep,
- completeOnboarding,
- canAccessStep,
- refreshProgress,
- };
-};
-
-// Helper hook for specific steps
-export const useOnboardingStep = (stepName: string) => {
- const onboarding = useOnboarding();
-
- const stepStatus = onboarding.progress?.steps.find(
- step => step.step_name === stepName
- );
-
- const isCompleted = stepStatus?.completed || false;
- const stepData = stepStatus?.data || {};
- const completedAt = stepStatus?.completed_at;
-
- const completeThisStep = async (data?: Record) => {
- await onboarding.completeStep(stepName, data);
- };
-
- const resetThisStep = async () => {
- await onboarding.resetStep(stepName);
- };
-
- const canAccessThisStep = async (): Promise => {
- return await onboarding.canAccessStep(stepName);
- };
-
- return {
- ...onboarding,
- stepName,
- isCompleted,
- stepData,
- completedAt,
- completeThisStep,
- resetThisStep,
- canAccessThisStep,
- };
-};
\ No newline at end of file
diff --git a/fdev-ffrontend/src/api/hooks/usePOS.ts b/fdev-ffrontend/src/api/hooks/usePOS.ts
deleted file mode 100644
index 044d968a..00000000
--- a/fdev-ffrontend/src/api/hooks/usePOS.ts
+++ /dev/null
@@ -1,337 +0,0 @@
-// frontend/src/api/hooks/usePOS.ts
-/**
- * React hooks for POS Integration functionality
- */
-
-import { useState, useEffect } from 'react';
-import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query';
-import {
- posService,
- POSConfiguration,
- CreatePOSConfigurationRequest,
- UpdatePOSConfigurationRequest,
- POSTransaction,
- POSSyncLog,
- POSAnalytics,
- SyncRequest
-} from '../services/pos.service';
-import { useTenantId } from './useTenant';
-
-// ============================================================================
-// CONFIGURATION HOOKS
-// ============================================================================
-
-export const usePOSConfigurations = (params?: {
- pos_system?: string;
- is_active?: boolean;
- limit?: number;
- offset?: number;
-}) => {
- const tenantId = useTenantId();
-
- return useQuery({
- queryKey: ['pos-configurations', tenantId, params],
- queryFn: () => posService.getConfigurations(tenantId, params),
- enabled: !!tenantId,
- staleTime: 5 * 60 * 1000, // 5 minutes
- });
-};
-
-export const usePOSConfiguration = (configId?: string) => {
- const tenantId = useTenantId();
-
- return useQuery({
- queryKey: ['pos-configuration', tenantId, configId],
- queryFn: () => posService.getConfiguration(tenantId, configId!),
- enabled: !!tenantId && !!configId,
- staleTime: 5 * 60 * 1000,
- });
-};
-
-export const useCreatePOSConfiguration = () => {
- const queryClient = useQueryClient();
- const tenantId = useTenantId();
-
- return useMutation({
- mutationFn: (data: CreatePOSConfigurationRequest) =>
- posService.createConfiguration(tenantId, data),
- onSuccess: () => {
- queryClient.invalidateQueries({ queryKey: ['pos-configurations', tenantId] });
- },
- });
-};
-
-export const useUpdatePOSConfiguration = () => {
- const queryClient = useQueryClient();
- const tenantId = useTenantId();
-
- return useMutation({
- mutationFn: ({ configId, data }: { configId: string; data: UpdatePOSConfigurationRequest }) =>
- posService.updateConfiguration(tenantId, configId, data),
- onSuccess: (_, { configId }) => {
- queryClient.invalidateQueries({ queryKey: ['pos-configurations', tenantId] });
- queryClient.invalidateQueries({ queryKey: ['pos-configuration', tenantId, configId] });
- },
- });
-};
-
-export const useDeletePOSConfiguration = () => {
- const queryClient = useQueryClient();
- const tenantId = useTenantId();
-
- return useMutation({
- mutationFn: (configId: string) =>
- posService.deleteConfiguration(tenantId, configId),
- onSuccess: () => {
- queryClient.invalidateQueries({ queryKey: ['pos-configurations', tenantId] });
- },
- });
-};
-
-export const useTestPOSConnection = () => {
- const tenantId = useTenantId();
-
- return useMutation({
- mutationFn: (configId: string) =>
- posService.testConnection(tenantId, configId),
- });
-};
-
-// ============================================================================
-// SYNCHRONIZATION HOOKS
-// ============================================================================
-
-export const useTriggerPOSSync = () => {
- const queryClient = useQueryClient();
- const tenantId = useTenantId();
-
- return useMutation({
- mutationFn: ({ configId, syncRequest }: { configId: string; syncRequest: SyncRequest }) =>
- posService.triggerSync(tenantId, configId, syncRequest),
- onSuccess: (_, { configId }) => {
- queryClient.invalidateQueries({ queryKey: ['pos-sync-status', tenantId, configId] });
- queryClient.invalidateQueries({ queryKey: ['pos-sync-logs', tenantId, configId] });
- },
- });
-};
-
-export const usePOSSyncStatus = (configId?: string, pollingInterval?: number) => {
- const tenantId = useTenantId();
-
- return useQuery({
- queryKey: ['pos-sync-status', tenantId, configId],
- queryFn: () => posService.getSyncStatus(tenantId, configId!),
- enabled: !!tenantId && !!configId,
- refetchInterval: pollingInterval || 30000, // Poll every 30 seconds by default
- staleTime: 10 * 1000, // 10 seconds
- });
-};
-
-export const usePOSSyncLogs = (configId?: string, params?: {
- limit?: number;
- offset?: number;
- status?: string;
- sync_type?: string;
- data_type?: string;
-}) => {
- const tenantId = useTenantId();
-
- return useQuery({
- queryKey: ['pos-sync-logs', tenantId, configId, params],
- queryFn: () => posService.getSyncLogs(tenantId, configId!, params),
- enabled: !!tenantId && !!configId,
- staleTime: 2 * 60 * 1000, // 2 minutes
- });
-};
-
-// ============================================================================
-// TRANSACTION HOOKS
-// ============================================================================
-
-export const usePOSTransactions = (params?: {
- pos_system?: string;
- start_date?: string;
- end_date?: string;
- status?: string;
- is_synced?: boolean;
- limit?: number;
- offset?: number;
-}) => {
- const tenantId = useTenantId();
-
- return useQuery({
- queryKey: ['pos-transactions', tenantId, params],
- queryFn: () => posService.getTransactions(tenantId, params),
- enabled: !!tenantId,
- staleTime: 2 * 60 * 1000, // 2 minutes
- });
-};
-
-export const useSyncSingleTransaction = () => {
- const queryClient = useQueryClient();
- const tenantId = useTenantId();
-
- return useMutation({
- mutationFn: ({ transactionId, force }: { transactionId: string; force?: boolean }) =>
- posService.syncSingleTransaction(tenantId, transactionId, force),
- onSuccess: () => {
- queryClient.invalidateQueries({ queryKey: ['pos-transactions', tenantId] });
- },
- });
-};
-
-export const useResyncFailedTransactions = () => {
- const queryClient = useQueryClient();
- const tenantId = useTenantId();
-
- return useMutation({
- mutationFn: (daysBack: number) =>
- posService.resyncFailedTransactions(tenantId, daysBack),
- onSuccess: () => {
- queryClient.invalidateQueries({ queryKey: ['pos-transactions', tenantId] });
- },
- });
-};
-
-// ============================================================================
-// ANALYTICS HOOKS
-// ============================================================================
-
-export const usePOSAnalytics = (days: number = 30) => {
- const tenantId = useTenantId();
-
- return useQuery({
- queryKey: ['pos-analytics', tenantId, days],
- queryFn: () => posService.getSyncAnalytics(tenantId, days),
- enabled: !!tenantId,
- staleTime: 10 * 60 * 1000, // 10 minutes
- });
-};
-
-// ============================================================================
-// SYSTEM INFO HOOKS
-// ============================================================================
-
-export const useSupportedPOSSystems = () => {
- return useQuery({
- queryKey: ['supported-pos-systems'],
- queryFn: () => posService.getSupportedSystems(),
- staleTime: 60 * 60 * 1000, // 1 hour
- });
-};
-
-export const useWebhookStatus = (posSystem?: string) => {
- return useQuery({
- queryKey: ['webhook-status', posSystem],
- queryFn: () => posService.getWebhookStatus(posSystem!),
- enabled: !!posSystem,
- staleTime: 5 * 60 * 1000, // 5 minutes
- });
-};
-
-// ============================================================================
-// COMPOSITE HOOKS
-// ============================================================================
-
-export const usePOSDashboard = () => {
- const tenantId = useTenantId();
-
- // Get configurations
- const { data: configurationsData, isLoading: configurationsLoading } = usePOSConfigurations();
-
- // Get recent transactions
- const { data: transactionsData, isLoading: transactionsLoading } = usePOSTransactions({
- limit: 10
- });
-
- // Get analytics for last 7 days
- const { data: analyticsData, isLoading: analyticsLoading } = usePOSAnalytics(7);
-
- const isLoading = configurationsLoading || transactionsLoading || analyticsLoading;
-
- return {
- configurations: configurationsData?.configurations || [],
- transactions: transactionsData?.transactions || [],
- analytics: analyticsData,
- isLoading,
- summary: {
- total_configurations: configurationsData?.total || 0,
- active_configurations: configurationsData?.configurations?.filter(c => c.is_active).length || 0,
- connected_configurations: configurationsData?.configurations?.filter(c => c.is_connected).length || 0,
- total_transactions: transactionsData?.total || 0,
- total_revenue: transactionsData?.summary?.total_amount || 0,
- sync_health: analyticsData?.success_rate || 0,
- }
- };
-};
-
-export const usePOSConfigurationManagement = () => {
- const createMutation = useCreatePOSConfiguration();
- const updateMutation = useUpdatePOSConfiguration();
- const deleteMutation = useDeletePOSConfiguration();
- const testConnectionMutation = useTestPOSConnection();
-
- const [selectedConfiguration, setSelectedConfiguration] = useState(null);
- const [isFormOpen, setIsFormOpen] = useState(false);
-
- const handleCreate = async (data: CreatePOSConfigurationRequest) => {
- await createMutation.mutateAsync(data);
- setIsFormOpen(false);
- };
-
- const handleUpdate = async (configId: string, data: UpdatePOSConfigurationRequest) => {
- await updateMutation.mutateAsync({ configId, data });
- setIsFormOpen(false);
- setSelectedConfiguration(null);
- };
-
- const handleDelete = async (configId: string) => {
- await deleteMutation.mutateAsync(configId);
- };
-
- const handleTestConnection = async (configId: string) => {
- return await testConnectionMutation.mutateAsync(configId);
- };
-
- const openCreateForm = () => {
- setSelectedConfiguration(null);
- setIsFormOpen(true);
- };
-
- const openEditForm = (configuration: POSConfiguration) => {
- setSelectedConfiguration(configuration);
- setIsFormOpen(true);
- };
-
- const closeForm = () => {
- setIsFormOpen(false);
- setSelectedConfiguration(null);
- };
-
- return {
- // State
- selectedConfiguration,
- isFormOpen,
-
- // Actions
- handleCreate,
- handleUpdate,
- handleDelete,
- handleTestConnection,
- openCreateForm,
- openEditForm,
- closeForm,
-
- // Loading states
- isCreating: createMutation.isPending,
- isUpdating: updateMutation.isPending,
- isDeleting: deleteMutation.isPending,
- isTesting: testConnectionMutation.isPending,
-
- // Errors
- createError: createMutation.error,
- updateError: updateMutation.error,
- deleteError: deleteMutation.error,
- testError: testConnectionMutation.error,
- };
-};
\ No newline at end of file
diff --git a/fdev-ffrontend/src/api/hooks/useProcurement.ts b/fdev-ffrontend/src/api/hooks/useProcurement.ts
deleted file mode 100644
index 067fd9ec..00000000
--- a/fdev-ffrontend/src/api/hooks/useProcurement.ts
+++ /dev/null
@@ -1,294 +0,0 @@
-// ================================================================
-// frontend/src/api/hooks/useProcurement.ts
-// ================================================================
-/**
- * React hooks for procurement planning functionality
- */
-
-import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query';
-import { procurementService } from '../services/procurement.service';
-import type {
- ProcurementPlan,
- GeneratePlanRequest,
- GeneratePlanResponse,
- DashboardData,
- ProcurementRequirement,
- PaginatedProcurementPlans
-} from '../types/procurement';
-
-// ================================================================
-// QUERY KEYS
-// ================================================================
-
-export const procurementKeys = {
- all: ['procurement'] as const,
- plans: () => [...procurementKeys.all, 'plans'] as const,
- plan: (id: string) => [...procurementKeys.plans(), id] as const,
- currentPlan: () => [...procurementKeys.plans(), 'current'] as const,
- planByDate: (date: string) => [...procurementKeys.plans(), 'date', date] as const,
- plansList: (filters?: any) => [...procurementKeys.plans(), 'list', filters] as const,
- requirements: () => [...procurementKeys.all, 'requirements'] as const,
- planRequirements: (planId: string) => [...procurementKeys.requirements(), 'plan', planId] as const,
- criticalRequirements: () => [...procurementKeys.requirements(), 'critical'] as const,
- dashboard: () => [...procurementKeys.all, 'dashboard'] as const,
-};
-
-// ================================================================
-// PROCUREMENT PLAN HOOKS
-// ================================================================
-
-/**
- * Hook to fetch the current day's procurement plan
- */
-export function useCurrentProcurementPlan() {
- return useQuery({
- queryKey: procurementKeys.currentPlan(),
- queryFn: () => procurementService.getCurrentPlan(),
- staleTime: 5 * 60 * 1000, // 5 minutes
- refetchInterval: 10 * 60 * 1000, // Refetch every 10 minutes
- });
-}
-
-/**
- * Hook to fetch procurement plan by date
- */
-export function useProcurementPlanByDate(date: string, enabled = true) {
- return useQuery({
- queryKey: procurementKeys.planByDate(date),
- queryFn: () => procurementService.getPlanByDate(date),
- enabled: enabled && !!date,
- staleTime: 30 * 60 * 1000, // 30 minutes for historical data
- });
-}
-
-/**
- * Hook to fetch procurement plan by ID
- */
-export function useProcurementPlan(planId: string, enabled = true) {
- return useQuery({
- queryKey: procurementKeys.plan(planId),
- queryFn: () => procurementService.getPlanById(planId),
- enabled: enabled && !!planId,
- staleTime: 10 * 60 * 1000, // 10 minutes
- });
-}
-
-/**
- * Hook to fetch paginated list of procurement plans
- */
-export function useProcurementPlans(params?: {
- status?: string;
- startDate?: string;
- endDate?: string;
- limit?: number;
- offset?: number;
-}) {
- return useQuery({
- queryKey: procurementKeys.plansList(params),
- queryFn: () => procurementService.listPlans(params),
- staleTime: 5 * 60 * 1000, // 5 minutes
- });
-}
-
-// ================================================================
-// REQUIREMENTS HOOKS
-// ================================================================
-
-/**
- * Hook to fetch requirements for a specific plan
- */
-export function usePlanRequirements(
- planId: string,
- filters?: {
- status?: string;
- priority?: string;
- },
- enabled = true
-) {
- return useQuery({
- queryKey: procurementKeys.planRequirements(planId),
- queryFn: () => procurementService.getPlanRequirements(planId, filters),
- enabled: enabled && !!planId,
- staleTime: 5 * 60 * 1000, // 5 minutes
- });
-}
-
-/**
- * Hook to fetch critical requirements across all plans
- */
-export function useCriticalRequirements() {
- return useQuery({
- queryKey: procurementKeys.criticalRequirements(),
- queryFn: () => procurementService.getCriticalRequirements(),
- staleTime: 2 * 60 * 1000, // 2 minutes for critical data
- refetchInterval: 5 * 60 * 1000, // Refetch every 5 minutes
- });
-}
-
-// ================================================================
-// DASHBOARD HOOKS
-// ================================================================
-
-/**
- * Hook to fetch procurement dashboard data
- */
-export function useProcurementDashboard() {
- return useQuery({
- queryKey: procurementKeys.dashboard(),
- queryFn: () => procurementService.getDashboardData(),
- staleTime: 2 * 60 * 1000, // 2 minutes
- refetchInterval: 5 * 60 * 1000, // Refetch every 5 minutes
- });
-}
-
-// ================================================================
-// MUTATION HOOKS
-// ================================================================
-
-/**
- * Hook to generate a new procurement plan
- */
-export function useGenerateProcurementPlan() {
- const queryClient = useQueryClient();
-
- return useMutation({
- mutationFn: (request: GeneratePlanRequest) =>
- procurementService.generatePlan(request),
- onSuccess: (data: GeneratePlanResponse) => {
- // Invalidate relevant queries
- queryClient.invalidateQueries({ queryKey: procurementKeys.plans() });
- queryClient.invalidateQueries({ queryKey: procurementKeys.dashboard() });
-
- // If plan was generated successfully, update the cache
- if (data.success && data.plan) {
- queryClient.setQueryData(
- procurementKeys.plan(data.plan.id),
- data.plan
- );
-
- // Update current plan cache if this is today's plan
- const today = new Date().toISOString().split('T')[0];
- if (data.plan.plan_date === today) {
- queryClient.setQueryData(
- procurementKeys.currentPlan(),
- data.plan
- );
- }
- }
- },
- });
-}
-
-/**
- * Hook to update procurement plan status
- */
-export function useUpdatePlanStatus() {
- const queryClient = useQueryClient();
-
- return useMutation({
- mutationFn: ({ planId, status }: { planId: string; status: string }) =>
- procurementService.updatePlanStatus(planId, status),
- onSuccess: (updatedPlan: ProcurementPlan) => {
- // Update the specific plan in cache
- queryClient.setQueryData(
- procurementKeys.plan(updatedPlan.id),
- updatedPlan
- );
-
- // Update current plan if this is the current plan
- const today = new Date().toISOString().split('T')[0];
- if (updatedPlan.plan_date === today) {
- queryClient.setQueryData(
- procurementKeys.currentPlan(),
- updatedPlan
- );
- }
-
- // Invalidate lists to ensure they're refreshed
- queryClient.invalidateQueries({ queryKey: procurementKeys.plansList() });
- queryClient.invalidateQueries({ queryKey: procurementKeys.dashboard() });
- },
- });
-}
-
-/**
- * Hook to trigger the daily scheduler manually
- */
-export function useTriggerDailyScheduler() {
- const queryClient = useQueryClient();
-
- return useMutation({
- mutationFn: () => procurementService.triggerDailyScheduler(),
- onSuccess: () => {
- // Invalidate all procurement data
- queryClient.invalidateQueries({ queryKey: procurementKeys.all });
- },
- });
-}
-
-// ================================================================
-// UTILITY HOOKS
-// ================================================================
-
-/**
- * Hook to check procurement service health
- */
-export function useProcurementHealth() {
- return useQuery({
- queryKey: [...procurementKeys.all, 'health'],
- queryFn: () => procurementService.healthCheck(),
- staleTime: 60 * 1000, // 1 minute
- refetchInterval: 5 * 60 * 1000, // Check every 5 minutes
- });
-}
-
-// ================================================================
-// COMBINED HOOKS
-// ================================================================
-
-/**
- * Combined hook for procurement plan dashboard
- * Fetches current plan, dashboard data, and critical requirements
- */
-export function useProcurementPlanDashboard() {
- const currentPlan = useCurrentProcurementPlan();
- const dashboard = useProcurementDashboard();
- const criticalRequirements = useCriticalRequirements();
- const health = useProcurementHealth();
-
- return {
- currentPlan,
- dashboard,
- criticalRequirements,
- health,
- isLoading: currentPlan.isLoading || dashboard.isLoading,
- error: currentPlan.error || dashboard.error || criticalRequirements.error,
- refetchAll: () => {
- currentPlan.refetch();
- dashboard.refetch();
- criticalRequirements.refetch();
- health.refetch();
- },
- };
-}
-
-/**
- * Hook for managing procurement plan lifecycle
- */
-export function useProcurementPlanActions() {
- const generatePlan = useGenerateProcurementPlan();
- const updateStatus = useUpdatePlanStatus();
- const triggerScheduler = useTriggerDailyScheduler();
-
- return {
- generatePlan: generatePlan.mutate,
- updateStatus: updateStatus.mutate,
- triggerScheduler: triggerScheduler.mutate,
- isGenerating: generatePlan.isPending,
- isUpdating: updateStatus.isPending,
- isTriggering: triggerScheduler.isPending,
- generateError: generatePlan.error,
- updateError: updateStatus.error,
- triggerError: triggerScheduler.error,
- };
-}
\ No newline at end of file
diff --git a/fdev-ffrontend/src/api/hooks/useRecipes.ts b/fdev-ffrontend/src/api/hooks/useRecipes.ts
deleted file mode 100644
index 3e3f33b5..00000000
--- a/fdev-ffrontend/src/api/hooks/useRecipes.ts
+++ /dev/null
@@ -1,682 +0,0 @@
-// frontend/src/api/hooks/useRecipes.ts
-/**
- * React hooks for recipe and production management
- */
-
-import { useState, useEffect, useCallback, useMemo } from 'react';
-import { toast } from 'react-hot-toast';
-import {
- RecipesService,
- Recipe,
- RecipeIngredient,
- CreateRecipeRequest,
- UpdateRecipeRequest,
- RecipeSearchParams,
- RecipeFeasibility,
- RecipeStatistics,
- ProductionBatch,
- CreateProductionBatchRequest,
- UpdateProductionBatchRequest,
- ProductionBatchSearchParams,
- ProductionStatistics
-} from '../services/recipes.service';
-import { useTenant } from './useTenant';
-import { useAuth } from './useAuth';
-
-const recipesService = new RecipesService();
-
-// Recipe Management Hook
-export interface UseRecipesReturn {
- // Data
- recipes: Recipe[];
- selectedRecipe: Recipe | null;
- categories: string[];
- statistics: RecipeStatistics | null;
-
- // State
- isLoading: boolean;
- isCreating: boolean;
- isUpdating: boolean;
- isDeleting: boolean;
- error: string | null;
-
- // Pagination
- pagination: {
- page: number;
- limit: number;
- total: number;
- totalPages: number;
- };
-
- // Actions
- loadRecipes: (params?: RecipeSearchParams) => Promise;
- loadRecipe: (recipeId: string) => Promise;
- createRecipe: (data: CreateRecipeRequest) => Promise;
- updateRecipe: (recipeId: string, data: UpdateRecipeRequest) => Promise;
- deleteRecipe: (recipeId: string) => Promise;
- duplicateRecipe: (recipeId: string, newName: string) => Promise;
- activateRecipe: (recipeId: string) => Promise;
- checkFeasibility: (recipeId: string, batchMultiplier?: number) => Promise;
- loadStatistics: () => Promise;
- loadCategories: () => Promise;
- clearError: () => void;
- refresh: () => Promise;
- setPage: (page: number) => void;
-}
-
-export const useRecipes = (autoLoad: boolean = true): UseRecipesReturn => {
- const { currentTenant } = useTenant();
- const { user } = useAuth();
-
- // State
- const [recipes, setRecipes] = useState([]);
- const [selectedRecipe, setSelectedRecipe] = useState(null);
- const [categories, setCategories] = useState([]);
- const [statistics, setStatistics] = useState(null);
- const [isLoading, setIsLoading] = useState(false);
- const [isCreating, setIsCreating] = useState(false);
- const [isUpdating, setIsUpdating] = useState(false);
- const [isDeleting, setIsDeleting] = useState(false);
- const [error, setError] = useState(null);
- const [currentParams, setCurrentParams] = useState({});
- const [pagination, setPagination] = useState({
- page: 1,
- limit: 20,
- total: 0,
- totalPages: 0
- });
-
- // Load recipes
- const loadRecipes = useCallback(async (params: RecipeSearchParams = {}) => {
- if (!currentTenant?.id) return;
-
- setIsLoading(true);
- setError(null);
-
- try {
- const searchParams = {
- ...params,
- limit: pagination.limit,
- offset: (pagination.page - 1) * pagination.limit
- };
-
- const recipesData = await recipesService.getRecipes(currentTenant.id, searchParams);
- setRecipes(recipesData);
- setCurrentParams(params);
-
- // Calculate pagination (assuming we get total count somehow)
- const total = recipesData.length; // This would need to be from a proper paginated response
- setPagination(prev => ({
- ...prev,
- total,
- totalPages: Math.ceil(total / prev.limit)
- }));
-
- } catch (err: any) {
- const errorMessage = err.response?.data?.detail || err.message || 'Error loading recipes';
- setError(errorMessage);
- toast.error(errorMessage);
- } finally {
- setIsLoading(false);
- }
- }, [currentTenant?.id, pagination.page, pagination.limit]);
-
- // Load single recipe
- const loadRecipe = useCallback(async (recipeId: string) => {
- if (!currentTenant?.id) return;
-
- setIsLoading(true);
- setError(null);
-
- try {
- const recipe = await recipesService.getRecipe(currentTenant.id, recipeId);
- setSelectedRecipe(recipe);
- } catch (err: any) {
- const errorMessage = err.response?.data?.detail || err.message || 'Error loading recipe';
- setError(errorMessage);
- toast.error(errorMessage);
- } finally {
- setIsLoading(false);
- }
- }, [currentTenant?.id]);
-
- // Create recipe
- const createRecipe = useCallback(async (data: CreateRecipeRequest): Promise => {
- if (!currentTenant?.id || !user?.id) return null;
-
- setIsCreating(true);
- setError(null);
-
- try {
- const newRecipe = await recipesService.createRecipe(currentTenant.id, user.id, data);
-
- // Add to local state
- setRecipes(prev => [newRecipe, ...prev]);
-
- toast.success('Recipe created successfully');
- return newRecipe;
- } catch (err: any) {
- const errorMessage = err.response?.data?.detail || err.message || 'Error creating recipe';
- setError(errorMessage);
- toast.error(errorMessage);
- return null;
- } finally {
- setIsCreating(false);
- }
- }, [currentTenant?.id, user?.id]);
-
- // Update recipe
- const updateRecipe = useCallback(async (recipeId: string, data: UpdateRecipeRequest): Promise => {
- if (!currentTenant?.id || !user?.id) return null;
-
- setIsUpdating(true);
- setError(null);
-
- try {
- const updatedRecipe = await recipesService.updateRecipe(currentTenant.id, user.id, recipeId, data);
-
- // Update local state
- setRecipes(prev => prev.map(recipe =>
- recipe.id === recipeId ? updatedRecipe : recipe
- ));
-
- if (selectedRecipe?.id === recipeId) {
- setSelectedRecipe(updatedRecipe);
- }
-
- toast.success('Recipe updated successfully');
- return updatedRecipe;
- } catch (err: any) {
- const errorMessage = err.response?.data?.detail || err.message || 'Error updating recipe';
- setError(errorMessage);
- toast.error(errorMessage);
- return null;
- } finally {
- setIsUpdating(false);
- }
- }, [currentTenant?.id, user?.id, selectedRecipe?.id]);
-
- // Delete recipe
- const deleteRecipe = useCallback(async (recipeId: string): Promise => {
- if (!currentTenant?.id) return false;
-
- setIsDeleting(true);
- setError(null);
-
- try {
- await recipesService.deleteRecipe(currentTenant.id, recipeId);
-
- // Remove from local state
- setRecipes(prev => prev.filter(recipe => recipe.id !== recipeId));
-
- if (selectedRecipe?.id === recipeId) {
- setSelectedRecipe(null);
- }
-
- toast.success('Recipe deleted successfully');
- return true;
- } catch (err: any) {
- const errorMessage = err.response?.data?.detail || err.message || 'Error deleting recipe';
- setError(errorMessage);
- toast.error(errorMessage);
- return false;
- } finally {
- setIsDeleting(false);
- }
- }, [currentTenant?.id, selectedRecipe?.id]);
-
- // Duplicate recipe
- const duplicateRecipe = useCallback(async (recipeId: string, newName: string): Promise => {
- if (!currentTenant?.id || !user?.id) return null;
-
- setIsCreating(true);
- setError(null);
-
- try {
- const duplicatedRecipe = await recipesService.duplicateRecipe(currentTenant.id, user.id, recipeId, newName);
-
- // Add to local state
- setRecipes(prev => [duplicatedRecipe, ...prev]);
-
- toast.success('Recipe duplicated successfully');
- return duplicatedRecipe;
- } catch (err: any) {
- const errorMessage = err.response?.data?.detail || err.message || 'Error duplicating recipe';
- setError(errorMessage);
- toast.error(errorMessage);
- return null;
- } finally {
- setIsCreating(false);
- }
- }, [currentTenant?.id, user?.id]);
-
- // Activate recipe
- const activateRecipe = useCallback(async (recipeId: string): Promise => {
- if (!currentTenant?.id || !user?.id) return null;
-
- setIsUpdating(true);
- setError(null);
-
- try {
- const activatedRecipe = await recipesService.activateRecipe(currentTenant.id, user.id, recipeId);
-
- // Update local state
- setRecipes(prev => prev.map(recipe =>
- recipe.id === recipeId ? activatedRecipe : recipe
- ));
-
- if (selectedRecipe?.id === recipeId) {
- setSelectedRecipe(activatedRecipe);
- }
-
- toast.success('Recipe activated successfully');
- return activatedRecipe;
- } catch (err: any) {
- const errorMessage = err.response?.data?.detail || err.message || 'Error activating recipe';
- setError(errorMessage);
- toast.error(errorMessage);
- return null;
- } finally {
- setIsUpdating(false);
- }
- }, [currentTenant?.id, user?.id, selectedRecipe?.id]);
-
- // Check feasibility
- const checkFeasibility = useCallback(async (recipeId: string, batchMultiplier: number = 1.0): Promise => {
- if (!currentTenant?.id) return null;
-
- try {
- const feasibility = await recipesService.checkRecipeFeasibility(currentTenant.id, recipeId, batchMultiplier);
- return feasibility;
- } catch (err: any) {
- const errorMessage = err.response?.data?.detail || err.message || 'Error checking recipe feasibility';
- setError(errorMessage);
- toast.error(errorMessage);
- return null;
- }
- }, [currentTenant?.id]);
-
- // Load statistics
- const loadStatistics = useCallback(async () => {
- if (!currentTenant?.id) return;
-
- try {
- const stats = await recipesService.getRecipeStatistics(currentTenant.id);
- setStatistics(stats);
- } catch (err: any) {
- console.error('Error loading recipe statistics:', err);
- }
- }, [currentTenant?.id]);
-
- // Load categories
- const loadCategories = useCallback(async () => {
- if (!currentTenant?.id) return;
-
- try {
- const cats = await recipesService.getRecipeCategories(currentTenant.id);
- setCategories(cats);
- } catch (err: any) {
- console.error('Error loading recipe categories:', err);
- }
- }, [currentTenant?.id]);
-
- // Clear error
- const clearError = useCallback(() => {
- setError(null);
- }, []);
-
- // Refresh
- const refresh = useCallback(async () => {
- await Promise.all([
- loadRecipes(currentParams),
- loadStatistics(),
- loadCategories()
- ]);
- }, [loadRecipes, currentParams, loadStatistics, loadCategories]);
-
- // Set page
- const setPage = useCallback((page: number) => {
- setPagination(prev => ({ ...prev, page }));
- }, []);
-
- // Auto-load on mount and dependencies change
- useEffect(() => {
- if (autoLoad && currentTenant?.id) {
- refresh();
- }
- }, [autoLoad, currentTenant?.id, pagination.page]);
-
- return {
- // Data
- recipes,
- selectedRecipe,
- categories,
- statistics,
-
- // State
- isLoading,
- isCreating,
- isUpdating,
- isDeleting,
- error,
- pagination,
-
- // Actions
- loadRecipes,
- loadRecipe,
- createRecipe,
- updateRecipe,
- deleteRecipe,
- duplicateRecipe,
- activateRecipe,
- checkFeasibility,
- loadStatistics,
- loadCategories,
- clearError,
- refresh,
- setPage
- };
-};
-
-// Production Management Hook
-export interface UseProductionReturn {
- // Data
- batches: ProductionBatch[];
- selectedBatch: ProductionBatch | null;
- activeBatches: ProductionBatch[];
- statistics: ProductionStatistics | null;
-
- // State
- isLoading: boolean;
- isCreating: boolean;
- isUpdating: boolean;
- isDeleting: boolean;
- error: string | null;
-
- // Actions
- loadBatches: (params?: ProductionBatchSearchParams) => Promise;
- loadBatch: (batchId: string) => Promise;
- loadActiveBatches: () => Promise;
- createBatch: (data: CreateProductionBatchRequest) => Promise;
- updateBatch: (batchId: string, data: UpdateProductionBatchRequest) => Promise;
- deleteBatch: (batchId: string) => Promise;
- startBatch: (batchId: string, data: any) => Promise;
- completeBatch: (batchId: string, data: any) => Promise;
- loadStatistics: (startDate?: string, endDate?: string) => Promise;
- clearError: () => void;
- refresh: () => Promise;
-}
-
-export const useProduction = (autoLoad: boolean = true): UseProductionReturn => {
- const { currentTenant } = useTenant();
- const { user } = useAuth();
-
- // State
- const [batches, setBatches] = useState([]);
- const [selectedBatch, setSelectedBatch] = useState(null);
- const [activeBatches, setActiveBatches] = useState([]);
- const [statistics, setStatistics] = useState(null);
- const [isLoading, setIsLoading] = useState(false);
- const [isCreating, setIsCreating] = useState(false);
- const [isUpdating, setIsUpdating] = useState(false);
- const [isDeleting, setIsDeleting] = useState(false);
- const [error, setError] = useState(null);
-
- // Load batches
- const loadBatches = useCallback(async (params: ProductionBatchSearchParams = {}) => {
- if (!currentTenant?.id) return;
-
- setIsLoading(true);
- setError(null);
-
- try {
- const batchesData = await recipesService.getProductionBatches(currentTenant.id, params);
- setBatches(batchesData);
- } catch (err: any) {
- const errorMessage = err.response?.data?.detail || err.message || 'Error loading production batches';
- setError(errorMessage);
- toast.error(errorMessage);
- } finally {
- setIsLoading(false);
- }
- }, [currentTenant?.id]);
-
- // Load single batch
- const loadBatch = useCallback(async (batchId: string) => {
- if (!currentTenant?.id) return;
-
- setIsLoading(true);
- setError(null);
-
- try {
- const batch = await recipesService.getProductionBatch(currentTenant.id, batchId);
- setSelectedBatch(batch);
- } catch (err: any) {
- const errorMessage = err.response?.data?.detail || err.message || 'Error loading production batch';
- setError(errorMessage);
- toast.error(errorMessage);
- } finally {
- setIsLoading(false);
- }
- }, [currentTenant?.id]);
-
- // Load active batches
- const loadActiveBatches = useCallback(async () => {
- if (!currentTenant?.id) return;
-
- try {
- const activeBatchesData = await recipesService.getActiveProductionBatches(currentTenant.id);
- setActiveBatches(activeBatchesData);
- } catch (err: any) {
- console.error('Error loading active batches:', err);
- }
- }, [currentTenant?.id]);
-
- // Create batch
- const createBatch = useCallback(async (data: CreateProductionBatchRequest): Promise => {
- if (!currentTenant?.id || !user?.id) return null;
-
- setIsCreating(true);
- setError(null);
-
- try {
- const newBatch = await recipesService.createProductionBatch(currentTenant.id, user.id, data);
-
- // Add to local state
- setBatches(prev => [newBatch, ...prev]);
-
- toast.success('Production batch created successfully');
- return newBatch;
- } catch (err: any) {
- const errorMessage = err.response?.data?.detail || err.message || 'Error creating production batch';
- setError(errorMessage);
- toast.error(errorMessage);
- return null;
- } finally {
- setIsCreating(false);
- }
- }, [currentTenant?.id, user?.id]);
-
- // Update batch
- const updateBatch = useCallback(async (batchId: string, data: UpdateProductionBatchRequest): Promise => {
- if (!currentTenant?.id || !user?.id) return null;
-
- setIsUpdating(true);
- setError(null);
-
- try {
- const updatedBatch = await recipesService.updateProductionBatch(currentTenant.id, user.id, batchId, data);
-
- // Update local state
- setBatches(prev => prev.map(batch =>
- batch.id === batchId ? updatedBatch : batch
- ));
-
- if (selectedBatch?.id === batchId) {
- setSelectedBatch(updatedBatch);
- }
-
- toast.success('Production batch updated successfully');
- return updatedBatch;
- } catch (err: any) {
- const errorMessage = err.response?.data?.detail || err.message || 'Error updating production batch';
- setError(errorMessage);
- toast.error(errorMessage);
- return null;
- } finally {
- setIsUpdating(false);
- }
- }, [currentTenant?.id, user?.id, selectedBatch?.id]);
-
- // Delete batch
- const deleteBatch = useCallback(async (batchId: string): Promise => {
- if (!currentTenant?.id) return false;
-
- setIsDeleting(true);
- setError(null);
-
- try {
- await recipesService.deleteProductionBatch(currentTenant.id, batchId);
-
- // Remove from local state
- setBatches(prev => prev.filter(batch => batch.id !== batchId));
-
- if (selectedBatch?.id === batchId) {
- setSelectedBatch(null);
- }
-
- toast.success('Production batch deleted successfully');
- return true;
- } catch (err: any) {
- const errorMessage = err.response?.data?.detail || err.message || 'Error deleting production batch';
- setError(errorMessage);
- toast.error(errorMessage);
- return false;
- } finally {
- setIsDeleting(false);
- }
- }, [currentTenant?.id, selectedBatch?.id]);
-
- // Start batch
- const startBatch = useCallback(async (batchId: string, data: any): Promise => {
- if (!currentTenant?.id || !user?.id) return null;
-
- setIsUpdating(true);
- setError(null);
-
- try {
- const startedBatch = await recipesService.startProductionBatch(currentTenant.id, user.id, batchId, data);
-
- // Update local state
- setBatches(prev => prev.map(batch =>
- batch.id === batchId ? startedBatch : batch
- ));
-
- if (selectedBatch?.id === batchId) {
- setSelectedBatch(startedBatch);
- }
-
- toast.success('Production batch started successfully');
- return startedBatch;
- } catch (err: any) {
- const errorMessage = err.response?.data?.detail || err.message || 'Error starting production batch';
- setError(errorMessage);
- toast.error(errorMessage);
- return null;
- } finally {
- setIsUpdating(false);
- }
- }, [currentTenant?.id, user?.id, selectedBatch?.id]);
-
- // Complete batch
- const completeBatch = useCallback(async (batchId: string, data: any): Promise => {
- if (!currentTenant?.id || !user?.id) return null;
-
- setIsUpdating(true);
- setError(null);
-
- try {
- const completedBatch = await recipesService.completeProductionBatch(currentTenant.id, user.id, batchId, data);
-
- // Update local state
- setBatches(prev => prev.map(batch =>
- batch.id === batchId ? completedBatch : batch
- ));
-
- if (selectedBatch?.id === batchId) {
- setSelectedBatch(completedBatch);
- }
-
- toast.success('Production batch completed successfully');
- return completedBatch;
- } catch (err: any) {
- const errorMessage = err.response?.data?.detail || err.message || 'Error completing production batch';
- setError(errorMessage);
- toast.error(errorMessage);
- return null;
- } finally {
- setIsUpdating(false);
- }
- }, [currentTenant?.id, user?.id, selectedBatch?.id]);
-
- // Load statistics
- const loadStatistics = useCallback(async (startDate?: string, endDate?: string) => {
- if (!currentTenant?.id) return;
-
- try {
- const stats = await recipesService.getProductionStatistics(currentTenant.id, startDate, endDate);
- setStatistics(stats);
- } catch (err: any) {
- console.error('Error loading production statistics:', err);
- }
- }, [currentTenant?.id]);
-
- // Clear error
- const clearError = useCallback(() => {
- setError(null);
- }, []);
-
- // Refresh
- const refresh = useCallback(async () => {
- await Promise.all([
- loadBatches(),
- loadActiveBatches(),
- loadStatistics()
- ]);
- }, [loadBatches, loadActiveBatches, loadStatistics]);
-
- // Auto-load on mount
- useEffect(() => {
- if (autoLoad && currentTenant?.id) {
- refresh();
- }
- }, [autoLoad, currentTenant?.id]);
-
- return {
- // Data
- batches,
- selectedBatch,
- activeBatches,
- statistics,
-
- // State
- isLoading,
- isCreating,
- isUpdating,
- isDeleting,
- error,
-
- // Actions
- loadBatches,
- loadBatch,
- loadActiveBatches,
- createBatch,
- updateBatch,
- deleteBatch,
- startBatch,
- completeBatch,
- loadStatistics,
- clearError,
- refresh
- };
-};
\ No newline at end of file
diff --git a/fdev-ffrontend/src/api/hooks/useSales.ts b/fdev-ffrontend/src/api/hooks/useSales.ts
deleted file mode 100644
index cbfa3fa3..00000000
--- a/fdev-ffrontend/src/api/hooks/useSales.ts
+++ /dev/null
@@ -1,200 +0,0 @@
-// frontend/src/api/hooks/useSales.ts
-/**
- * Sales Data Management Hooks
- */
-
-import { useState, useCallback } from 'react';
-import { salesService } from '../services/sales.service';
-import type {
- SalesData,
- SalesValidationResult,
- SalesDataQuery,
- SalesDataImport,
- SalesImportResult,
- DashboardStats,
- ActivityItem,
-} from '../types';
-
-export const useSales = () => {
- const [salesData, setSalesData] = useState([]);
- const [dashboardStats, setDashboardStats] = useState(null);
- const [recentActivity, setRecentActivity] = useState([]);
- const [isLoading, setIsLoading] = useState(false);
- const [error, setError] = useState(null);
- const [uploadProgress, setUploadProgress] = useState(0);
-
- const uploadSalesHistory = useCallback(async (
- tenantId: string,
- file: File,
- additionalData?: Record
- ): Promise => {
- try {
- setIsLoading(true);
- setError(null);
- setUploadProgress(0);
-
- const result = await salesService.uploadSalesHistory(tenantId, file, {
- ...additionalData,
- onProgress: (progress) => {
- setUploadProgress(progress.percentage);
- },
- });
-
- return result;
- } catch (error) {
- const message = error instanceof Error ? error.message : 'Upload failed';
- setError(message);
- throw error;
- } finally {
- setIsLoading(false);
- setUploadProgress(0);
- }
- }, []);
-
- const validateSalesData = useCallback(async (
- tenantId: string,
- file: File
- ): Promise => {
- try {
- setIsLoading(true);
- setError(null);
-
- const result = await salesService.validateSalesData(tenantId, file);
- return result;
- } catch (error) {
- const message = error instanceof Error ? error.message : 'Validation failed';
- setError(message);
- throw error;
- } finally {
- setIsLoading(false);
- }
- }, []);
-
- const getSalesData = useCallback(async (
- tenantId: string,
- query?: SalesDataQuery
- ): Promise => {
- try {
- setIsLoading(true);
- setError(null);
-
- const response = await salesService.getSalesData(tenantId, query);
- setSalesData(response.data);
-
- return response.data;
- } catch (error) {
- const message = error instanceof Error ? error.message : 'Failed to get sales data';
- setError(message);
- throw error;
- } finally {
- setIsLoading(false);
- }
- }, []);
-
- const getDashboardStats = useCallback(async (tenantId: string): Promise => {
- try {
- setIsLoading(true);
- setError(null);
-
- const stats = await salesService.getDashboardStats(tenantId);
- setDashboardStats(stats);
-
- return stats;
- } catch (error) {
- const message = error instanceof Error ? error.message : 'Failed to get dashboard stats';
- setError(message);
- throw error;
- } finally {
- setIsLoading(false);
- }
- }, []);
-
- const getRecentActivity = useCallback(async (tenantId: string, limit?: number): Promise => {
- try {
- setIsLoading(true);
- setError(null);
-
- const activity = await salesService.getRecentActivity(tenantId, limit);
- setRecentActivity(activity);
-
- return activity;
- } catch (error) {
- const message = error instanceof Error ? error.message : 'Failed to get recent activity';
- setError(message);
- throw error;
- } finally {
- setIsLoading(false);
- }
- }, []);
-
- const exportSalesData = useCallback(async (
- tenantId: string,
- format: 'csv' | 'excel' | 'json',
- query?: SalesDataQuery
- ): Promise => {
- try {
- setIsLoading(true);
- setError(null);
-
- const blob = await salesService.exportSalesData(tenantId, format, query);
-
- // Create download link
- const url = window.URL.createObjectURL(blob);
- const link = document.createElement('a');
- link.href = url;
- link.download = `sales-data.${format}`;
- document.body.appendChild(link);
- link.click();
- document.body.removeChild(link);
- window.URL.revokeObjectURL(url);
- } catch (error) {
- const message = error instanceof Error ? error.message : 'Export failed';
- setError(message);
- throw error;
- } finally {
- setIsLoading(false);
- }
- }, []);
-
-
- /**
- * Get Sales Analytics
- */
- const getSalesAnalytics = useCallback(async (
- tenantId: string,
- startDate?: string,
- endDate?: string
- ) => {
- try {
- setIsLoading(true);
- setError(null);
-
- const analytics = await salesService.getSalesAnalytics(tenantId, startDate, endDate);
-
- return analytics;
- } catch (error) {
- const message = error instanceof Error ? error.message : 'Failed to get sales analytics';
- setError(message);
- throw error;
- } finally {
- setIsLoading(false);
- }
- }, []);
-
- return {
- salesData,
- dashboardStats,
- recentActivity,
- isLoading,
- error,
- uploadProgress,
- uploadSalesHistory,
- validateSalesData,
- getSalesData,
- getDashboardStats,
- getRecentActivity,
- exportSalesData,
- getSalesAnalytics,
- clearError: () => setError(null),
- };
-};
\ No newline at end of file
diff --git a/fdev-ffrontend/src/api/hooks/useSuppliers.ts b/fdev-ffrontend/src/api/hooks/useSuppliers.ts
deleted file mode 100644
index 0d3cdefe..00000000
--- a/fdev-ffrontend/src/api/hooks/useSuppliers.ts
+++ /dev/null
@@ -1,101 +0,0 @@
-// Simplified useSuppliers hook for TypeScript compatibility
-import { useState } from 'react';
-import {
- SupplierSummary,
- CreateSupplierRequest,
- UpdateSupplierRequest,
- SupplierSearchParams,
- SupplierStatistics,
- PurchaseOrder,
- CreatePurchaseOrderRequest,
- PurchaseOrderSearchParams,
- PurchaseOrderStatistics,
- Delivery,
- DeliverySearchParams,
- DeliveryPerformanceStats
-} from '../services/suppliers.service';
-
-export const useSuppliers = () => {
- const [isLoading, setIsLoading] = useState(false);
- const [error, setError] = useState(null);
-
- // Simple stub implementations
- const getSuppliers = async (params?: SupplierSearchParams) => {
- setIsLoading(true);
- try {
- // Mock data for now
- return [];
- } catch (err) {
- setError(err instanceof Error ? err.message : 'Unknown error');
- throw err;
- } finally {
- setIsLoading(false);
- }
- };
-
- const createSupplier = async (data: CreateSupplierRequest) => {
- setIsLoading(true);
- try {
- // Mock implementation
- return { id: '1', ...data } as any;
- } catch (err) {
- setError(err instanceof Error ? err.message : 'Unknown error');
- throw err;
- } finally {
- setIsLoading(false);
- }
- };
-
- const updateSupplier = async (id: string, data: UpdateSupplierRequest) => {
- setIsLoading(true);
- try {
- // Mock implementation
- return { id, ...data } as any;
- } catch (err) {
- setError(err instanceof Error ? err.message : 'Unknown error');
- throw err;
- } finally {
- setIsLoading(false);
- }
- };
-
- // Return all the expected properties/methods
- return {
- suppliers: [],
- isLoading,
- error,
- getSuppliers,
- createSupplier,
- updateSupplier,
- deleteSupplier: async () => {},
- getSupplierStatistics: async () => ({} as SupplierStatistics),
- getActiveSuppliers: async () => [] as SupplierSummary[],
- getTopSuppliers: async () => [] as SupplierSummary[],
- getSuppliersNeedingReview: async () => [] as SupplierSummary[],
- approveSupplier: async () => {},
- // Purchase orders
- getPurchaseOrders: async () => [] as PurchaseOrder[],
- createPurchaseOrder: async () => ({} as PurchaseOrder),
- updatePurchaseOrderStatus: async () => ({} as PurchaseOrder),
- // Deliveries
- getDeliveries: async () => [] as Delivery[],
- getTodaysDeliveries: async () => [] as Delivery[],
- getDeliveryPerformanceStats: async () => ({} as DeliveryPerformanceStats),
- };
-};
-
-// Re-export types
-export type {
- SupplierSummary,
- CreateSupplierRequest,
- UpdateSupplierRequest,
- SupplierSearchParams,
- SupplierStatistics,
- PurchaseOrder,
- CreatePurchaseOrderRequest,
- PurchaseOrderSearchParams,
- PurchaseOrderStatistics,
- Delivery,
- DeliverySearchParams,
- DeliveryPerformanceStats
-};
\ No newline at end of file
diff --git a/fdev-ffrontend/src/api/hooks/useTenant.ts b/fdev-ffrontend/src/api/hooks/useTenant.ts
deleted file mode 100644
index 4cbc87ca..00000000
--- a/fdev-ffrontend/src/api/hooks/useTenant.ts
+++ /dev/null
@@ -1,209 +0,0 @@
-// frontend/src/api/hooks/useTenant.ts
-/**
- * Tenant Management Hooks
- */
-
-import { useState, useCallback } from 'react';
-import { tenantService } from '../services';
-import type {
- TenantInfo,
- TenantCreate,
- TenantUpdate,
- TenantMember,
- InviteUser,
- TenantStats,
-} from '../types';
-
-export const useTenant = () => {
- const [tenants, setTenants] = useState([]);
- const [currentTenant, setCurrentTenant] = useState(null);
- const [members, setMembers] = useState([]);
- const [stats, setStats] = useState(null);
- const [isLoading, setIsLoading] = useState(false);
- const [error, setError] = useState(null);
-
- const createTenant = useCallback(async (data: TenantCreate): Promise => {
- try {
- setIsLoading(true);
- setError(null);
-
- const tenant = await tenantService.createTenant(data);
- setTenants(prev => [...prev, tenant]);
- setCurrentTenant(tenant);
-
- return tenant;
- } catch (error) {
- const message = error instanceof Error ? error.message : 'Failed to create tenant';
- setError(message);
- throw error;
- } finally {
- setIsLoading(false);
- }
- }, []);
-
- const getTenant = useCallback(async (tenantId: string): Promise => {
- try {
- setIsLoading(true);
- setError(null);
-
- const tenant = await tenantService.getTenant(tenantId);
- setCurrentTenant(tenant);
-
- return tenant;
- } catch (error) {
- const message = error instanceof Error ? error.message : 'Failed to get tenant';
- setError(message);
- throw error;
- } finally {
- setIsLoading(false);
- }
- }, []);
-
- const updateTenant = useCallback(async (tenantId: string, data: TenantUpdate): Promise => {
- try {
- setIsLoading(true);
- setError(null);
-
- const updatedTenant = await tenantService.updateTenant(tenantId, data);
- setCurrentTenant(updatedTenant);
- setTenants(prev => prev.map(t => t.id === tenantId ? updatedTenant : t));
-
- return updatedTenant;
- } catch (error) {
- const message = error instanceof Error ? error.message : 'Failed to update tenant';
- setError(message);
- throw error;
- } finally {
- setIsLoading(false);
- }
- }, []);
-
- const getUserTenants = useCallback(async (): Promise => {
- try {
- setIsLoading(true);
- setError(null);
-
- const userTenants = await tenantService.getUserTenants();
- setTenants(userTenants);
-
- return userTenants;
- } catch (error) {
- const message = error instanceof Error ? error.message : 'Failed to get user tenants';
- setError(message);
- throw error;
- } finally {
- setIsLoading(false);
- }
- }, []);
-
- const getTenantMembers = useCallback(async (tenantId: string): Promise => {
- try {
- setIsLoading(true);
- setError(null);
-
- const response = await tenantService.getTenantMembers(tenantId);
- setMembers(response.data);
-
- return response.data;
- } catch (error) {
- const message = error instanceof Error ? error.message : 'Failed to get tenant members';
- setError(message);
- throw error;
- } finally {
- setIsLoading(false);
- }
- }, []);
-
- const inviteUser = useCallback(async (tenantId: string, invitation: InviteUser): Promise => {
- try {
- setIsLoading(true);
- setError(null);
-
- await tenantService.inviteUser(tenantId, invitation);
-
- // Refresh members list
- await getTenantMembers(tenantId);
- } catch (error) {
- const message = error instanceof Error ? error.message : 'Failed to invite user';
- setError(message);
- throw error;
- } finally {
- setIsLoading(false);
- }
- }, [getTenantMembers]);
-
- const removeMember = useCallback(async (tenantId: string, userId: string): Promise => {
- try {
- setIsLoading(true);
- setError(null);
-
- await tenantService.removeMember(tenantId, userId);
- setMembers(prev => prev.filter(m => m.user_id !== userId));
- } catch (error) {
- const message = error instanceof Error ? error.message : 'Failed to remove member';
- setError(message);
- throw error;
- } finally {
- setIsLoading(false);
- }
- }, []);
-
- const updateMemberRole = useCallback(async (tenantId: string, userId: string, role: string): Promise => {
- try {
- setIsLoading(true);
- setError(null);
-
- const updatedMember = await tenantService.updateMemberRole(tenantId, userId, role);
- setMembers(prev => prev.map(m => m.user_id === userId ? updatedMember : m));
- } catch (error) {
- const message = error instanceof Error ? error.message : 'Failed to update member role';
- setError(message);
- throw error;
- } finally {
- setIsLoading(false);
- }
- }, []);
-
- const getTenantStats = useCallback(async (tenantId: string): Promise => {
- try {
- setIsLoading(true);
- setError(null);
-
- const tenantStats = await tenantService.getTenantStats(tenantId);
- setStats(tenantStats);
-
- return tenantStats;
- } catch (error) {
- const message = error instanceof Error ? error.message : 'Failed to get tenant stats';
- setError(message);
- throw error;
- } finally {
- setIsLoading(false);
- }
- }, []);
-
- return {
- tenants,
- currentTenant,
- members,
- stats,
- isLoading,
- error,
- createTenant,
- getTenant,
- updateTenant,
- getUserTenants,
- getTenantMembers,
- inviteUser,
- removeMember,
- updateMemberRole,
- getTenantStats,
- clearError: () => setError(null),
- };
-};
-
-// Hook to get current tenant ID from context or state
-export const useTenantId = () => {
- const { currentTenant } = useTenant();
- return currentTenant?.id || null;
-};
diff --git a/fdev-ffrontend/src/api/hooks/useTraining.ts b/fdev-ffrontend/src/api/hooks/useTraining.ts
deleted file mode 100644
index 49efbd33..00000000
--- a/fdev-ffrontend/src/api/hooks/useTraining.ts
+++ /dev/null
@@ -1,265 +0,0 @@
-// frontend/src/api/hooks/useTraining.ts
-/**
- * Training Operations Hooks
- */
-
-import { useState, useCallback, useEffect } from 'react';
-import { trainingService } from '../services';
-import type {
- TrainingJobRequest,
- TrainingJobResponse,
- ModelInfo,
- ModelTrainingStats,
- SingleProductTrainingRequest,
-} from '../types';
-
-interface UseTrainingOptions {
- disablePolling?: boolean; // New option to disable HTTP status polling
-}
-
-export const useTraining = (options: UseTrainingOptions = {}) => {
-
- const { disablePolling = false } = options;
-
- // Debug logging for option changes
- console.log('🔧 useTraining initialized with options:', { disablePolling, options });
- const [jobs, setJobs] = useState([]);
- const [currentJob, setCurrentJob] = useState(null);
- const [models, setModels] = useState([]);
- const [stats, setStats] = useState(null);
- const [isLoading, setIsLoading] = useState(false);
- const [error, setError] = useState(null);
-
- const startTrainingJob = useCallback(async (
- tenantId: string,
- request: TrainingJobRequest
- ): Promise => {
- try {
- setIsLoading(true);
- setError(null);
-
- const job = await trainingService.startTrainingJob(tenantId, request);
- setCurrentJob(job);
- setJobs(prev => [job, ...prev]);
-
- return job;
- } catch (error) {
- const message = error instanceof Error ? error.message : 'Failed to start training job';
- setError(message);
- throw error;
- } finally {
- setIsLoading(false);
- }
- }, []);
-
- const startSingleProductTraining = useCallback(async (
- tenantId: string,
- request: SingleProductTrainingRequest
- ): Promise => {
- try {
- setIsLoading(true);
- setError(null);
-
- const job = await trainingService.startSingleProductTraining(tenantId, request);
- setCurrentJob(job);
- setJobs(prev => [job, ...prev]);
-
- return job;
- } catch (error) {
- const message = error instanceof Error ? error.message : 'Failed to start product training';
- setError(message);
- throw error;
- } finally {
- setIsLoading(false);
- }
- }, []);
-
- const getTrainingJobStatus = useCallback(async (
- tenantId: string,
- jobId: string
- ): Promise => {
- try {
- const job = await trainingService.getTrainingJobStatus(tenantId, jobId);
-
- // Update job in state
- setJobs(prev => prev.map(j => j.job_id === jobId ? job : j));
- if (currentJob?.job_id === jobId) {
- setCurrentJob(job);
- }
-
- return job;
- } catch (error) {
- const message = error instanceof Error ? error.message : 'Failed to get job status';
- setError(message);
- throw error;
- }
- }, [currentJob]);
-
- const cancelTrainingJob = useCallback(async (
- tenantId: string,
- jobId: string
- ): Promise => {
- try {
- setIsLoading(true);
- setError(null);
-
- await trainingService.cancelTrainingJob(tenantId, jobId);
-
- // Update job status in state
- setJobs(prev => prev.map(j =>
- j.job_id === jobId ? { ...j, status: 'cancelled' } : j
- ));
- if (currentJob?.job_id === jobId) {
- setCurrentJob({ ...currentJob, status: 'cancelled' });
- }
- } catch (error) {
- const message = error instanceof Error ? error.message : 'Failed to cancel job';
- setError(message);
- throw error;
- } finally {
- setIsLoading(false);
- }
- }, [currentJob]);
-
- const getTrainingJobs = useCallback(async (tenantId: string): Promise => {
- try {
- setIsLoading(true);
- setError(null);
-
- const response = await trainingService.getTrainingJobs(tenantId);
- setJobs(response.data);
-
- return response.data;
- } catch (error) {
- const message = error instanceof Error ? error.message : 'Failed to get training jobs';
- setError(message);
- throw error;
- } finally {
- setIsLoading(false);
- }
- }, []);
-
- const getModels = useCallback(async (tenantId: string): Promise => {
- try {
- setIsLoading(true);
- setError(null);
-
- const response = await trainingService.getModels(tenantId);
- setModels(response.data);
-
- return response.data;
- } catch (error) {
- const message = error instanceof Error ? error.message : 'Failed to get models';
- setError(message);
- throw error;
- } finally {
- setIsLoading(false);
- }
- }, []);
-
- const validateTrainingData = useCallback(async (tenantId: string): Promise<{
- is_valid: boolean;
- message: string;
- details?: any;
- }> => {
- try {
- setIsLoading(true);
- setError(null);
-
- const result = await trainingService.validateTrainingData(tenantId);
- return result;
- } catch (error) {
- const message = error instanceof Error ? error.message : 'Data validation failed';
- setError(message);
- throw error;
- } finally {
- setIsLoading(false);
- }
- }, []);
-
- const getTrainingStats = useCallback(async (tenantId: string): Promise => {
- try {
- setIsLoading(true);
- setError(null);
-
- const trainingStats = await trainingService.getTrainingStats(tenantId);
- setStats(trainingStats);
-
- return trainingStats;
- } catch (error) {
- const message = error instanceof Error ? error.message : 'Failed to get training stats';
- setError(message);
- throw error;
- } finally {
- setIsLoading(false);
- }
- }, []);
-
- useEffect(() => {
- // Always check disablePolling first and log for debugging
- console.log('🔍 useTraining polling check:', {
- disablePolling,
- jobsCount: jobs.length,
- runningJobs: jobs.filter(job => job.status === 'running' || job.status === 'pending').length
- });
-
- // STRICT CHECK: Skip polling if disabled - NO EXCEPTIONS
- if (disablePolling === true) {
- console.log('🚫 HTTP status polling STRICTLY DISABLED - using WebSocket instead');
- console.log('🚫 Effect triggered but polling prevented by disablePolling flag');
- return; // Early return - no cleanup needed, no interval creation
- }
-
- const runningJobs = jobs.filter(job => job.status === 'running' || job.status === 'pending');
-
- if (runningJobs.length === 0) {
- console.log('⏸️ No running jobs - skipping polling setup');
- return;
- }
-
- console.log('🔄 Starting HTTP status polling for', runningJobs.length, 'jobs');
-
- const interval = setInterval(async () => {
- // Double-check disablePolling inside interval to prevent race conditions
- if (disablePolling) {
- console.log('🚫 Polling disabled during interval - clearing');
- clearInterval(interval);
- return;
- }
-
- for (const job of runningJobs) {
- try {
- const tenantId = job.tenant_id;
- console.log('📡 HTTP polling job status:', job.job_id);
- await getTrainingJobStatus(tenantId, job.job_id);
- } catch (error) {
- console.error('Failed to refresh job status:', error);
- }
- }
- }, 5000); // Refresh every 5 seconds
-
- return () => {
- console.log('🛑 Stopping HTTP status polling (cleanup)');
- clearInterval(interval);
- };
- }, [jobs, getTrainingJobStatus, disablePolling]);
-
-
- return {
- jobs,
- currentJob,
- models,
- stats,
- isLoading,
- error,
- startTrainingJob,
- startSingleProductTraining,
- getTrainingJobStatus,
- cancelTrainingJob,
- getTrainingJobs,
- getModels,
- validateTrainingData,
- getTrainingStats,
- clearError: () => setError(null),
- };
-};
diff --git a/fdev-ffrontend/src/api/index.ts b/fdev-ffrontend/src/api/index.ts
deleted file mode 100644
index 701c823f..00000000
--- a/fdev-ffrontend/src/api/index.ts
+++ /dev/null
@@ -1,64 +0,0 @@
-// frontend/src/api/index.ts
-/**
- * Main API Export
- * Central entry point for all API functionality
- */
-
-// Export main API client first
-export { apiClient } from './client';
-
-// Export all services
-export {
- authService,
- tenantService,
- salesService,
- externalService,
- trainingService,
- forecastingService,
- notificationService,
- inventoryService,
- api
-} from './services';
-
-// Export all hooks
-export {
- useAuth,
- useAuthHeaders,
- useTenant,
- useSales,
- useExternal,
- useTraining,
- useForecast,
- useNotification,
- useApiHooks,
- useOnboarding,
- useInventory,
- useInventoryProducts
-} from './hooks';
-
-// Export WebSocket functionality
-export {
- WebSocketManager,
- useWebSocket,
- useTrainingWebSocket,
- useForecastWebSocket,
-} from './websocket';
-
-// Export WebSocket types
-export type {
- WebSocketConfig,
- WebSocketMessage,
- WebSocketHandlers,
- WebSocketStatus,
- WebSocketMetrics,
-} from './websocket';
-
-// Export types
-export * from './types';
-
-// Export configuration
-export { apiConfig, serviceEndpoints, featureFlags } from './client/config';
-
-// Setup interceptors on import (move to end to avoid circular deps)
-import { setupInterceptors } from './client/interceptors';
-setupInterceptors();
\ No newline at end of file
diff --git a/fdev-ffrontend/src/api/services/auth.service.ts b/fdev-ffrontend/src/api/services/auth.service.ts
deleted file mode 100644
index dd2a8c2d..00000000
--- a/fdev-ffrontend/src/api/services/auth.service.ts
+++ /dev/null
@@ -1,107 +0,0 @@
-// frontend/src/api/services/auth.service.ts
-/**
- * Authentication Service
- * Handles all authentication-related API calls
- */
-
-import { apiClient } from '../client';
-import { serviceEndpoints } from '../client/config';
-import type {
- LoginRequest,
- LoginResponse,
- RegisterRequest,
- UserResponse,
- PasswordResetRequest,
- PasswordResetResponse,
- PasswordResetConfirmRequest,
- TokenVerification,
- LogoutResponse,
-} from '../types';
-
-export class AuthService {
- private baseEndpoint = serviceEndpoints.auth;
-
- /**
- * User Registration
- */
- async register(data: RegisterRequest): Promise {
- return apiClient.post(`${this.baseEndpoint}/register`, data);
- }
-
- /**
- * User Login
- */
- async login(credentials: LoginRequest): Promise {
- return apiClient.post(`${this.baseEndpoint}/login`, credentials);
- }
-
- /**
- * User Logout
- */
- async logout(): Promise {
- return apiClient.post(`${this.baseEndpoint}/logout`);
- }
-
- /**
- * Get Current User Profile
- */
- async getCurrentUser(): Promise {
- return apiClient.get(`/users/me`);
- }
-
- /**
- * Update User Profile
- */
- async updateProfile(data: Partial): Promise {
- return apiClient.put(`/users/me`, data);
- }
-
- /**
- * Verify Token
- */
- async verifyToken(token: string): Promise {
- return apiClient.post(`${this.baseEndpoint}/verify-token`, { token });
- }
-
- /**
- * Refresh Access Token
- */
- async refreshToken(refreshToken: string): Promise {
- return apiClient.post(`${this.baseEndpoint}/refresh`, {
- refresh_token: refreshToken,
- });
- }
-
- /**
- * Request Password Reset
- */
- async requestPasswordReset(data: PasswordResetRequest): Promise {
- return apiClient.post(`${this.baseEndpoint}/password-reset`, data);
- }
-
- /**
- * Confirm Password Reset
- */
- async confirmPasswordReset(data: PasswordResetConfirmRequest): Promise<{ message: string }> {
- return apiClient.post(`${this.baseEndpoint}/password-reset/confirm`, data);
- }
-
- /**
- * Change Password (for authenticated users)
- */
- async changePassword(currentPassword: string, newPassword: string): Promise<{ message: string }> {
- return apiClient.post(`/users/me/change-password`, {
- current_password: currentPassword,
- new_password: newPassword,
- });
- }
-
- /**
- * Delete User Account
- */
- async deleteAccount(): Promise<{ message: string }> {
- return apiClient.delete(`/users/me`);
- }
-}
-
-export const authService = new AuthService();
\ No newline at end of file
diff --git a/fdev-ffrontend/src/api/services/external.service.ts b/fdev-ffrontend/src/api/services/external.service.ts
deleted file mode 100644
index c6756d9a..00000000
--- a/fdev-ffrontend/src/api/services/external.service.ts
+++ /dev/null
@@ -1,296 +0,0 @@
-// frontend/src/api/services/external.service.ts
-/**
- * External Data Service
- * Handles weather and traffic data operations for the external microservice
- */
-
-import { apiClient } from '../client';
-import { RequestTimeouts } from '../client/config';
-
-// Align with backend WeatherDataResponse schema
-export interface WeatherData {
- date: string;
- temperature?: number;
- precipitation?: number;
- humidity?: number;
- wind_speed?: number;
- pressure?: number;
- description?: string;
- source: string;
-}
-
-// Align with backend TrafficDataResponse schema
-export interface TrafficData {
- date: string;
- traffic_volume?: number;
- pedestrian_count?: number;
- congestion_level?: string;
- average_speed?: number;
- source: string;
-}
-
-export interface WeatherForecast {
- date: string;
- temperature_min: number;
- temperature_max: number;
- temperature_avg: number;
- precipitation: number;
- description: string;
- humidity?: number;
- wind_speed?: number;
-}
-
-export interface HourlyForecast {
- forecast_datetime: string;
- generated_at: string;
- temperature: number;
- precipitation: number;
- humidity: number;
- wind_speed: number;
- description: string;
- source: string;
- hour: number;
-}
-
-export class ExternalService {
- /**
- * Get Current Weather Data
- */
- async getCurrentWeather(
- tenantId: string,
- lat: number,
- lon: number
- ): Promise {
- try {
- // ✅ FIX 1: Correct endpoint path with tenant ID
- const endpoint = `/tenants/${tenantId}/weather/current`;
-
- // ✅ FIX 2: Correct parameter names (latitude/longitude, not lat/lon)
- const response = await apiClient.get(endpoint, {
- params: {
- latitude: lat, // Backend expects 'latitude'
- longitude: lon // Backend expects 'longitude'
- }
- });
-
- console.log('Weather API response:', response);
-
- // Return backend response directly (matches WeatherData interface)
- return response;
-
- } catch (error) {
- console.error('Failed to fetch weather from AEMET API via backend:', error);
- throw new Error(`Weather data unavailable: ${error instanceof Error ? error.message : 'AEMET API connection failed'}`);
- }
- }
-
- /**
- * Get Weather Forecast
- */
- async getWeatherForecast(
- tenantId: string,
- lat: number,
- lon: number,
- days: number = 7
- ): Promise {
- try {
- // Fix: Use POST with JSON body as expected by backend
- const response = await apiClient.post(`/tenants/${tenantId}/weather/forecast`, {
- latitude: lat,
- longitude: lon,
- days: days
- });
-
- // Handle response format
- if (Array.isArray(response)) {
- return response;
- } else if (response && response.forecasts) {
- return response.forecasts;
- } else {
- console.warn('Unexpected weather forecast response format:', response);
- return [];
- }
- } catch (error) {
- console.error('Failed to fetch weather forecast from AEMET API:', error);
- throw new Error(`Weather forecast unavailable: ${error instanceof Error ? error.message : 'AEMET API connection failed'}`);
- }
- }
-
- /**
- * Get Hourly Weather Forecast (NEW)
- */
- async getHourlyWeatherForecast(
- tenantId: string,
- lat: number,
- lon: number,
- hours: number = 48
- ): Promise {
- try {
- console.log(`🕒 Fetching hourly weather forecast from AEMET API for tenant ${tenantId}`, {
- latitude: lat,
- longitude: lon,
- hours: hours
- });
-
- const response = await apiClient.post(`/tenants/${tenantId}/weather/hourly-forecast`, {
- latitude: lat,
- longitude: lon,
- hours: hours
- });
-
- // Handle response format
- if (Array.isArray(response)) {
- return response;
- } else if (response && response.data) {
- return response.data;
- } else {
- console.warn('Unexpected hourly forecast response format:', response);
- return [];
- }
- } catch (error) {
- console.error('Failed to fetch hourly forecast from AEMET API:', error);
- throw new Error(`Hourly forecast unavailable: ${error instanceof Error ? error.message : 'AEMET API connection failed'}`);
- }
- }
-
- /**
- * Get Historical Weather Data
- */
- async getHistoricalWeather(
- tenantId: string,
- lat: number,
- lon: number,
- startDate: string,
- endDate: string
- ): Promise {
- try {
- // Fix: Use POST with JSON body as expected by backend
- const response = await apiClient.post(`/tenants/${tenantId}/weather/historical`, {
- latitude: lat,
- longitude: lon,
- start_date: startDate,
- end_date: endDate
- });
-
- // Return backend response directly (matches WeatherData interface)
- return Array.isArray(response) ? response : response.data || [];
- } catch (error) {
- console.error('Failed to fetch historical weather from AEMET API:', error);
- throw new Error(`Historical weather data unavailable: ${error instanceof Error ? error.message : 'AEMET API connection failed'}`);
- }
- }
-
- /**
- * Get Current Traffic Data
- */
- async getCurrentTraffic(
- tenantId: string,
- lat: number,
- lon: number
- ): Promise {
- try {
- const response = await apiClient.get(`/tenants/${tenantId}/traffic/current`, {
- params: {
- latitude: lat,
- longitude: lon
- }
- });
-
- // Return backend response directly (matches TrafficData interface)
- return response;
- } catch (error) {
- console.error('Failed to fetch traffic data from external API:', error);
- throw new Error(`Traffic data unavailable: ${error instanceof Error ? error.message : 'External API connection failed'}`);
- }
- }
-
- /**
- * Get Traffic Forecast
- */
- async getTrafficForecast(
- tenantId: string,
- lat: number,
- lon: number,
- hours: number = 24
- ): Promise {
- try {
- // Fix: Use POST with JSON body as expected by backend
- const response = await apiClient.post(`/tenants/${tenantId}/traffic/forecast`, {
- latitude: lat,
- longitude: lon,
- hours: hours
- });
-
- // Return backend response directly (matches TrafficData interface)
- return Array.isArray(response) ? response : response.data || [];
- } catch (error) {
- console.error('Failed to fetch traffic forecast from external API:', error);
- throw new Error(`Traffic forecast unavailable: ${error instanceof Error ? error.message : 'External API connection failed'}`);
- }
- }
-
- /**
- * Get Historical Traffic Data
- */
- async getHistoricalTraffic(
- tenantId: string,
- lat: number,
- lon: number,
- startDate: string,
- endDate: string
- ): Promise {
- try {
- // Fix: Use POST with JSON body as expected by backend
- const response = await apiClient.post(`/tenants/${tenantId}/traffic/historical`, {
- latitude: lat,
- longitude: lon,
- start_date: startDate,
- end_date: endDate
- });
-
- // Return backend response directly (matches TrafficData interface)
- return Array.isArray(response) ? response : response.data || [];
- } catch (error) {
- console.error('Failed to fetch historical traffic from external API:', error);
- throw new Error(`Historical traffic data unavailable: ${error instanceof Error ? error.message : 'External API connection failed'}`);
- }
- }
-
- /**
- * Test External Service Connectivity
- */
- async testConnectivity(tenantId: string): Promise<{
- weather: boolean;
- traffic: boolean;
- overall: boolean;
- }> {
- const results = {
- weather: false,
- traffic: false,
- overall: false
- };
-
- try {
- // Test weather service (AEMET API)
- await this.getCurrentWeather(tenantId, 40.4168, -3.7038); // Madrid coordinates
- results.weather = true;
- } catch (error) {
- console.warn('AEMET weather service connectivity test failed:', error);
- results.weather = false;
- }
-
- try {
- // Test traffic service
- await this.getCurrentTraffic(tenantId, 40.4168, -3.7038); // Madrid coordinates
- results.traffic = true;
- } catch (error) {
- console.warn('Traffic service connectivity test failed:', error);
- results.traffic = false;
- }
-
- results.overall = results.weather && results.traffic;
- return results;
- }
-}
-
-export const externalService = new ExternalService();
\ No newline at end of file
diff --git a/fdev-ffrontend/src/api/services/forecasting.service.ts b/fdev-ffrontend/src/api/services/forecasting.service.ts
deleted file mode 100644
index 83ef95f1..00000000
--- a/fdev-ffrontend/src/api/services/forecasting.service.ts
+++ /dev/null
@@ -1,301 +0,0 @@
-// frontend/src/api/services/forecasting.service.ts
-/**
- * Forecasting Service
- * Handles forecast operations and predictions
- */
-
-import { apiClient } from '../client';
-import { RequestTimeouts } from '../client/config';
-import type {
- SingleForecastRequest,
- BatchForecastRequest,
- ForecastResponse,
- BatchForecastResponse,
- ForecastAlert,
- QuickForecast,
- PaginatedResponse,
- BaseQueryParams,
-} from '../types';
-
-export class ForecastingService {
- /**
- * Create Single Product Forecast
- */
- async createSingleForecast(
- tenantId: string,
- request: SingleForecastRequest
- ): Promise {
- console.log('🔮 Creating single forecast:', { tenantId, request });
-
- try {
- // Backend returns single ForecastResponse object
- const response = await apiClient.post(
- `/tenants/${tenantId}/forecasts/single`,
- request,
- {
- timeout: RequestTimeouts.MEDIUM,
- }
- );
-
- console.log('🔮 Forecast API Response:', response);
- console.log('- Type:', typeof response);
- console.log('- Is Array:', Array.isArray(response));
-
- // ✅ FIX: Convert single response to array
- if (response && typeof response === 'object' && !Array.isArray(response)) {
- // Single forecast response - wrap in array
- const forecastArray = [response as ForecastResponse];
- console.log('✅ Converted single forecast to array:', forecastArray);
- return forecastArray;
- } else if (Array.isArray(response)) {
- // Already an array (unexpected but handle gracefully)
- console.log('✅ Response is already an array:', response);
- return response;
- } else {
- console.error('❌ Unexpected response format:', response);
- throw new Error('Invalid forecast response format');
- }
-
- } catch (error) {
- console.error('❌ Forecast API Error:', error);
- throw error;
- }
- }
-
- /**
- * Create Batch Forecast
- */
- async createBatchForecast(
- tenantId: string,
- request: BatchForecastRequest
- ): Promise