ElPoyo/EM2_ERP
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat: ajout de la configuration des émulateurs Firebase et mise à jour des services pour utiliser le backend sécurisé

Browse Source
This commit is contained in:
ElPoyo
2026-01-06 23:43:36 +01:00
parent fb6a271f66
commit 13a890606d
24 changed files with 1905 additions and 375 deletions
Download Patch File Download Diff File Expand all files Collapse all files

216
em2rp/lib/services/api_service.dart Normal file
View File

@@ -0,0 +1,216 @@
import 'package:firebase_auth/firebase_auth.dart';
import 'package:http/http.dart' as http;
import 'dart:convert';
import 'package:em2rp/config/api_config.dart';
import 'package:cloud_firestore/cloud_firestore.dart';
/// Interface abstraite pour les opérations API
/// Permet de changer facilement de backend (Firebase Functions, REST API personnalisé, etc.)
abstract class ApiService {
Future<Map<String, dynamic>> call(String functionName, Map<String, dynamic> data);
Future<T?> get<T>(String endpoint, {Map<String, dynamic>? params});
Future<T> post<T>(String endpoint, Map<String, dynamic> data);
Future<T> put<T>(String endpoint, Map<String, dynamic> data);
Future<void> delete(String endpoint, {Map<String, dynamic>? data});
}
/// Implémentation pour Firebase Cloud Functions
class FirebaseFunctionsApiService implements ApiService {
// URL de base - gérée par ApiConfig
String get _baseUrl => ApiConfig.baseUrl;
/// Récupère le token d'authentification Firebase
Future<String?> _getAuthToken() async {
final user = FirebaseAuth.instance.currentUser;
if (user == null) return null;
return await user.getIdToken();
}
/// Headers par défaut avec authentification
Future<Map<String, String>> _getHeaders() async {
final token = await _getAuthToken();
return {
'Content-Type': 'application/json',
if (token != null) 'Authorization': 'Bearer $token',
};
}
/// Convertit récursivement les Timestamps Firestore, DocumentReference et GeoPoint en formats encodables
dynamic _convertTimestamps(dynamic value) {
if (value == null) return null;
if (value is Timestamp) {
// Convertir Timestamp en ISO string
return value.toDate().toIso8601String();
} else if (value is DateTime) {
// Convertir DateTime en ISO string
return value.toIso8601String();
} else if (value is DocumentReference) {
// Convertir DocumentReference en path string
return value.path;
} else if (value is GeoPoint) {
// Convertir GeoPoint en objet avec latitude et longitude
return {
'latitude': value.latitude,
'longitude': value.longitude,
};
} else if (value is Map) {
// Parcourir récursivement les Maps et créer une nouvelle Map typée
final Map<String, dynamic> result = {};
value.forEach((key, val) {
result[key.toString()] = _convertTimestamps(val);
});
return result;
} else if (value is List) {
// Parcourir récursivement les Lists
return value.map((item) => _convertTimestamps(item)).toList();
}
return value;
}
@override
Future<Map<String, dynamic>> call(String functionName, Map<String, dynamic> data) async {
final url = Uri.parse('$_baseUrl/$functionName');
final headers = await _getHeaders();
// Convertir les Timestamps avant l'envoi
final convertedData = _convertTimestamps(data) as Map<String, dynamic>;
final response = await http.post(
url,
headers: headers,
body: jsonEncode({'data': convertedData}),
);
if (response.statusCode >= 200 && response.statusCode < 300) {
final responseData = jsonDecode(response.body);
return responseData is Map<String, dynamic> ? responseData : {};
} else {
final error = jsonDecode(response.body);
throw ApiException(
message: error['error'] ?? 'Unknown error',
statusCode: response.statusCode,
);
}
}
@override
Future<T?> get<T>(String endpoint, {Map<String, dynamic>? params}) async {
final url = Uri.parse('$_baseUrl/$endpoint').replace(queryParameters: params);
final headers = await _getHeaders();
final response = await http.get(url, headers: headers);
if (response.statusCode >= 200 && response.statusCode < 300) {
final responseData = jsonDecode(response.body);
return responseData as T?;
} else if (response.statusCode == 404) {
return null;
} else {
final error = jsonDecode(response.body);
throw ApiException(
message: error['error'] ?? 'Unknown error',
statusCode: response.statusCode,
);
}
}
@override
Future<T> post<T>(String endpoint, Map<String, dynamic> data) async {
final url = Uri.parse('$_baseUrl/$endpoint');
final headers = await _getHeaders();
// Convertir les Timestamps avant l'envoi
final convertedData = _convertTimestamps(data) as Map<String, dynamic>;
final response = await http.post(
url,
headers: headers,
body: jsonEncode({'data': convertedData}),
);
if (response.statusCode >= 200 && response.statusCode < 300) {
final responseData = jsonDecode(response.body);
return responseData as T;
} else {
final error = jsonDecode(response.body);
throw ApiException(
message: error['error'] ?? 'Unknown error',
statusCode: response.statusCode,
);
}
}
@override
Future<T> put<T>(String endpoint, Map<String, dynamic> data) async {
final url = Uri.parse('$_baseUrl/$endpoint');
final headers = await _getHeaders();
// Convertir les Timestamps avant l'envoi
final convertedData = _convertTimestamps(data) as Map<String, dynamic>;
final response = await http.put(
url,
headers: headers,
body: jsonEncode({'data': convertedData}),
);
if (response.statusCode >= 200 && response.statusCode < 300) {
final responseData = jsonDecode(response.body);
return responseData as T;
} else {
final error = jsonDecode(response.body);
throw ApiException(
message: error['error'] ?? 'Unknown error',
statusCode: response.statusCode,
);
}
}
@override
Future<void> delete(String endpoint, {Map<String, dynamic>? data}) async {
final url = Uri.parse('$_baseUrl/$endpoint');
final headers = await _getHeaders();
// Convertir les Timestamps avant l'envoi si data existe
final convertedData = data != null ? _convertTimestamps(data) as Map<String, dynamic> : null;
final response = await http.delete(
url,
headers: headers,
body: convertedData != null ? jsonEncode({'data': convertedData}) : null,
);
if (response.statusCode < 200 || response.statusCode >= 300) {
final error = jsonDecode(response.body);
throw ApiException(
message: error['error'] ?? 'Unknown error',
statusCode: response.statusCode,
);
}
}
}
/// Exception personnalisée pour les erreurs API
class ApiException implements Exception {
final String message;
final int statusCode;
ApiException({
required this.message,
required this.statusCode,
});
@override
String toString() => 'ApiException($statusCode): $message';
bool get isForbidden => statusCode == 403;
bool get isUnauthorized => statusCode == 401;
bool get isNotFound => statusCode == 404;
bool get isConflict => statusCode == 409;
}
/// Instance singleton du service API
final ApiService apiService = FirebaseFunctionsApiService();

