Upload 2 files

flare-ui/src/app/services/audio-stream-service.ts

@@ -0,0 +1,170 @@
+// audio-stream.service.ts (YENİ DOSYA)
+// Path: /flare-ui/src/app/services/audio-stream.service.ts
+
+import { Injectable, OnDestroy } from '@angular/core';
+import { Subject, Observable } from 'rxjs';
+
+export interface AudioChunk {
+  data: string; // Base64 encoded audio
+  timestamp: number;
+}
+
+@Injectable({
+  providedIn: 'root'
+})
+export class AudioStreamService implements OnDestroy {
+  private mediaRecorder: MediaRecorder | null = null;
+  private audioStream: MediaStream | null = null;
+  private audioChunkSubject = new Subject<AudioChunk>();
+  private recordingStateSubject = new Subject<boolean>();
+  
+  public audioChunk$ = this.audioChunkSubject.asObservable();
+  public recordingState$ = this.recordingStateSubject.asObservable();
+  
+  // Audio constraints
+  private constraints = {
+    audio: {
+      channelCount: 1,
+      sampleRate: 16000,
+      echoCancellation: true,
+      noiseSuppression: true,
+      autoGainControl: true
+    }
+  };
+  
+  ngOnDestroy(): void {
+    this.stopRecording();
+  }
+  
+  static checkBrowserSupport(): boolean {
+    return !!(navigator.mediaDevices && navigator.mediaDevices.getUserMedia);
+  }
+  
+  async startRecording(): Promise<void> {
+    try {
+      // Request microphone access
+      this.audioStream = await navigator.mediaDevices.getUserMedia(this.constraints);
+      
+      // Create MediaRecorder with appropriate format
+      const options: MediaRecorderOptions = {
+        mimeType: this.getPreferredMimeType()
+      };
+      
+      this.mediaRecorder = new MediaRecorder(this.audioStream, options);
+      
+      // Handle data available
+      this.mediaRecorder.ondataavailable = async (event) => {
+        if (event.data.size > 0) {
+          const base64Data = await this.blobToBase64(event.data);
+          this.audioChunkSubject.next({
+            data: base64Data,
+            timestamp: Date.now()
+          });
+        }
+      };
+      
+      // Handle errors
+      this.mediaRecorder.onerror = (error) => {
+        console.error('MediaRecorder error:', error);
+        this.stopRecording();
+      };
+      
+      // Start recording with timeslice for real-time streaming
+      this.mediaRecorder.start(100); // Send chunks every 100ms
+      this.recordingStateSubject.next(true);
+      
+      console.log('✅ Audio recording started');
+      
+    } catch (error) {
+      console.error('Failed to start recording:', error);
+      throw error;
+    }
+  }
+  
+  stopRecording(): void {
+    if (this.mediaRecorder && this.mediaRecorder.state !== 'inactive') {
+      this.mediaRecorder.stop();
+      this.mediaRecorder = null;
+    }
+    
+    if (this.audioStream) {
+      this.audioStream.getTracks().forEach(track => track.stop());
+      this.audioStream = null;
+    }
+    
+    this.recordingStateSubject.next(false);
+    console.log('🛑 Audio recording stopped');
+  }
+  
+  private getPreferredMimeType(): string {
+    const types = [
+      'audio/webm;codecs=opus',
+      'audio/webm',
+      'audio/ogg;codecs=opus',
+      'audio/ogg'
+    ];
+    
+    for (const type of types) {
+      if (MediaRecorder.isTypeSupported(type)) {
+        console.log(`Using MIME type: ${type}`);
+        return type;
+      }
+    }
+    
+    // Fallback to default
+    return '';
+  }
+  
+  private async blobToBase64(blob: Blob): Promise<string> {
+    return new Promise((resolve, reject) => {
+      const reader = new FileReader();
+      reader.onloadend = () => {
+        if (reader.result) {
+          // Remove data URL prefix
+          const base64 = (reader.result as string).split(',')[1];
+          resolve(base64);
+        } else {
+          reject(new Error('Failed to convert blob to base64'));
+        }
+      };
+      reader.onerror = reject;
+      reader.readAsDataURL(blob);
+    });
+  }
+  
+  // Volume level monitoring
+  async getVolumeLevel(): Promise<number> {
+    if (!this.audioStream) return 0;
+    
+    const audioContext = new AudioContext();
+    const analyser = audioContext.createAnalyser();
+    const source = audioContext.createMediaStreamSource(this.audioStream);
+    
+    source.connect(analyser);
+    analyser.fftSize = 256;
+    
+    const dataArray = new Uint8Array(analyser.frequencyBinCount);
+    analyser.getByteFrequencyData(dataArray);
+    
+    // Calculate average volume
+    const average = dataArray.reduce((sum, value) => sum + value, 0) / dataArray.length;
+    
+    // Cleanup
+    source.disconnect();
+    audioContext.close();
+    
+    return average / 255; // Normalize to 0-1
+  }
+  
+  // Check microphone permissions
+  async checkMicrophonePermission(): Promise<PermissionState> {
+    try {
+      const result = await navigator.permissions.query({ name: 'microphone' as PermissionName });
+      return result.state;
+    } catch (error) {
+      console.warn('Permissions API not supported:', error);
+      // Assume granted if API not supported
+      return 'granted';
+    }
+  }
+}

flare-ui/src/app/services/error-handler-service.ts