22
em2rp/lib/services/container_service.dart
View File

@@ -1,38 +1,44 @@
import 'package:cloud_firestore/cloud_firestore.dart';
import 'package:em2rp/models/container_model.dart';
import 'package:em2rp/models/equipment_model.dart';
import 'package:em2rp/services/api_service.dart';
class ContainerService {
final FirebaseFirestore _firestore = FirebaseFirestore.instance;
final ApiService _apiService = apiService;
// Collection references
CollectionReference get _containersCollection => _firestore.collection('containers');
CollectionReference get _equipmentCollection => _firestore.collection('equipments');
// CRUD Operations
// ============================================================================
// CRUD Operations - Utilise le backend sécurisé
// ============================================================================
/// Créer un nouveau container
/// Créer un nouveau container (via Cloud Function)
Future<void> createContainer(ContainerModel container) async {
try {
await _containersCollection.doc(container.id).set(container.toMap());
await _apiService.call('createContainer', container.toMap()..['id'] = container.id);
} catch (e) {
print('Error creating container: $e');
rethrow;
}
}
/// Mettre à jour un container
/// Mettre à jour un container (via Cloud Function)
Future<void> updateContainer(String id, Map<String, dynamic> data) async {
try {
data['updatedAt'] = Timestamp.fromDate(DateTime.now());
await _containersCollection.doc(id).update(data);
await _apiService.call('updateContainer', {
'containerId': id,
'data': data,
});
} catch (e) {
print('Error updating container: $e');
rethrow;
}
}
/// Supprimer un container
/// Supprimer un container (via Cloud Function)
Future<void> deleteContainer(String id) async {
try {
// Récupérer le container pour obtenir les équipements
@@ -55,7 +61,7 @@ class ContainerService {
}
}
await _containersCollection.doc(id).delete();
await _apiService.call('deleteContainer', {'containerId': id});
} catch (e) {
print('Error deleting container: $e');
rethrow;

60
em2rp/lib/services/equipment_service.dart
View File

@@ -2,48 +2,56 @@ import 'package:cloud_firestore/cloud_firestore.dart';
import 'package:em2rp/models/equipment_model.dart';
import 'package:em2rp/models/alert_model.dart';
import 'package:em2rp/models/maintenance_model.dart';
import 'package:em2rp/services/api_service.dart';
class EquipmentService {
final FirebaseFirestore _firestore = FirebaseFirestore.instance;
final ApiService _apiService = apiService;
// Collection references
// Collection references (utilisées seulement pour les lectures)
CollectionReference get _equipmentCollection => _firestore.collection('equipments');
CollectionReference get _alertsCollection => _firestore.collection('alerts');
CollectionReference get _eventsCollection => _firestore.collection('events');
// CRUD Operations
// ============================================================================
// CRUD Operations - Utilise le backend sécurisé
// ============================================================================
/// Créer un nouvel équipement
/// Créer un nouvel équipement (via Cloud Function)
Future<void> createEquipment(EquipmentModel equipment) async {
try {
await _equipmentCollection.doc(equipment.id).set(equipment.toMap());
await _apiService.call('createEquipment', equipment.toMap()..['id'] = equipment.id);
} catch (e) {
print('Error creating equipment: $e');
rethrow;
}
}
/// Mettre à jour un équipement
/// Mettre à jour un équipement (via Cloud Function)
Future<void> updateEquipment(String id, Map<String, dynamic> data) async {
try {
data['updatedAt'] = Timestamp.fromDate(DateTime.now());
await _equipmentCollection.doc(id).update(data);
await _apiService.call('updateEquipment', {
'equipmentId': id,
'data': data,
});
} catch (e) {
print('Error updating equipment: $e');
rethrow;
}
}
/// Supprimer un équipement
/// Supprimer un équipement (via Cloud Function)
Future<void> deleteEquipment(String id) async {
try {
await _equipmentCollection.doc(id).delete();
await _apiService.call('deleteEquipment', {'equipmentId': id});
} catch (e) {
print('Error deleting equipment: $e');
rethrow;
}
}
// ============================================================================
// READ Operations - Utilise Firestore streams (temps réel)
// ============================================================================
/// Récupérer un équipement par ID
Future<EquipmentModel?> getEquipmentById(String id) async {
try {
@@ -58,7 +66,7 @@ class EquipmentService {
}
}
/// Récupérer les équipements avec filtres
/// Récupérer les équipements avec filtres (stream temps réel)
Stream<List<EquipmentModel>> getEquipment({
EquipmentCategory? category,
EquipmentStatus? status,
@@ -106,6 +114,10 @@ class EquipmentService {
}
}
// ============================================================================
// Availability & Stock Management - Logique métier côté client
// ============================================================================
/// Vérifier la disponibilité d'un équipement pour une période donnée
Future<List<String>> checkAvailability(
String equipmentId,
@@ -116,7 +128,7 @@ class EquipmentService {
final conflicts = <String>[];
// Récupérer tous les événements qui chevauchent la période
final eventsQuery = await _eventsCollection
final eventsQuery = await _firestore.collection('events')
.where('StartDateTime', isLessThanOrEqualTo: Timestamp.fromDate(endDate))
.where('EndDateTime', isGreaterThanOrEqualTo: Timestamp.fromDate(startDate))
.get();
@@ -150,7 +162,7 @@ class EquipmentService {
) async {
try {
// Récupérer tous les équipements du même modèle
final equipmentQuery = await _equipmentCollection
final equipmentQuery = await _firestore.collection('equipments')
.where('model', isEqualTo: model)
.get();
@@ -209,7 +221,7 @@ class EquipmentService {
/// Vérifier les stocks critiques et créer des alertes
Future<void> checkCriticalStock() async {
try {
final equipmentQuery = await _equipmentCollection
final equipmentQuery = await _firestore.collection('equipments')
.where('category', whereIn: [
equipmentCategoryToString(EquipmentCategory.consumable),
equipmentCategoryToString(EquipmentCategory.cable),
@@ -236,7 +248,7 @@ class EquipmentService {
Future<void> _createLowStockAlert(EquipmentModel equipment) async {
try {
// Vérifier si une alerte existe déjà pour cet équipement
final existingAlerts = await _alertsCollection
final existingAlerts = await _firestore.collection('alerts')
.where('equipmentId', isEqualTo: equipment.id)
.where('type', isEqualTo: alertTypeToString(AlertType.lowStock))
.where('isRead', isEqualTo: false)
@@ -244,14 +256,14 @@ class EquipmentService {
if (existingAlerts.docs.isEmpty) {
final alert = AlertModel(
id: _alertsCollection.doc().id,
id: _firestore.collection('alerts').doc().id,
type: AlertType.lowStock,
message: 'Stock critique pour ${equipment.name} (${equipment.model ?? ""}): ${equipment.availableQuantity}/${equipment.criticalThreshold}',
equipmentId: equipment.id,
createdAt: DateTime.now(),
);
await _alertsCollection.doc(alert.id).set(alert.toMap());
await _firestore.collection('alerts').doc(alert.id).set(alert.toMap());
}
} catch (e) {
print('Error creating low stock alert: $e');
@@ -269,7 +281,7 @@ class EquipmentService {
/// Récupérer tous les modèles uniques (pour l'indexation/autocomplete)
Future<List<String>> getAllModels() async {
try {
final equipmentQuery = await _equipmentCollection.get();
final equipmentQuery = await _firestore.collection('equipments').get();
final models = <String>{};
for (var doc in equipmentQuery.docs) {
@@ -290,7 +302,7 @@ class EquipmentService {
/// Récupérer toutes les marques uniques (pour l'indexation/autocomplete)
Future<List<String>> getAllBrands() async {
try {
final equipmentQuery = await _equipmentCollection.get();
final equipmentQuery = await _firestore.collection('equipments').get();
final brands = <String>{};
for (var doc in equipmentQuery.docs) {
@@ -311,7 +323,7 @@ class EquipmentService {
/// Récupérer les modèles filtrés par marque
Future<List<String>> getModelsByBrand(String brand) async {
try {
final equipmentQuery = await _equipmentCollection
final equipmentQuery = await _firestore.collection('equipments')
.where('brand', isEqualTo: brand)
.get();
final models = <String>{};
@@ -334,7 +346,7 @@ class EquipmentService {
/// Vérifier si un ID existe déjà
Future<bool> isIdUnique(String id) async {
try {
final doc = await _equipmentCollection.doc(id).get();
final doc = await _firestore.collection('equipments').doc(id).get();
return !doc.exists;
} catch (e) {
print('Error checking ID uniqueness: $e');
@@ -347,7 +359,7 @@ class EquipmentService {
try {
// Les boîtes sont généralement des équipements de catégorie "structure" ou "other"
// On pourrait aussi ajouter un champ spécifique "isBox" dans le modèle
final equipmentQuery = await _equipmentCollection
final equipmentQuery = await _firestore.collection('equipments')
.where('category', whereIn: [
equipmentCategoryToString(EquipmentCategory.structure),
equipmentCategoryToString(EquipmentCategory.other),
@@ -382,7 +394,7 @@ class EquipmentService {
// On doit donc diviser en plusieurs requêtes si nécessaire
for (int i = 0; i < ids.length; i += 10) {
final batch = ids.skip(i).take(10).toList();
final query = await _equipmentCollection
final query = await _firestore.collection('equipments')
.where(FieldPath.documentId, whereIn: batch)
.get();

44
em2rp/lib/services/event_form_service.dart
View File

@@ -7,9 +7,16 @@ import 'dart:convert';
import 'package:em2rp/models/event_model.dart';
import 'package:em2rp/models/event_type_model.dart';
import 'package:em2rp/models/user_model.dart';
import 'package:em2rp/services/api_service.dart';
import 'dart:developer' as developer;
class EventFormService {
static final ApiService _apiService = apiService;
// ============================================================================
// READ Operations - Utilise Firestore (peut rester en lecture directe)
// ============================================================================
static Future<List<EventTypeModel>> fetchEventTypes() async {
developer.log('Fetching event types from Firestore...', name: 'EventFormService');
try {
@@ -33,6 +40,10 @@ class EventFormService {
}
}
// ============================================================================
// STORAGE - Reste inchangé (déjà via Cloud Function)
// ============================================================================
static Future<List<Map<String, String>>> uploadFiles(List<PlatformFile> files) async {
List<Map<String, String>> uploadedFiles = [];
@@ -90,14 +101,39 @@ class EventFormService {
}
}
// ============================================================================
// CRUD Operations - Utilise le backend sécurisé
// ============================================================================
static Future<String> createEvent(EventModel event) async {
final docRef = await FirebaseFirestore.instance.collection('events').add(event.toMap());
return docRef.id;
try {
final result = await _apiService.call('createEvent', event.toMap());
return result['id'] as String;
} catch (e) {
developer.log('Error creating event', name: 'EventFormService', error: e);
rethrow;
}
}
static Future<void> updateEvent(EventModel event) async {
final docRef = FirebaseFirestore.instance.collection('events').doc(event.id);
await docRef.update(event.toMap());
try {
await _apiService.call('updateEvent', {
'eventId': event.id,
'data': event.toMap(),
});
} catch (e) {
developer.log('Error updating event', name: 'EventFormService', error: e);
rethrow;
}
}
static Future<void> deleteEvent(String eventId) async {
try {
await _apiService.call('deleteEvent', {'eventId': eventId});
} catch (e) {
developer.log('Error deleting event', name: 'EventFormService', error: e);
rethrow;
}
}
static Future<List<Map<String, String>>> moveFilesToEvent(

22
em2rp/lib/services/maintenance_service.dart
View File

@@ -3,24 +3,28 @@ import 'package:em2rp/models/maintenance_model.dart';
import 'package:em2rp/models/alert_model.dart';
import 'package:em2rp/models/equipment_model.dart';
import 'package:em2rp/services/equipment_service.dart';
import 'package:em2rp/services/api_service.dart';
class MaintenanceService {
final FirebaseFirestore _firestore = FirebaseFirestore.instance;
final EquipmentService _equipmentService = EquipmentService();
final ApiService _apiService = apiService;
// Collection references
CollectionReference get _maintenancesCollection => _firestore.collection('maintenances');
CollectionReference get _equipmentCollection => _firestore.collection('equipment');
CollectionReference get _equipmentCollection => _firestore.collection('equipments');
CollectionReference get _alertsCollection => _firestore.collection('alerts');
// CRUD Operations
// ============================================================================
// CRUD Operations - Utilise le backend sécurisé
// ============================================================================
/// Créer une nouvelle maintenance
/// Créer une nouvelle maintenance (via Cloud Function)
Future<void> createMaintenance(MaintenanceModel maintenance) async {
try {
await _maintenancesCollection.doc(maintenance.id).set(maintenance.toMap());
await _apiService.call('createMaintenance', maintenance.toMap());
// Mettre à jour les équipements concernés
// Mettre à jour les équipements concernés (côté client pour l'instant)
for (String equipmentId in maintenance.equipmentIds) {
await _updateEquipmentMaintenanceList(equipmentId, maintenance.id);
@@ -35,11 +39,13 @@ class MaintenanceService {
}
}
/// Mettre à jour une maintenance
/// Mettre à jour une maintenance (via Cloud Function)
Future<void> updateMaintenance(String id, Map<String, dynamic> data) async {
try {
data['updatedAt'] = Timestamp.fromDate(DateTime.now());
await _maintenancesCollection.doc(id).update(data);
await _apiService.call('updateMaintenance', {
'maintenanceId': id,
'data': data,
});
} catch (e) {
print('Error updating maintenance: $e');
rethrow;