@@ -0,0 +1,193 @@
+// error-handler.service.ts (YENİ DOSYA)
+// Path: /flare-ui/src/app/services/error-handler.service.ts
+
+import { ErrorHandler, Injectable, Injector } from '@angular/core';
+import { MatSnackBar } from '@angular/material/snack-bar';
+import { Router } from '@angular/router';
+import { HttpErrorResponse } from '@angular/common/http';
+
+interface FlareError {
+  error: string;
+  message: string;
+  details?: any;
+  request_id?: string;
+  timestamp?: string;
+  user_action?: string;
+}
+
+@Injectable({
+  providedIn: 'root'
+})
+export class GlobalErrorHandler implements ErrorHandler {
+  constructor(private injector: Injector) {}
+
+  handleError(error: Error | HttpErrorResponse): void {
+    // Get services lazily to avoid circular dependency
+    const snackBar = this.injector.get(MatSnackBar);
+    const router = this.injector.get(Router);
+    
+    console.error('Global error caught:', error);
+    
+    // Handle HTTP errors
+    if (error instanceof HttpErrorResponse) {
+      this.handleHttpError(error, snackBar, router);
+    } else {
+      // Handle client-side errors
+      this.handleClientError(error, snackBar);
+    }
+  }
+  
+  private handleHttpError(error: HttpErrorResponse, snackBar: MatSnackBar, router: Router): void {
+    const flareError = error.error as FlareError;
+    
+    // Race condition error (409)
+    if (error.status === 409 && flareError.error === 'RaceConditionError') {
+      const snackBarRef = snackBar.open(
+        flareError.message || 'The data was modified by another user. Please refresh and try again.',
+        'Refresh',
+        {
+          duration: 0,
+          panelClass: ['error-snackbar', 'race-condition-snackbar']
+        }
+      );
+      
+      snackBarRef.onAction().subscribe(() => {
+        window.location.reload();
+      });
+      
+      // Show additional info if available
+      if (flareError.details?.last_update_user) {
+        console.info(`Last updated by: ${flareError.details.last_update_user} at ${flareError.details.last_update_date}`);
+      }
+      return;
+    }
+    
+    // Authentication error (401)
+    if (error.status === 401) {
+      snackBar.open(
+        'Your session has expired. Please login again.',
+        'Login',
+        {
+          duration: 5000,
+          panelClass: ['error-snackbar']
+        }
+      ).onAction().subscribe(() => {
+        router.navigate(['/login']);
+      });
+      return;
+    }
+    
+    // Validation error (422)
+    if (error.status === 422 && flareError.details) {
+      const fieldErrors = flareError.details
+        .map((d: any) => `${d.field}: ${d.message}`)
+        .join('\n');
+      
+      snackBar.open(
+        flareError.message || 'Validation failed. Please check your input.',
+        'Close',
+        {
+          duration: 8000,
+          panelClass: ['error-snackbar', 'validation-snackbar']
+        }
+      );
+      
+      console.error('Validation errors:', flareError.details);
+      return;
+    }
+    
+    // Not found error (404)
+    if (error.status === 404) {
+      snackBar.open(
+        flareError.message || 'The requested resource was not found.',
+        'Close',
+        {
+          duration: 5000,
+          panelClass: ['error-snackbar']
+        }
+      );
+      return;
+    }
+    
+    // Server errors (5xx)
+    if (error.status >= 500) {
+      const message = flareError.message || 'A server error occurred. Please try again later.';
+      const requestId = flareError.request_id;
+      
+      snackBar.open(
+        requestId ? `${message} (Request ID: ${requestId})` : message,
+        'Close',
+        {
+          duration: 8000,
+          panelClass: ['error-snackbar', 'server-error-snackbar']
+        }
+      );
+      return;
+    }
+    
+    // Generic HTTP error
+    snackBar.open(
+      flareError.message || `HTTP Error ${error.status}: ${error.statusText}`,
+      'Close',
+      {
+        duration: 6000,
+        panelClass: ['error-snackbar']
+      }
+    );
+  }
+  
+  private handleClientError(error: Error, snackBar: MatSnackBar): void {
+    // Check if it's a network error
+    if (error.message.includes('NetworkError') || error.message.includes('Failed to fetch')) {
+      snackBar.open(
+        'Network connection error. Please check your internet connection.',
+        'Retry',
+        {
+          duration: 0,
+          panelClass: ['error-snackbar', 'network-error-snackbar']
+        }
+      ).onAction().subscribe(() => {
+        window.location.reload();
+      });
+      return;
+    }
+    
+    // Generic client error
+    snackBar.open(
+      'An unexpected error occurred. Please refresh the page.',
+      'Refresh',
+      {
+        duration: 6000,
+        panelClass: ['error-snackbar']
+      }
+    ).onAction().subscribe(() => {
+      window.location.reload();
+    });
+  }
+}
+
+// Error interceptor for consistent error format
+import { HttpInterceptor, HttpRequest, HttpHandler, HttpEvent } from '@angular/common/http';
+import { Observable, throwError } from 'rxjs';
+import { catchError } from 'rxjs/operators';
+
+@Injectable()
+export class ErrorInterceptor implements HttpInterceptor {
+  intercept(req: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>> {
+    return next.handle(req).pipe(
+      catchError((error: HttpErrorResponse) => {
+        // Log request details for debugging
+        console.error('HTTP Error:', {
+          url: req.url,
+          method: req.method,
+          status: error.status,
+          error: error.error,
+          requestId: error.headers.get('X-Request-ID')
+        });
+        
+        // Re-throw to be handled by global error handler
+        return throwError(() => error);
+      })
+    );
+  }
+}