import { users, groups, suppliers, orders, deliveries, userGroups, publicities, publicityParticipations, customerOrders, dlcProducts, tasks, nocodbConfig, invoiceVerificationCache, savTickets, savTicketHistory, weatherData, weatherSettings, type User, type UpsertUser, type Group, type InsertGroup, type Supplier, type InsertSupplier, type Order, type InsertOrder, type Delivery, type InsertDelivery, type UserGroup, type InsertUserGroup, type OrderWithRelations, type DeliveryWithRelations, type UserWithGroups, type Publicity, type InsertPublicity, type PublicityParticipation, type InsertPublicityParticipation, type PublicityWithRelations, type CustomerOrder, type InsertCustomerOrder, type CustomerOrderWithRelations, type DlcProduct, type InsertDlcProduct, type DlcProductFrontend, type InsertDlcProductFrontend, type DlcProductWithRelations, type Task, type InsertTask, type TaskWithRelations, type NocodbConfig, type InsertNocodbConfig, type InvoiceVerificationCache, type InsertInvoiceVerificationCache, type SavTicket, type InsertSavTicket, type SavTicketHistory, type InsertSavTicketHistory, type SavTicketWithRelations, type SavTicketHistoryWithCreator, type WeatherData, type InsertWeatherData, type WeatherSettings, type InsertWeatherSettings, } from "@shared/schema"; import { db } from "./db"; import { eq, and, inArray, desc, sql, gte, lte, lt, or, isNull, isNotNull, asc } from "drizzle-orm"; export interface IStorage { // User operations getUser(id: string): Promise; getUserByEmail(email: string): Promise; getUserByUsername(username: string): Promise; upsertUser(user: UpsertUser): Promise; getUserWithGroups(id: string): Promise; getUsers(): Promise; createUser(user: UpsertUser): Promise; updateUser(id: string, user: Partial): Promise; deleteUser(id: string): Promise; // Group operations getGroups(): Promise; getGroup(id: number): Promise; createGroup(group: InsertGroup): Promise; updateGroup(id: number, group: Partial): Promise; deleteGroup(id: number): Promise; // Supplier operations getSuppliers(): Promise; createSupplier(supplier: InsertSupplier): Promise; updateSupplier(id: number, supplier: Partial): Promise; deleteSupplier(id: number): Promise; // Order operations getOrders(groupIds?: number[]): Promise; getOrdersByDateRange(startDate: string, endDate: string, groupIds?: number[]): Promise; getOrder(id: number): Promise; createOrder(order: InsertOrder): Promise; updateOrder(id: number, order: Partial): Promise; deleteOrder(id: number): Promise; // Delivery operations getDeliveries(groupIds?: number[]): Promise; getDeliveriesByDateRange(startDate: string, endDate: string, groupIds?: number[]): Promise; getDelivery(id: number): Promise; createDelivery(delivery: InsertDelivery): Promise; updateDelivery(id: number, delivery: Partial): Promise; deleteDelivery(id: number): Promise; validateDelivery(id: number, blData?: { blNumber: string; blAmount: number }): Promise; // User-Group operations getUserGroups(userId: string): Promise; assignUserToGroup(userGroup: InsertUserGroup): Promise; removeUserFromGroup(userId: string, groupId: number): Promise; // Statistics getMonthlyStats(year: number, month: number, groupIds?: number[]): Promise<{ ordersCount: number; deliveriesCount: number; pendingOrdersCount: number; averageDeliveryTime: number; totalPalettes: number; totalPackages: number; }>; // Publicity operations getPublicities(year?: number, groupIds?: number[]): Promise; getPublicity(id: number): Promise; createPublicity(publicity: InsertPublicity): Promise; updatePublicity(id: number, publicity: Partial): Promise; deletePublicity(id: number): Promise; // Publicity participation operations getPublicityParticipations(publicityId: number): Promise; setPublicityParticipations(publicityId: number, groupIds: number[]): Promise; // NocoDB Configuration operations getNocodbConfigs(): Promise; getNocodbConfig(id: number): Promise; getActiveNocodbConfig(): Promise; createNocodbConfig(config: InsertNocodbConfig): Promise; updateNocodbConfig(id: number, config: Partial): Promise; deleteNocodbConfig(id: number): Promise; // Invoice Verification Cache operations getInvoiceVerificationCache(cacheKey: string): Promise; saveInvoiceVerificationCache(cache: InsertInvoiceVerificationCache): Promise; createInvoiceVerificationCache(cache: InsertInvoiceVerificationCache): Promise; clearExpiredCache(): Promise; // Customer Order operations getCustomerOrders(groupIds?: number[]): Promise; getCustomerOrder(id: number): Promise; createCustomerOrder(customerOrder: InsertCustomerOrder): Promise; updateCustomerOrder(id: number, customerOrder: Partial): Promise; deleteCustomerOrder(id: number): Promise; // DLC Product operations getDlcProducts(groupIds?: number[], filters?: { status?: string; supplierId?: number; search?: string; }): Promise; getDlcProduct(id: number): Promise; createDlcProduct(dlcProduct: InsertDlcProduct): Promise; updateDlcProduct(id: number, dlcProduct: Partial): Promise; deleteDlcProduct(id: number): Promise; validateDlcProduct(id: number, validatedBy: string): Promise; getDlcStats(groupIds?: number[]): Promise<{ active: number; expiringSoon: number; expired: number; }>; // Task operations getTasks(groupIds?: number[]): Promise; getTask(id: number): Promise; createTask(task: InsertTask): Promise; updateTask(id: number, task: Partial): Promise; deleteTask(id: number): Promise; completeTask(id: number, completedBy?: string): Promise; // SAV operations getSavTickets(filters?: { groupIds?: number[]; status?: string; supplierId?: number; priority?: string; startDate?: string; endDate?: string; }): Promise; getSavTicket(id: number): Promise; createSavTicket(ticket: InsertSavTicket): Promise; updateSavTicket(id: number, ticket: Partial): Promise; deleteSavTicket(id: number): Promise; getSavTicketHistory(ticketId: number): Promise; addSavTicketHistory(history: InsertSavTicketHistory): Promise; getSavTicketStats(groupIds?: number[]): Promise<{ totalTickets: number; newTickets: number; inProgressTickets: number; resolvedTickets: number; criticalTickets: number; }>; // Weather operations getWeatherSettings(): Promise; createWeatherSettings(settings: InsertWeatherSettings): Promise; updateWeatherSettings(id: number, settings: Partial): Promise; getWeatherData(date: string, isCurrentYear: boolean): Promise; createWeatherData(data: InsertWeatherData): Promise; updateWeatherData(id: number, data: Partial): Promise; deleteOldWeatherData(daysToKeep: number): Promise; } export class DatabaseStorage implements IStorage { // User operations async getUser(id: string): Promise { const [user] = await db.select().from(users).where(eq(users.id, id)); return user; } async getUserByEmail(email: string): Promise { const [user] = await db.select().from(users).where(eq(users.email, email)); return user; } async getUserByUsername(username: string): Promise { const [user] = await db.select().from(users).where(eq(users.username, username)); return user; } async upsertUser(userData: UpsertUser): Promise { const [user] = await db .insert(users) .values(userData) .onConflictDoUpdate({ target: users.id, set: { ...userData, updatedAt: new Date(), }, }) .returning(); return user; } async getUserWithGroups(id: string): Promise { const user = await this.getUser(id); if (!user) return undefined; try { const result = await db.execute(sql` SELECT ug.user_id, ug.group_id, g.id as group_id_ref, g.name as group_name, g.color as group_color, g.created_at as group_created_at, g.updated_at as group_updated_at FROM user_groups ug INNER JOIN groups g ON ug.group_id = g.id WHERE ug.user_id = ${id} `); const userGroups = result.rows.map((row: any) => ({ userId: row.user_id, groupId: row.group_id, group: { id: row.group_id_ref, name: row.group_name, color: row.group_color, createdAt: row.group_created_at, updatedAt: row.group_updated_at, } })); return { ...user, userGroups }; } catch (error) { console.error('Error fetching user with groups:', error); return { ...user, userGroups: [] }; } } async getUsers(): Promise { return await db.select().from(users); } async createUser(userData: UpsertUser): Promise { const [user] = await db.insert(users).values(userData).returning(); return user; } async updateUser(id: string, userData: Partial): Promise { const [user] = await db .update(users) .set({ ...userData, updatedAt: new Date() }) .where(eq(users.id, id)) .returning(); return user; } async deleteUser(id: string): Promise { await db.delete(users).where(eq(users.id, id)); } // Group operations async getGroups(): Promise { return await db.select().from(groups).orderBy(groups.name); } async getGroup(id: number): Promise { const [group] = await db.select().from(groups).where(eq(groups.id, id)); return group; } async createGroup(groupData: InsertGroup): Promise { const [group] = await db.insert(groups).values(groupData).returning(); return group; } async updateGroup(id: number, groupData: Partial): Promise { const [group] = await db .update(groups) .set({ ...groupData, updatedAt: new Date() }) .where(eq(groups.id, id)) .returning(); return group; } async deleteGroup(id: number): Promise { await db.delete(groups).where(eq(groups.id, id)); } // Supplier operations async getSuppliers(): Promise { return await db.select().from(suppliers).orderBy(suppliers.name); } async createSupplier(supplierData: InsertSupplier): Promise { const [supplier] = await db.insert(suppliers).values(supplierData).returning(); return supplier; } async updateSupplier(id: number, supplierData: Partial): Promise { const [supplier] = await db .update(suppliers) .set({ ...supplierData, updatedAt: new Date() }) .where(eq(suppliers.id, id)) .returning(); return supplier; } async deleteSupplier(id: number): Promise { await db.delete(suppliers).where(eq(suppliers.id, id)); } // Order operations async getOrders(groupIds?: number[]): Promise { let query = db .select({ id: orders.id, supplierId: orders.supplierId, groupId: orders.groupId, plannedDate: orders.plannedDate, status: orders.status, quantity: orders.quantity, unit: orders.unit, notes: orders.notes, createdBy: orders.createdBy, createdAt: orders.createdAt, updatedAt: orders.updatedAt, supplier: suppliers, group: groups, creator: { id: users.id, firstName: users.firstName, lastName: users.lastName, username: users.username, email: users.email } }) .from(orders) .leftJoin(suppliers, eq(orders.supplierId, suppliers.id)) .leftJoin(groups, eq(orders.groupId, groups.id)) .leftJoin(users, eq(orders.createdBy, users.id)); if (groupIds && groupIds.length > 0) { query = query.where(inArray(orders.groupId, groupIds)); } const baseOrders = await query.orderBy(desc(orders.createdAt)); // Pour chaque commande, récupérer ses livraisons associées (PRODUCTION RELATIONS) const ordersWithDeliveries = await Promise.all( baseOrders.map(async (order) => { const associatedDeliveries = await db .select({ id: deliveries.id, orderId: deliveries.orderId, supplierId: deliveries.supplierId, groupId: deliveries.groupId, scheduledDate: deliveries.scheduledDate, deliveredDate: deliveries.deliveredDate, status: deliveries.status, quantity: deliveries.quantity, unit: deliveries.unit, blNumber: deliveries.blNumber, blAmount: deliveries.blAmount, invoiceReference: deliveries.invoiceReference, invoiceAmount: deliveries.invoiceAmount, reconciled: deliveries.reconciled, validatedAt: deliveries.validatedAt, notes: deliveries.notes, createdBy: deliveries.createdBy, createdAt: deliveries.createdAt, updatedAt: deliveries.updatedAt, supplier: suppliers, group: groups, creator: { id: users.id, firstName: users.firstName, lastName: users.lastName, username: users.username, email: users.email } }) .from(deliveries) .leftJoin(suppliers, eq(deliveries.supplierId, suppliers.id)) .leftJoin(groups, eq(deliveries.groupId, groups.id)) .leftJoin(users, eq(deliveries.createdBy, users.id)) .where(eq(deliveries.orderId, order.id)); return { ...order, deliveries: associatedDeliveries }; }) ); console.log(`🔗 PRODUCTION: getOrders() récupéré ${ordersWithDeliveries.length} commandes avec relations`); return ordersWithDeliveries as OrderWithRelations[]; } async getOrdersByDateRange(startDate: string, endDate: string, groupIds?: number[]): Promise { let query = db .select({ id: orders.id, supplierId: orders.supplierId, groupId: orders.groupId, plannedDate: orders.plannedDate, status: orders.status, quantity: orders.quantity, unit: orders.unit, notes: orders.notes, createdBy: orders.createdBy, createdAt: orders.createdAt, updatedAt: orders.updatedAt, supplier: suppliers, group: groups, creator: { id: users.id, firstName: users.firstName, lastName: users.lastName, username: users.username, email: users.email } }) .from(orders) .leftJoin(suppliers, eq(orders.supplierId, suppliers.id)) .leftJoin(groups, eq(orders.groupId, groups.id)) .leftJoin(users, eq(orders.createdBy, users.id)) .where( and( gte(orders.plannedDate, startDate), lte(orders.plannedDate, endDate) ) ); if (groupIds && groupIds.length > 0) { query = query.where( and( gte(orders.plannedDate, startDate), lte(orders.plannedDate, endDate), inArray(orders.groupId, groupIds) ) ); } const baseOrders = await query.orderBy(desc(orders.plannedDate)); // Pour chaque commande, récupérer ses livraisons associées (PRODUCTION RELATIONS) const ordersWithDeliveries = await Promise.all( baseOrders.map(async (order) => { const associatedDeliveries = await db .select({ id: deliveries.id, orderId: deliveries.orderId, supplierId: deliveries.supplierId, groupId: deliveries.groupId, scheduledDate: deliveries.scheduledDate, deliveredDate: deliveries.deliveredDate, status: deliveries.status, quantity: deliveries.quantity, unit: deliveries.unit, blNumber: deliveries.blNumber, blAmount: deliveries.blAmount, invoiceReference: deliveries.invoiceReference, invoiceAmount: deliveries.invoiceAmount, reconciled: deliveries.reconciled, validatedAt: deliveries.validatedAt, notes: deliveries.notes, createdBy: deliveries.createdBy, createdAt: deliveries.createdAt, updatedAt: deliveries.updatedAt, supplier: suppliers, group: groups, creator: { id: users.id, firstName: users.firstName, lastName: users.lastName, username: users.username, email: users.email } }) .from(deliveries) .leftJoin(suppliers, eq(deliveries.supplierId, suppliers.id)) .leftJoin(groups, eq(deliveries.groupId, groups.id)) .leftJoin(users, eq(deliveries.createdBy, users.id)) .where(eq(deliveries.orderId, order.id)); return { ...order, deliveries: associatedDeliveries }; }) ); return ordersWithDeliveries as OrderWithRelations[]; } async getOrder(id: number): Promise { const [order] = await db .select({ id: orders.id, supplierId: orders.supplierId, groupId: orders.groupId, plannedDate: orders.plannedDate, status: orders.status, quantity: orders.quantity, unit: orders.unit, notes: orders.notes, createdBy: orders.createdBy, createdAt: orders.createdAt, updatedAt: orders.updatedAt, supplier: suppliers, group: groups, creator: { id: users.id, firstName: users.firstName, lastName: users.lastName, username: users.username, email: users.email } }) .from(orders) .leftJoin(suppliers, eq(orders.supplierId, suppliers.id)) .leftJoin(groups, eq(orders.groupId, groups.id)) .leftJoin(users, eq(orders.createdBy, users.id)) .where(eq(orders.id, id)); if (!order) return undefined; // Récupérer les livraisons associées à cette commande (PRODUCTION PostgreSQL) const associatedDeliveries = await db .select({ id: deliveries.id, orderId: deliveries.orderId, supplierId: deliveries.supplierId, groupId: deliveries.groupId, scheduledDate: deliveries.scheduledDate, deliveredDate: deliveries.deliveredDate, status: deliveries.status, quantity: deliveries.quantity, unit: deliveries.unit, blNumber: deliveries.blNumber, blAmount: deliveries.blAmount, invoiceReference: deliveries.invoiceReference, invoiceAmount: deliveries.invoiceAmount, reconciled: deliveries.reconciled, validatedAt: deliveries.validatedAt, notes: deliveries.notes, createdBy: deliveries.createdBy, createdAt: deliveries.createdAt, updatedAt: deliveries.updatedAt, supplier: suppliers, group: groups, creator: { id: users.id, firstName: users.firstName, lastName: users.lastName, username: users.username, email: users.email } }) .from(deliveries) .leftJoin(suppliers, eq(deliveries.supplierId, suppliers.id)) .leftJoin(groups, eq(deliveries.groupId, groups.id)) .leftJoin(users, eq(deliveries.createdBy, users.id)) .where(eq(deliveries.orderId, id)); console.log(`🔗 PRODUCTION: getOrder #${id} found ${associatedDeliveries.length} associated deliveries`); return { ...order, deliveries: associatedDeliveries } as OrderWithRelations; } async createOrder(orderData: InsertOrder): Promise { const [order] = await db.insert(orders).values(orderData).returning(); return order; } async updateOrder(id: number, orderData: Partial): Promise { const [order] = await db .update(orders) .set({ ...orderData, updatedAt: new Date() }) .where(eq(orders.id, id)) .returning(); return order; } async deleteOrder(id: number): Promise { await db.delete(orders).where(eq(orders.id, id)); } // Delivery operations async getDeliveries(groupIds?: number[]): Promise { let query = db .select({ id: deliveries.id, orderId: deliveries.orderId, supplierId: deliveries.supplierId, groupId: deliveries.groupId, scheduledDate: deliveries.scheduledDate, deliveredDate: deliveries.deliveredDate, status: deliveries.status, quantity: deliveries.quantity, unit: deliveries.unit, blNumber: deliveries.blNumber, blAmount: deliveries.blAmount, invoiceReference: deliveries.invoiceReference, invoiceAmount: deliveries.invoiceAmount, reconciled: deliveries.reconciled, validatedAt: deliveries.validatedAt, notes: deliveries.notes, createdBy: deliveries.createdBy, createdAt: deliveries.createdAt, updatedAt: deliveries.updatedAt, supplier: suppliers, group: groups, creator: { id: users.id, firstName: users.firstName, lastName: users.lastName, username: users.username, email: users.email } }) .from(deliveries) .leftJoin(suppliers, eq(deliveries.supplierId, suppliers.id)) .leftJoin(groups, eq(deliveries.groupId, groups.id)) .leftJoin(users, eq(deliveries.createdBy, users.id)); if (groupIds && groupIds.length > 0) { query = query.where(inArray(deliveries.groupId, groupIds)); } const baseDeliveries = await query.orderBy(desc(deliveries.createdAt)); // Pour chaque livraison, récupérer sa commande associée si elle existe (PRODUCTION RELATIONS) const deliveriesWithOrders = await Promise.all( baseDeliveries.map(async (delivery) => { let associatedOrder = undefined; if (delivery.orderId) { try { const [orderData] = await db .select({ id: orders.id, supplierId: orders.supplierId, groupId: orders.groupId, plannedDate: orders.plannedDate, status: orders.status, quantity: orders.quantity, unit: orders.unit, notes: orders.notes, createdBy: orders.createdBy, createdAt: orders.createdAt, updatedAt: orders.updatedAt, supplier: suppliers, group: groups, creator: { id: users.id, firstName: users.firstName, lastName: users.lastName, username: users.username, email: users.email } }) .from(orders) .leftJoin(suppliers, eq(orders.supplierId, suppliers.id)) .leftJoin(groups, eq(orders.groupId, groups.id)) .leftJoin(users, eq(orders.createdBy, users.id)) .where(eq(orders.id, delivery.orderId)); if (orderData) { associatedOrder = orderData; } } catch (error) { console.error(`❌ PRODUCTION: Failed to retrieve associated order #${delivery.orderId} for delivery #${delivery.id}:`, error); } } return { ...delivery, order: associatedOrder }; }) ); console.log(`🔗 PRODUCTION: getDeliveries() récupéré ${deliveriesWithOrders.length} livraisons avec relations`); return deliveriesWithOrders as DeliveryWithRelations[]; } async getDeliveriesByDateRange(startDate: string, endDate: string, groupIds?: number[]): Promise { let query = db .select({ id: deliveries.id, orderId: deliveries.orderId, supplierId: deliveries.supplierId, groupId: deliveries.groupId, scheduledDate: deliveries.scheduledDate, deliveredDate: deliveries.deliveredDate, status: deliveries.status, quantity: deliveries.quantity, unit: deliveries.unit, blNumber: deliveries.blNumber, blAmount: deliveries.blAmount, invoiceReference: deliveries.invoiceReference, invoiceAmount: deliveries.invoiceAmount, reconciled: deliveries.reconciled, validatedAt: deliveries.validatedAt, notes: deliveries.notes, createdBy: deliveries.createdBy, createdAt: deliveries.createdAt, updatedAt: deliveries.updatedAt, supplier: suppliers, group: groups, creator: { id: users.id, firstName: users.firstName, lastName: users.lastName, username: users.username, email: users.email } }) .from(deliveries) .leftJoin(suppliers, eq(deliveries.supplierId, suppliers.id)) .leftJoin(groups, eq(deliveries.groupId, groups.id)) .leftJoin(users, eq(deliveries.createdBy, users.id)) .where( and( gte(deliveries.scheduledDate, startDate), lte(deliveries.scheduledDate, endDate) ) ); if (groupIds && groupIds.length > 0) { query = query.where( and( gte(deliveries.scheduledDate, startDate), lte(deliveries.scheduledDate, endDate), inArray(deliveries.groupId, groupIds) ) ); } const baseDeliveries = await query.orderBy(desc(deliveries.scheduledDate)); // Pour chaque livraison, récupérer sa commande associée si elle existe (PRODUCTION RELATIONS) const deliveriesWithOrders = await Promise.all( baseDeliveries.map(async (delivery) => { let associatedOrder = undefined; if (delivery.orderId) { try { const [orderData] = await db .select({ id: orders.id, supplierId: orders.supplierId, groupId: orders.groupId, plannedDate: orders.plannedDate, status: orders.status, quantity: orders.quantity, unit: orders.unit, notes: orders.notes, createdBy: orders.createdBy, createdAt: orders.createdAt, updatedAt: orders.updatedAt, supplier: suppliers, group: groups, creator: { id: users.id, firstName: users.firstName, lastName: users.lastName, username: users.username, email: users.email } }) .from(orders) .leftJoin(suppliers, eq(orders.supplierId, suppliers.id)) .leftJoin(groups, eq(orders.groupId, groups.id)) .leftJoin(users, eq(orders.createdBy, users.id)) .where(eq(orders.id, delivery.orderId)); if (orderData) { associatedOrder = orderData; } } catch (error) { console.error(`❌ PRODUCTION: Failed to retrieve associated order #${delivery.orderId} for delivery #${delivery.id}:`, error); } } return { ...delivery, order: associatedOrder }; }) ); return deliveriesWithOrders as DeliveryWithRelations[]; } async getDelivery(id: number): Promise { const [delivery] = await db .select({ id: deliveries.id, orderId: deliveries.orderId, supplierId: deliveries.supplierId, groupId: deliveries.groupId, scheduledDate: deliveries.scheduledDate, deliveredDate: deliveries.deliveredDate, status: deliveries.status, quantity: deliveries.quantity, unit: deliveries.unit, blNumber: deliveries.blNumber, blAmount: deliveries.blAmount, invoiceReference: deliveries.invoiceReference, invoiceAmount: deliveries.invoiceAmount, reconciled: deliveries.reconciled, validatedAt: deliveries.validatedAt, notes: deliveries.notes, createdBy: deliveries.createdBy, createdAt: deliveries.createdAt, updatedAt: deliveries.updatedAt, supplier: suppliers, group: groups }) .from(deliveries) .leftJoin(suppliers, eq(deliveries.supplierId, suppliers.id)) .leftJoin(groups, eq(deliveries.groupId, groups.id)) .where(eq(deliveries.id, id)); if (!delivery) return undefined; // Add creator info separately to avoid complex JOIN issues in production let creator = null; try { const user = await this.getUser(delivery.createdBy); if (user) { creator = { id: user.id, firstName: user.firstName, lastName: user.lastName, username: user.username, email: user.email }; } } catch (error) { console.log('⚠️ Could not load creator info:', error); } // Récupérer la commande associée si elle existe (PRODUCTION PostgreSQL) let associatedOrder = undefined; if (delivery.orderId) { try { console.log(`🔗 PRODUCTION: getDelivery #${id} retrieving associated order #${delivery.orderId}`); const orderData = await this.getOrder(delivery.orderId); if (orderData) { associatedOrder = orderData; console.log(`✅ PRODUCTION: getDelivery #${id} found associated order #${delivery.orderId} with status: ${orderData.status}`); } } catch (error) { console.error(`❌ PRODUCTION: Failed to retrieve associated order #${delivery.orderId} for delivery #${id}:`, error); } } return { ...delivery, creator, order: associatedOrder } as DeliveryWithRelations; } async createDelivery(deliveryData: InsertDelivery): Promise { // Créer la livraison avec statut "planned" par défaut const deliveryDataWithStatus = { ...deliveryData, status: deliveryData.status || 'planned' // Force planned status by default }; const [delivery] = await db.insert(deliveries).values(deliveryDataWithStatus).returning(); // Si une commande est liée, la marquer comme "planned" (pas delivered!) if (deliveryData.orderId) { try { console.log(`🔗 PRODUCTION: Delivery #${delivery.id} linked to order #${deliveryData.orderId}, updating order status to 'planned'`); // Récupérer la commande actuelle const [currentOrder] = await db .select() .from(orders) .where(eq(orders.id, deliveryData.orderId)); if (currentOrder && currentOrder.status === 'pending') { await db .update(orders) .set({ status: 'planned', updatedAt: new Date() }) .where(eq(orders.id, deliveryData.orderId)); console.log(`✅ PRODUCTION: Order #${deliveryData.orderId} status updated to 'planned'`); } } catch (error) { console.error(`❌ PRODUCTION: Failed to update order #${deliveryData.orderId} status to planned:`, error); } } return delivery; } async updateDelivery(id: number, deliveryData: Partial): Promise { const [delivery] = await db .update(deliveries) .set({ ...deliveryData, updatedAt: new Date() }) .where(eq(deliveries.id, id)) .returning(); return delivery; } async deleteDelivery(id: number): Promise { await db.delete(deliveries).where(eq(deliveries.id, id)); } async validateDelivery(id: number, blData?: { blNumber: string; blAmount: number }): Promise { const updateData: any = { status: 'delivered', deliveredDate: new Date(), updatedAt: new Date(), }; if (blData) { updateData.blNumber = blData.blNumber; if (blData.blAmount !== undefined) { updateData.blAmount = blData.blAmount.toString(); } } await db.update(deliveries).set(updateData).where(eq(deliveries.id, id)); } // User-Group operations async getUserGroups(userId: string): Promise { return await db.select().from(userGroups).where(eq(userGroups.userId, userId)); } async assignUserToGroup(userGroupData: InsertUserGroup): Promise { const [userGroup] = await db.insert(userGroups).values(userGroupData).returning(); return userGroup; } async removeUserFromGroup(userId: string, groupId: number): Promise { await db.delete(userGroups).where( and(eq(userGroups.userId, userId), eq(userGroups.groupId, groupId)) ); } // Statistics async getMonthlyStats(year: number, month: number, groupIds?: number[]): Promise<{ ordersCount: number; deliveriesCount: number; pendingOrdersCount: number; averageDeliveryTime: number; totalPalettes: number; totalPackages: number; }> { // En mode développement avec MemStorage, retourner des statistiques simulées if (process.env.NODE_ENV === 'development') { console.log('📊 Mode développement - statistiques simulées'); return { ordersCount: 12, deliveriesCount: 8, pendingOrdersCount: 3, averageDeliveryTime: 2.5, totalPalettes: 45, totalPackages: 156, }; } // En production, calculer les vraies statistiques const startDate = `${year}-${month.toString().padStart(2, '0')}-01`; const endDate = month === 12 ? `${year + 1}-01-01` : `${year}-${(month + 1).toString().padStart(2, '0')}-01`; try { console.log('📊 Calcul statistiques mensuelles:', { year, month, startDate, endDate, groupIds }); // Construire les conditions pour le filtrage par groupe - UTILISER LE BON CHAMP DE DATE let ordersWhereCondition = and( gte(orders.plannedDate, startDate), lt(orders.plannedDate, endDate) ); // Pour les livraisons, utiliser deliveredDate pour celles livrées, sinon scheduledDate let deliveriesWhereCondition = and( gte(deliveries.scheduledDate, startDate), lt(deliveries.scheduledDate, endDate) ); // Ajouter le filtre par groupe si spécifié if (groupIds && groupIds.length > 0) { ordersWhereCondition = and(ordersWhereCondition, inArray(orders.groupId, groupIds)); deliveriesWhereCondition = and(deliveriesWhereCondition, inArray(deliveries.groupId, groupIds)); } // Compter les commandes du mois const ordersResult = await db .select({ count: sql`count(*)` }) .from(orders) .where(ordersWhereCondition); // Compter les livraisons du mois const deliveriesResult = await db .select({ count: sql`count(*)` }) .from(deliveries) .where(deliveriesWhereCondition); // Commandes en attente (sans date de livraison ou pas encore livrées) let pendingWhereCondition = eq(orders.status, 'pending'); if (groupIds && groupIds.length > 0) { pendingWhereCondition = and(pendingWhereCondition, inArray(orders.groupId, groupIds)) as any; } const pendingResult = await db .select({ count: sql`count(*)` }) .from(orders) .where(pendingWhereCondition); // Calculer les totaux de palettes et colis du mois (SEULEMENT livraisons delivered) // IMPORTANT: Utiliser deliveredDate pour filtrer par le mois de livraison effective let deliveredWhereCondition = and( gte(deliveries.deliveredDate, sql`${startDate}::timestamp`), lt(deliveries.deliveredDate, sql`${endDate}::timestamp`), eq(deliveries.status, 'delivered'), isNotNull(deliveries.deliveredDate) ); // Ajouter le filtre par groupe pour les livraisons delivered if (groupIds && groupIds.length > 0) { deliveredWhereCondition = and(deliveredWhereCondition, inArray(deliveries.groupId, groupIds)); } const deliveriesStatsResult = await db .select({ totalPalettes: sql`COALESCE(SUM(CAST(${deliveries.quantity} as INTEGER)), 0)`, totalPackages: sql`COALESCE(COUNT(*), 0)`, avgDelay: sql`COALESCE(AVG(EXTRACT(DAY FROM (${deliveries.deliveredDate} - ${deliveries.scheduledDate}))), 0)` }) .from(deliveries) .where(deliveredWhereCondition); const ordersCount = Number(ordersResult[0]?.count || 0); const deliveriesCount = Number(deliveriesResult[0]?.count || 0); const pendingOrdersCount = Number(pendingResult[0]?.count || 0); const totalPalettes = Number(deliveriesStatsResult[0]?.totalPalettes || 0); const totalPackages = Number(deliveriesStatsResult[0]?.totalPackages || 0); const averageDeliveryTime = Number(deliveriesStatsResult[0]?.avgDelay || 0); console.log('📊 Statistiques calculées:', { ordersCount, deliveriesCount, pendingOrdersCount, averageDeliveryTime, totalPalettes, totalPackages, }); return { ordersCount, deliveriesCount, pendingOrdersCount, averageDeliveryTime, totalPalettes, totalPackages, }; } catch (error) { console.error('❌ Erreur calcul statistiques:', error); // Retourner des zéros en cas d'erreur pour éviter un crash return { ordersCount: 0, deliveriesCount: 0, pendingOrdersCount: 0, averageDeliveryTime: 0, totalPalettes: 0, totalPackages: 0, }; } } // Publicity operations async getPublicities(year?: number, groupIds?: number[]): Promise { let query = db .select({ id: publicities.id, pubNumber: publicities.pubNumber, designation: publicities.designation, startDate: publicities.startDate, endDate: publicities.endDate, year: publicities.year, createdBy: publicities.createdBy, createdAt: publicities.createdAt, updatedAt: publicities.updatedAt, }) .from(publicities); if (year) { query = query.where(eq(publicities.year, year)); } const results = await query.orderBy(desc(publicities.createdAt)); const publicityIds = results.map((p: any) => p.id); const participations = publicityIds.length > 0 ? await db .select({ publicityId: publicityParticipations.publicityId, groupId: publicityParticipations.groupId, group: groups, }) .from(publicityParticipations) .leftJoin(groups, eq(publicityParticipations.groupId, groups.id)) .where(inArray(publicityParticipations.publicityId, publicityIds)) : []; return results.map((publicity: any) => ({ ...publicity, participations: participations .filter((p: any) => p.publicityId === publicity.id) .map((p: any) => ({ publicityId: p.publicityId, groupId: p.groupId, group: p.group!, })), })); } async getPublicity(id: number): Promise { const [publicity] = await db.select().from(publicities).where(eq(publicities.id, id)); if (!publicity) return undefined; const participations = await db .select({ publicityId: publicityParticipations.publicityId, groupId: publicityParticipations.groupId, group: groups, }) .from(publicityParticipations) .leftJoin(groups, eq(publicityParticipations.groupId, groups.id)) .where(eq(publicityParticipations.publicityId, id)); return { ...publicity, participations: participations.map((p: any) => ({ publicityId: p.publicityId, groupId: p.groupId, group: p.group!, })), }; } async createPublicity(publicityData: InsertPublicity): Promise { const [publicity] = await db.insert(publicities).values(publicityData).returning(); return publicity; } async updatePublicity(id: number, publicityData: Partial): Promise { const [publicity] = await db .update(publicities) .set({ ...publicityData, updatedAt: new Date() }) .where(eq(publicities.id, id)) .returning(); return publicity; } async deletePublicity(id: number): Promise { await db.delete(publicityParticipations).where(eq(publicityParticipations.publicityId, id)); await db.delete(publicities).where(eq(publicities.id, id)); } async getPublicityParticipations(publicityId: number): Promise { return await db .select() .from(publicityParticipations) .where(eq(publicityParticipations.publicityId, publicityId)); } async setPublicityParticipations(publicityId: number, groupIds: number[]): Promise { await db.delete(publicityParticipations).where(eq(publicityParticipations.publicityId, publicityId)); if (groupIds.length > 0) { const participationsData = groupIds.map(groupId => ({ publicityId, groupId, })); await db.insert(publicityParticipations).values(participationsData); } } // NocoDB Configuration operations async getNocodbConfigs(): Promise { return await db.select().from(nocodbConfig).orderBy(desc(nocodbConfig.createdAt)); } async getNocodbConfig(id: number): Promise { const [config] = await db.select().from(nocodbConfig).where(eq(nocodbConfig.id, id)); return config; } async getActiveNocodbConfig(): Promise { try { const [config] = await db .select() .from(nocodbConfig) .where(eq(nocodbConfig.isActive, true)) .limit(1); console.log('🔧 Configuration NocoDB active récupérée:', config); return config; } catch (error) { console.error('❌ Erreur récupération config NocoDB:', error); return undefined; } } async createNocodbConfig(configData: InsertNocodbConfig): Promise { const [config] = await db.insert(nocodbConfig).values(configData).returning(); return config; } async updateNocodbConfig(id: number, configData: Partial): Promise { const [config] = await db .update(nocodbConfig) .set({ ...configData, updatedAt: new Date() }) .where(eq(nocodbConfig.id, id)) .returning(); return config; } async deleteNocodbConfig(id: number): Promise { await db.delete(nocodbConfig).where(eq(nocodbConfig.id, id)); } // Invoice Verification Cache operations async getInvoiceVerificationCache(cacheKey: string): Promise { const [cache] = await db .select() .from(invoiceVerificationCache) .where(eq(invoiceVerificationCache.cacheKey, cacheKey)); return cache; } async createInvoiceVerificationCache(cacheData: InsertInvoiceVerificationCache): Promise { const [cache] = await db.insert(invoiceVerificationCache).values(cacheData).returning(); return cache; } async saveInvoiceVerificationCache(cacheData: InsertInvoiceVerificationCache): Promise { return this.createInvoiceVerificationCache(cacheData); } async clearExpiredCache(): Promise { await db.delete(invoiceVerificationCache).where( sql`expires_at < NOW()` ); } // Real implementations for production operations async getCustomerOrders(groupIds?: number[]): Promise { let query = db .select({ customerOrder: customerOrders, supplier: suppliers, group: groups }) .from(customerOrders) .leftJoin(suppliers, eq(customerOrders.supplierId, suppliers.id)) .leftJoin(groups, eq(customerOrders.groupId, groups.id)); if (groupIds && groupIds.length > 0) { query = query.where(inArray(customerOrders.groupId, groupIds)); } const results = await query.orderBy(desc(customerOrders.createdAt)); return results.map((row: any) => ({ ...row.customerOrder, supplier: row.supplier, group: row.group, creator: row.creator || { id: row.customerOrder.createdBy, username: 'unknown' } })); } async getCustomerOrder(id: number): Promise { const [result] = await db .select({ customerOrder: customerOrders, supplier: suppliers, group: groups }) .from(customerOrders) .leftJoin(suppliers, eq(customerOrders.supplierId, suppliers.id)) .leftJoin(groups, eq(customerOrders.groupId, groups.id)) .where(eq(customerOrders.id, id)); if (!result) return undefined; return { ...result.customerOrder, supplier: result.supplier, group: result.group, creator: result.creator || { id: result.customerOrder.createdBy, username: 'unknown' } }; } async createCustomerOrder(orderData: InsertCustomerOrder): Promise { const [customerOrder] = await db.insert(customerOrders).values(orderData).returning(); return customerOrder; } async updateCustomerOrder(id: number, orderData: Partial): Promise { const [customerOrder] = await db .update(customerOrders) .set({ ...orderData, updatedAt: new Date() }) .where(eq(customerOrders.id, id)) .returning(); return customerOrder; } async deleteCustomerOrder(id: number): Promise { await db.delete(customerOrders).where(eq(customerOrders.id, id)); } async getDlcProducts(groupIds?: number[], filters?: { status?: string; supplierId?: number; search?: string; }): Promise { let query = db .select({ dlcProduct: dlcProducts, supplier: suppliers, group: groups }) .from(dlcProducts) .leftJoin(suppliers, eq(dlcProducts.supplierId, suppliers.id)) .leftJoin(groups, eq(dlcProducts.groupId, groups.id)); const conditions = []; if (groupIds && groupIds.length > 0) { conditions.push(inArray(dlcProducts.groupId, groupIds)); } if (filters) { if (filters.status) { conditions.push(eq(dlcProducts.status, filters.status)); } if (filters.supplierId) { conditions.push(eq(dlcProducts.supplierId, filters.supplierId)); } if (filters.search) { conditions.push( or( sql`LOWER(${dlcProducts.productName}) LIKE LOWER(${'%' + filters.search + '%'})`, sql`LOWER(${suppliers.name}) LIKE LOWER(${'%' + filters.search + '%'})` ) ); } } if (conditions.length > 0) { query = query.where(and(...conditions)); } const results = await query.orderBy(asc(dlcProducts.expiryDate)); return results.map((row: any) => ({ ...row.dlcProduct, dlcDate: row.dlcProduct.expiryDate, // ✅ Mapping expiryDate vers dlcDate pour frontend supplier: row.supplier, group: row.group, creator: row.creator || { id: row.dlcProduct.createdBy, username: 'unknown' } })); } async getDlcProduct(id: number): Promise { const [result] = await db .select({ dlcProduct: dlcProducts, supplier: suppliers, group: groups }) .from(dlcProducts) .leftJoin(suppliers, eq(dlcProducts.supplierId, suppliers.id)) .leftJoin(groups, eq(dlcProducts.groupId, groups.id)) .where(eq(dlcProducts.id, id)); if (!result) return undefined; return { ...result.dlcProduct, dlcDate: result.dlcProduct.expiryDate, // ✅ Mapping expiryDate vers dlcDate pour frontend supplier: result.supplier, group: result.group, creator: result.creator || { id: result.dlcProduct.createdBy, username: 'unknown' } }; } async createDlcProduct(productData: InsertDlcProduct): Promise { const [dlcProduct] = await db.insert(dlcProducts).values(productData).returning(); return { ...dlcProduct, dlcDate: new Date(dlcProduct.expiryDate) } as DlcProductFrontend; } async updateDlcProduct(id: number, productData: Partial): Promise { const [dlcProduct] = await db .update(dlcProducts) .set({ ...productData, updatedAt: new Date() }) .where(eq(dlcProducts.id, id)) .returning(); return dlcProduct as DlcProductFrontend; } async deleteDlcProduct(id: number): Promise { await db.delete(dlcProducts).where(eq(dlcProducts.id, id)); } async validateDlcProduct(id: number, validatedBy: string): Promise { const [dlcProduct] = await db .update(dlcProducts) .set({ validatedBy, validatedAt: new Date(), updatedAt: new Date() }) .where(eq(dlcProducts.id, id)) .returning(); return dlcProduct as DlcProductFrontend; } async getDlcStats(groupIds?: number[]): Promise<{ active: number; expiringSoon: number; expired: number; }> { const today = new Date(); const alertDate = new Date(); alertDate.setDate(today.getDate() + 15); let whereCondition = sql`1 = 1`; if (groupIds && groupIds.length > 0) { whereCondition = inArray(dlcProducts.groupId, groupIds); } const [stats] = await db .select({ active: sql`COUNT(CASE WHEN ${dlcProducts.expiryDate} > ${today.toISOString().split('T')[0]} THEN 1 END)`, expiringSoon: sql`COUNT(CASE WHEN ${dlcProducts.expiryDate} BETWEEN ${today.toISOString().split('T')[0]} AND ${alertDate.toISOString().split('T')[0]} THEN 1 END)`, expired: sql`COUNT(CASE WHEN ${dlcProducts.expiryDate} <= ${today.toISOString().split('T')[0]} THEN 1 END)` }) .from(dlcProducts) .where(whereCondition); return { active: stats.active || 0, expiringSoon: stats.expiringSoon || 0, expired: stats.expired || 0 }; } async getTasks(groupIds?: number[]): Promise { let query = db .select({ task: tasks, group: groups }) .from(tasks) .leftJoin(groups, eq(tasks.groupId, groups.id)); if (groupIds && groupIds.length > 0) { query = query.where(inArray(tasks.groupId, groupIds)); } const results = await query.orderBy(desc(tasks.createdAt)); return results.map((row: any) => ({ ...row.task, group: row.group })); } async getTask(id: number): Promise { const [result] = await db .select({ task: tasks, group: groups }) .from(tasks) .leftJoin(groups, eq(tasks.groupId, groups.id)) .where(eq(tasks.id, id)); if (!result) return undefined; return { ...result.task, group: result.group }; } async createTask(taskData: InsertTask): Promise { const [task] = await db.insert(tasks).values(taskData).returning(); return task; } async updateTask(id: number, taskData: Partial): Promise { const [task] = await db .update(tasks) .set({ ...taskData, updatedAt: new Date() }) .where(eq(tasks.id, id)) .returning(); return task; } async deleteTask(id: number): Promise { await db.delete(tasks).where(eq(tasks.id, id)); } async completeTask(id: number, completedBy: string): Promise { await db .update(tasks) .set({ status: 'completed', completedAt: new Date(), completedBy, updatedAt: new Date() }) .where(eq(tasks.id, id)); } // SAV operations async getSavTickets(filters?: { groupIds?: number[]; status?: string; supplierId?: number; priority?: string; startDate?: string; endDate?: string; }): Promise { let query = db .select({ ticket: savTickets, supplier: suppliers, group: groups, creator: users, }) .from(savTickets) .leftJoin(suppliers, eq(savTickets.supplierId, suppliers.id)) .leftJoin(groups, eq(savTickets.groupId, groups.id)) .leftJoin(users, eq(savTickets.createdBy, users.id)); const conditions = []; if (filters?.groupIds?.length) { conditions.push(inArray(savTickets.groupId, filters.groupIds)); } if (filters?.status) { conditions.push(eq(savTickets.status, filters.status)); } if (filters?.supplierId) { conditions.push(eq(savTickets.supplierId, filters.supplierId)); } if (filters?.priority) { conditions.push(eq(savTickets.priority, filters.priority)); } if (filters?.startDate) { conditions.push(gte(savTickets.createdAt, new Date(filters.startDate))); } if (filters?.endDate) { conditions.push(lte(savTickets.createdAt, new Date(filters.endDate))); } if (conditions.length) { query = query.where(and(...conditions)); } const results = await query.orderBy(desc(savTickets.createdAt)); // Get history for each ticket const ticketsWithHistory = await Promise.all( results.map(async (result) => { const history = await this.getSavTicketHistory(result.ticket.id); return { ...result.ticket, supplier: result.supplier!, group: result.group!, creator: result.creator!, history, }; }) ); return ticketsWithHistory; } async getSavTicket(id: number): Promise { const [result] = await db .select({ ticket: savTickets, supplier: suppliers, group: groups, creator: users, }) .from(savTickets) .leftJoin(suppliers, eq(savTickets.supplierId, suppliers.id)) .leftJoin(groups, eq(savTickets.groupId, groups.id)) .leftJoin(users, eq(savTickets.createdBy, users.id)) .where(eq(savTickets.id, id)); if (!result) return undefined; const history = await this.getSavTicketHistory(id); return { ...result.ticket, supplier: result.supplier!, group: result.group!, creator: result.creator!, history, }; } async createSavTicket(ticketData: InsertSavTicket): Promise { // Generate ticket number const currentYear = new Date().getFullYear(); const count = await db .select({ count: sql`count(*)` }) .from(savTickets) .where(sql`EXTRACT(year from created_at) = ${currentYear}`); const ticketNumber = `SAV-${currentYear}-${String((count[0]?.count || 0) + 1).padStart(4, '0')}`; const [ticket] = await db .insert(savTickets) .values({ ...ticketData, ticketNumber }) .returning(); // Add initial history entry await this.addSavTicketHistory({ ticketId: ticket.id, action: 'created', description: `Ticket créé avec le statut "${ticket.status}"`, createdBy: ticket.createdBy, }); return ticket; } async updateSavTicket(id: number, ticketData: Partial): Promise { const [ticket] = await db .update(savTickets) .set({ ...ticketData, updatedAt: new Date() }) .where(eq(savTickets.id, id)) .returning(); return ticket; } async deleteSavTicket(id: number): Promise { // Delete history first await db.delete(savTicketHistory).where(eq(savTicketHistory.ticketId, id)); // Delete ticket await db.delete(savTickets).where(eq(savTickets.id, id)); } async getSavTicketHistory(ticketId: number): Promise { const results = await db .select({ history: savTicketHistory, creator: users, }) .from(savTicketHistory) .leftJoin(users, eq(savTicketHistory.createdBy, users.id)) .where(eq(savTicketHistory.ticketId, ticketId)) .orderBy(desc(savTicketHistory.createdAt)); return results.map(result => ({ ...result.history, creator: result.creator!, })); } async addSavTicketHistory(historyData: InsertSavTicketHistory): Promise { const [history] = await db .insert(savTicketHistory) .values(historyData) .returning(); return history; } async getSavTicketStats(groupIds?: number[]): Promise<{ totalTickets: number; newTickets: number; inProgressTickets: number; resolvedTickets: number; criticalTickets: number; }> { let query = db.select({ count: sql`count(*)`, status: savTickets.status, priority: savTickets.priority }) .from(savTickets); if (groupIds?.length) { query = query.where(inArray(savTickets.groupId, groupIds)); } const results = await query.groupBy(savTickets.status, savTickets.priority); const stats = { totalTickets: 0, newTickets: 0, inProgressTickets: 0, resolvedTickets: 0, criticalTickets: 0, }; results.forEach(result => { const count = result.count || 0; stats.totalTickets += count; if (result.status === 'nouveau') { stats.newTickets += count; } else if (['en_cours', 'attente_pieces', 'attente_echange'].includes(result.status)) { stats.inProgressTickets += count; } else if (['resolu', 'ferme'].includes(result.status)) { stats.resolvedTickets += count; } if (result.priority === 'critique') { stats.criticalTickets += count; } }); return stats; } // Weather operations async getWeatherSettings(): Promise { const [settings] = await db.select().from(weatherSettings).limit(1); return settings; } async createWeatherSettings(settingsData: InsertWeatherSettings): Promise { const [settings] = await db.insert(weatherSettings).values(settingsData).returning(); return settings; } async updateWeatherSettings(id: number, settingsData: Partial): Promise { const [settings] = await db .update(weatherSettings) .set({ ...settingsData, updatedAt: new Date() }) .where(eq(weatherSettings.id, id)) .returning(); return settings; } async getWeatherData(date: string, isCurrentYear: boolean): Promise { const [data] = await db .select() .from(weatherData) .where(and( eq(weatherData.date, date), eq(weatherData.isCurrentYear, isCurrentYear) )) .limit(1); return data; } async createWeatherData(data: InsertWeatherData): Promise { const [weatherInfo] = await db.insert(weatherData).values(data).returning(); return weatherInfo; } async updateWeatherData(id: number, data: Partial): Promise { const [weatherInfo] = await db .update(weatherData) .set({ ...data, updatedAt: new Date() }) .where(eq(weatherData.id, id)) .returning(); return weatherInfo; } async deleteOldWeatherData(daysToKeep: number): Promise { const cutoffDate = new Date(); cutoffDate.setDate(cutoffDate.getDate() - daysToKeep); await db .delete(weatherData) .where(lt(weatherData.createdAt, cutoffDate)); console.log(`🧹 Deleted weather data older than ${daysToKeep} days`); } } // MemStorage class for development export class MemStorage implements IStorage { private users = new Map(); private groups = new Map(); private suppliers = new Map(); private orders = new Map(); private deliveries = new Map(); private userGroups = new Map(); private publicities = new Map(); private publicityParticipations = new Map(); private customerOrders = new Map(); private dlcProducts = new Map(); private tasks = new Map(); private savTickets = new Map(); private savTicketHistories = new Map(); private idCounters = { group: 1, supplier: 1, order: 1, delivery: 1, publicity: 1, customerOrder: 1, dlcProduct: 1, task: 1, savTicket: 1, savTicketHistory: 1, }; constructor() { this.initializeTestData(); this.initializeExtraTestData(); } private initializeTestData() { // Create admin user const adminUser: User = { id: 'admin', username: 'admin', email: 'admin@example.com', name: 'Admin', firstName: 'Admin', lastName: 'User', profileImageUrl: null, password: 'admin', // In real app, this would be hashed role: 'admin', passwordChanged: false, createdAt: new Date(), updatedAt: new Date(), }; this.users.set(adminUser.id, adminUser); // Initialize group counter this.idCounters.group = 2; // Initialize supplier counter this.idCounters.supplier = 2; // Create test groups const testGroup: Group = { id: 1, name: 'Magasin Test', color: '#3B82F6', nocodbConfigId: 1, // Référence vers la config NocoDB de test nocodbTableName: 'invoices', nocodbTableId: 'mrr733dfb8wtt9b', // ID réel de la table NocoDB invoiceColumnName: 'invoice_reference', nocodbBlColumnName: 'bl_number', nocodbAmountColumnName: 'amount', nocodbSupplierColumnName: 'supplier', webhookUrl: 'https://webhook.test/invoice-upload', createdAt: new Date(), updatedAt: new Date(), }; this.groups.set(testGroup.id, testGroup); this.idCounters.group = 2; // Create test supplier const testSupplier: Supplier = { id: 1, name: 'Fournisseur Test', contact: 'test@supplier.com', phone: '0123456789', hasDlc: false, automaticReconciliation: false, createdAt: new Date(), updatedAt: new Date(), }; this.suppliers.set(testSupplier.id, testSupplier); this.idCounters.supplier = 2; console.log('✅ MemStorage initialized with admin user (admin/admin)'); } // User operations async getUser(id: string): Promise { return this.users.get(id); } async getUserByEmail(email: string): Promise { for (const user of this.users.values()) { if (user.email === email) return user; } return undefined; } async getUserByUsername(username: string): Promise { for (const user of this.users.values()) { if (user.username === username) return user; } return undefined; } async upsertUser(userData: UpsertUser): Promise { const existingUser = this.users.get(userData.id); const user: User = { id: userData.id, username: userData.username, email: userData.email || null, name: userData.name || null, firstName: userData.firstName || null, lastName: userData.lastName || null, profileImageUrl: userData.profileImageUrl || null, password: userData.password || null, role: userData.role || 'user', passwordChanged: userData.passwordChanged || false, createdAt: existingUser?.createdAt || new Date(), updatedAt: new Date(), }; this.users.set(user.id, user); return user; } async getUserWithGroups(id: string): Promise { const user = await this.getUser(id); if (!user) return undefined; const userGroupsList = this.userGroups.get(id) || []; const userGroupsWithGroups = userGroupsList.map(ug => ({ ...ug, group: this.groups.get(ug.groupId)!, })); return { ...user, userGroups: userGroupsWithGroups }; } async getUsers(): Promise { return Array.from(this.users.values()); } async createUser(userData: UpsertUser): Promise { return this.upsertUser(userData); } async updateUser(id: string, userData: Partial): Promise { const existingUser = this.users.get(id); if (!existingUser) throw new Error('User not found'); const updatedUser = { ...existingUser, ...userData, updatedAt: new Date() }; this.users.set(id, updatedUser); return updatedUser; } async deleteUser(id: string): Promise { this.users.delete(id); this.userGroups.delete(id); } // Group operations async getGroups(): Promise { return Array.from(this.groups.values()); } async getGroup(id: number): Promise { return this.groups.get(id); } async createGroup(groupData: InsertGroup): Promise { const id = this.idCounters.group++; const group: Group = { id, name: groupData.name, color: groupData.color || null, nocodbConfigId: groupData.nocodbConfigId || null, nocodbTableName: groupData.nocodbTableName || null, nocodbTableId: groupData.nocodbTableId || null, invoiceColumnName: groupData.invoiceColumnName || null, nocodbBlColumnName: groupData.nocodbBlColumnName || null, nocodbAmountColumnName: groupData.nocodbAmountColumnName || null, nocodbSupplierColumnName: groupData.nocodbSupplierColumnName || null, webhookUrl: groupData.webhookUrl || null, createdAt: new Date(), updatedAt: new Date(), }; this.groups.set(id, group); return group; } async updateGroup(id: number, groupData: Partial): Promise { const existingGroup = this.groups.get(id); if (!existingGroup) throw new Error('Group not found'); const updatedGroup = { ...existingGroup, ...groupData, updatedAt: new Date() }; this.groups.set(id, updatedGroup); return updatedGroup; } async deleteGroup(id: number): Promise { this.groups.delete(id); } // Supplier operations async getSuppliers(): Promise { return Array.from(this.suppliers.values()); } async createSupplier(supplierData: InsertSupplier): Promise { const id = this.idCounters.supplier++; const supplier: Supplier = { id, name: supplierData.name, contact: supplierData.contact || null, phone: supplierData.phone || null, hasDlc: supplierData.hasDlc || null, automaticReconciliation: supplierData.automaticReconciliation || null, createdAt: new Date(), updatedAt: new Date(), }; this.suppliers.set(id, supplier); return supplier; } async updateSupplier(id: number, supplierData: Partial): Promise { const existingSupplier = this.suppliers.get(id); if (!existingSupplier) throw new Error('Supplier not found'); const updatedSupplier = { ...existingSupplier, ...supplierData, updatedAt: new Date() }; this.suppliers.set(id, updatedSupplier); return updatedSupplier; } async deleteSupplier(id: number): Promise { this.suppliers.delete(id); } // NocoDB Configuration methods async getNocodbConfigs(): Promise { return []; // Empty array for development } async getNocodbConfig(id: number): Promise { return undefined; // Not found in development } async getActiveNocodbConfig(): Promise { // Configuration corrigée pour votre serveur NocoDB const testConfig: NocodbConfig = { id: 1, name: 'Configuration Production NocoDB FFNancy', baseUrl: 'https://nocodb.ffnancy.fr', // URL corrigée projectId: 'pcg4uw79ukvycxc', // Project ID de vos logs apiToken: 'xc-token-production-invoice-system', description: 'Configuration de production pour vérification des factures FFNancy', isActive: true, createdBy: 'admin', createdAt: new Date(), updatedAt: new Date(), }; console.log('🔧 Configuration NocoDB active:', { name: testConfig.name, baseUrl: testConfig.baseUrl, projectId: testConfig.projectId, hasToken: !!testConfig.apiToken }); return testConfig; } async createNocodbConfig(config: InsertNocodbConfig): Promise { const newConfig: NocodbConfig = { id: 1, name: config.name, baseUrl: config.baseUrl, projectId: config.projectId, apiToken: config.apiToken, description: config.description || null, isActive: config.isActive ?? true, createdBy: config.createdBy || null, createdAt: new Date(), updatedAt: new Date(), }; return newConfig; } async updateNocodbConfig(id: number, config: Partial): Promise { const updatedConfig: NocodbConfig = { id, name: config.name || 'Test Config', baseUrl: config.baseUrl || 'https://nocodb.example.com', projectId: config.projectId || 'test-project', apiToken: config.apiToken || 'test-token', description: config.description || null, isActive: config.isActive ?? true, createdBy: config.createdBy || null, createdAt: new Date(), updatedAt: new Date(), }; return updatedConfig; } async deleteNocodbConfig(id: number): Promise { // No-op in development } async getInvoiceVerificationCache(cacheKey: string): Promise { return undefined; // Pas de cache en développement } async createInvoiceVerificationCache(cache: InsertInvoiceVerificationCache): Promise { const newCache: InvoiceVerificationCache = { id: 1, cacheKey: cache.cacheKey, groupId: cache.groupId, invoiceReference: cache.invoiceReference, supplierName: cache.supplierName || null, exists: cache.exists, matchType: cache.matchType, errorMessage: cache.errorMessage || null, cacheHit: cache.cacheHit || false, apiCallTime: cache.apiCallTime || null, expiresAt: cache.expiresAt, createdAt: new Date(), updatedAt: new Date(), }; return newCache; } async saveInvoiceVerificationCache(cache: InsertInvoiceVerificationCache): Promise { return this.createInvoiceVerificationCache(cache); } async clearExpiredCache(): Promise { // No-op en développement } // MemStorage implementations with actual data handling async getOrders(groupIds?: number[]): Promise { let orders = Array.from(this.orders.values()); if (groupIds && groupIds.length > 0) { orders = orders.filter(order => groupIds.includes(order.groupId)); } return orders.map(order => { // Récupérer les livraisons associées à cette commande (DEV RELATIONS) const associatedDeliveries = Array.from(this.deliveries.values()) .filter(delivery => delivery.orderId === order.id) .map(delivery => ({ ...delivery, supplier: this.suppliers.get(delivery.supplierId), group: this.groups.get(delivery.groupId), creator: this.users.get(delivery.createdBy || '') })); return { ...order, supplier: this.suppliers.get(order.supplierId), group: this.groups.get(order.groupId), creator: this.users.get(order.createdBy), deliveries: associatedDeliveries }; }); } async getOrdersByDateRange(startDate: string, endDate: string, groupIds?: number[]): Promise { const start = new Date(startDate); const end = new Date(endDate); let orders = Array.from(this.orders.values()).filter(order => { const orderDate = new Date(order.plannedDate); return orderDate >= start && orderDate <= end; }); if (groupIds && groupIds.length > 0) { orders = orders.filter(order => groupIds.includes(order.groupId)); } return orders.map(order => { // Récupérer les livraisons associées à cette commande (DEV RELATIONS) const associatedDeliveries = Array.from(this.deliveries.values()) .filter(delivery => delivery.orderId === order.id) .map(delivery => ({ ...delivery, supplier: this.suppliers.get(delivery.supplierId), group: this.groups.get(delivery.groupId), creator: this.users.get(delivery.createdBy || '') })); return { ...order, supplier: this.suppliers.get(order.supplierId), group: this.groups.get(order.groupId), creator: this.users.get(order.createdBy), deliveries: associatedDeliveries }; }); } async getOrder(id: number): Promise { const order = this.orders.get(id); if (!order) return undefined; // Récupérer les livraisons associées à cette commande const associatedDeliveries = Array.from(this.deliveries.values()) .filter(delivery => delivery.orderId === id) .map(delivery => ({ ...delivery, supplier: this.suppliers.get(delivery.supplierId), group: this.groups.get(delivery.groupId), creator: this.users.get(delivery.createdBy || '') })); return { ...order, supplier: this.suppliers.get(order.supplierId), group: this.groups.get(order.groupId), creator: this.users.get(order.createdBy), deliveries: associatedDeliveries }; } async createOrder(orderData: InsertOrder): Promise { const id = this.idCounters.order++; const order: Order = { id, ...orderData, createdAt: new Date(), updatedAt: new Date(), }; this.orders.set(id, order); return order; } async updateOrder(id: number, orderData: Partial): Promise { const existingOrder = this.orders.get(id); if (!existingOrder) throw new Error('Order not found'); const updatedOrder = { ...existingOrder, ...orderData, updatedAt: new Date(), }; this.orders.set(id, updatedOrder); return updatedOrder; } async deleteOrder(id: number): Promise { this.orders.delete(id); } async getDeliveries(groupIds?: number[]): Promise { let deliveries = Array.from(this.deliveries.values()); if (groupIds && groupIds.length > 0) { deliveries = deliveries.filter(delivery => groupIds.includes(delivery.groupId)); } return deliveries.map(delivery => { // Récupérer la commande associée à cette livraison si elle existe (DEV RELATIONS) let associatedOrder = undefined; if (delivery.orderId) { const order = this.orders.get(delivery.orderId); if (order) { associatedOrder = { ...order, supplier: this.suppliers.get(order.supplierId), group: this.groups.get(order.groupId), creator: this.users.get(order.createdBy) }; } } return { ...delivery, supplier: this.suppliers.get(delivery.supplierId), group: this.groups.get(delivery.groupId), creator: this.users.get(delivery.createdBy || ''), order: associatedOrder }; }); } async getDeliveriesByDateRange(startDate: string, endDate: string, groupIds?: number[]): Promise { const start = new Date(startDate); const end = new Date(endDate); let deliveries = Array.from(this.deliveries.values()).filter(delivery => { const deliveryDate = new Date(delivery.scheduledDate); return deliveryDate >= start && deliveryDate <= end; }); if (groupIds && groupIds.length > 0) { deliveries = deliveries.filter(delivery => groupIds.includes(delivery.groupId)); } return deliveries.map(delivery => { // Récupérer la commande associée à cette livraison si elle existe (DEV RELATIONS) let associatedOrder = undefined; if (delivery.orderId) { const order = this.orders.get(delivery.orderId); if (order) { associatedOrder = { ...order, supplier: this.suppliers.get(order.supplierId), group: this.groups.get(order.groupId), creator: this.users.get(order.createdBy) }; } } return { ...delivery, supplier: this.suppliers.get(delivery.supplierId), group: this.groups.get(delivery.groupId), creator: this.users.get(delivery.createdBy || ''), order: associatedOrder }; }); } async getDelivery(id: number): Promise { const delivery = this.deliveries.get(id); if (!delivery) return undefined; // Récupérer la commande associée si elle existe let associatedOrder = undefined; if (delivery.orderId) { const order = this.orders.get(delivery.orderId); if (order) { associatedOrder = { ...order, supplier: this.suppliers.get(order.supplierId), group: this.groups.get(order.groupId), creator: this.users.get(order.createdBy) }; } } return { ...delivery, supplier: this.suppliers.get(delivery.supplierId), group: this.groups.get(delivery.groupId), creator: this.users.get(delivery.createdBy || ''), order: associatedOrder }; } async createDelivery(deliveryData: InsertDelivery): Promise { const id = this.idCounters.delivery++; const delivery: Delivery = { id, ...deliveryData, status: 'planned', // Livraisons créées sont automatiquement planifiées createdAt: new Date(), updatedAt: new Date(), }; this.deliveries.set(id, delivery); // Si une commande est liée, la marquer comme "planned" (pas delivered!) if (deliveryData.orderId) { try { const order = this.orders.get(deliveryData.orderId); if (order && order.status === 'pending') { console.log(`🔗 Delivery #${id} linked to order #${deliveryData.orderId}, updating order status to 'planned'`); await this.updateOrder(deliveryData.orderId, { status: 'planned' }); } } catch (error) { console.error(`❌ Failed to update order #${deliveryData.orderId} status to planned:`, error); } } return delivery; } async updateDelivery(id: number, deliveryData: Partial): Promise { const existingDelivery = this.deliveries.get(id); if (!existingDelivery) throw new Error('Delivery not found'); const updatedDelivery = { ...existingDelivery, ...deliveryData, updatedAt: new Date(), }; this.deliveries.set(id, updatedDelivery); return updatedDelivery; } async deleteDelivery(id: number): Promise { this.deliveries.delete(id); } async validateDelivery(id: number, blData?: { blNumber: string; blAmount: number }): Promise { const delivery = this.deliveries.get(id); if (!delivery) throw new Error('Delivery not found'); const updatedDelivery = { ...delivery, status: 'delivered' as const, deliveredDate: new Date(), blNumber: blData?.blNumber || delivery.blNumber, blAmount: blData?.blAmount || delivery.blAmount, updatedAt: new Date(), }; this.deliveries.set(id, updatedDelivery); } async getUserGroups(): Promise { return []; } async assignUserToGroup(): Promise { return {} as UserGroup; } async removeUserFromGroup(): Promise {} async getMonthlyStats(): Promise { return {}; } async getPublicities(): Promise { return []; } async getPublicity(): Promise { return undefined; } async createPublicity(): Promise { return {} as Publicity; } async updatePublicity(): Promise { return {} as Publicity; } async deletePublicity(): Promise {} async getPublicityParticipations(): Promise { return []; } async setPublicityParticipations(): Promise {} async getCustomerOrders(groupIds?: number[]): Promise { let orders = Array.from(this.customerOrders.values()); if (groupIds && groupIds.length > 0) { orders = orders.filter(order => groupIds.includes(order.groupId)); } return orders.map(order => ({ ...order, supplier: this.suppliers.get(order.supplierId)!, group: this.groups.get(order.groupId)!, creator: this.users.get(order.createdBy)! })); } async getCustomerOrder(id: number): Promise { const order = this.customerOrders.get(id); if (!order) return undefined; return { ...order, supplier: this.suppliers.get(order.supplierId)!, group: this.groups.get(order.groupId)!, creator: this.users.get(order.createdBy)! }; } async createCustomerOrder(orderData: InsertCustomerOrder): Promise { const id = this.idCounters.customerOrder++; const order: CustomerOrder = { id, ...orderData, notes: orderData.notes || null, status: orderData.status || 'En attente de Commande', quantity: orderData.quantity || 1, deposit: orderData.deposit || "0.00" as any, isPromotionalPrice: orderData.isPromotionalPrice || false, customerNotified: orderData.customerNotified || false, createdAt: new Date(), updatedAt: new Date(), }; this.customerOrders.set(id, order); return order; } async updateCustomerOrder(id: number, orderData: Partial): Promise { const existingOrder = this.customerOrders.get(id); if (!existingOrder) throw new Error('Customer order not found'); const updatedOrder = { ...existingOrder, ...orderData, updatedAt: new Date() }; this.customerOrders.set(id, updatedOrder); return updatedOrder; } async deleteCustomerOrder(id: number): Promise { this.customerOrders.delete(id); } async getDlcProducts(groupIds?: number[], filters?: { status?: string; supplierId?: number; search?: string; }): Promise { let products = Array.from(this.dlcProducts.values()); if (groupIds && groupIds.length > 0) { products = products.filter(product => groupIds.includes(product.groupId)); } if (filters) { if (filters.status) { products = products.filter(product => product.status === filters.status); } if (filters.supplierId) { products = products.filter(product => product.supplierId === filters.supplierId); } if (filters.search) { const searchTerm = filters.search.toLowerCase(); products = products.filter(product => { const supplier = this.suppliers.get(product.supplierId); return product.productName.toLowerCase().includes(searchTerm) || (supplier && supplier.name.toLowerCase().includes(searchTerm)); }); } } return products.map(product => ({ ...product, supplier: this.suppliers.get(product.supplierId)!, group: this.groups.get(product.groupId)!, creator: this.users.get(product.createdBy)! })); } async getDlcProduct(id: number): Promise { const product = this.dlcProducts.get(id); if (!product) return undefined; return { ...product, supplier: this.suppliers.get(product.supplierId)!, group: this.groups.get(product.groupId)!, creator: this.users.get(product.createdBy)! }; } async createDlcProduct(productData: InsertDlcProduct): Promise { const id = this.idCounters.dlcProduct++; const product: DlcProduct = { id, ...productData, notes: productData.notes || null, status: productData.status || 'en_cours', quantity: productData.quantity || 1, unit: productData.unit || 'unité', location: productData.location || 'Magasin', alertThreshold: productData.alertThreshold || 15, createdAt: new Date(), updatedAt: new Date(), }; this.dlcProducts.set(id, product); return { ...product, dlcDate: new Date(product.expiryDate) } as DlcProductFrontend; } async updateDlcProduct(id: number, productData: Partial): Promise { const existingProduct = this.dlcProducts.get(id); if (!existingProduct) throw new Error('DLC Product not found'); const updatedProduct = { ...existingProduct, ...productData, updatedAt: new Date() }; this.dlcProducts.set(id, updatedProduct); return { ...updatedProduct, dlcDate: new Date(updatedProduct.expiryDate) } as DlcProductFrontend; } async deleteDlcProduct(id: number): Promise { this.dlcProducts.delete(id); } async validateDlcProduct(id: number, validatedBy: string): Promise { const existingProduct = this.dlcProducts.get(id); if (!existingProduct) throw new Error('DLC Product not found'); const updatedProduct = { ...existingProduct, validatedBy, validatedAt: new Date(), updatedAt: new Date() }; this.dlcProducts.set(id, updatedProduct); return { ...updatedProduct, dlcDate: new Date(updatedProduct.expiryDate) } as DlcProductFrontend; } async getDlcStats(groupIds?: number[]): Promise<{ active: number; expiringSoon: number; expired: number; }> { const today = new Date(); const alertDate = new Date(); alertDate.setDate(today.getDate() + 15); let products = Array.from(this.dlcProducts.values()); if (groupIds && groupIds.length > 0) { products = products.filter(product => groupIds.includes(product.groupId)); } return { active: products.filter(p => new Date(p.expiryDate) > today).length, expiringSoon: products.filter(p => { const expiry = new Date(p.expiryDate); return expiry >= today && expiry <= alertDate; }).length, expired: products.filter(p => new Date(p.expiryDate) <= today).length }; } async getTasks(groupIds?: number[]): Promise { let tasks = Array.from(this.tasks.values()); if (groupIds && groupIds.length > 0) { tasks = tasks.filter(task => groupIds.includes(task.groupId)); } return tasks.map(task => ({ ...task, group: this.groups.get(task.groupId)!, creator: this.users.get(task.createdBy)! })); } async getTask(id: number): Promise { const task = this.tasks.get(id); if (!task) return undefined; return { ...task, group: this.groups.get(task.groupId)!, creator: this.users.get(task.createdBy)! }; } async createTask(taskData: InsertTask): Promise { const id = this.idCounters.task++; const task: Task = { id, ...taskData, description: taskData.description || null, status: taskData.status || 'pending', priority: taskData.priority || 'medium', completedAt: null, completedBy: null, createdAt: new Date(), updatedAt: new Date(), }; this.tasks.set(id, task); return task; } private initializeExtraTestData() { // Add test customer orders const testOrder1: CustomerOrder = { id: 1, supplierId: 1, groupId: 1, createdBy: 'admin', orderTaker: 'Admin', customerName: 'Marie Dupont', customerPhone: '0123456789', customerEmail: null, productDesignation: 'Table de jardin', productReference: null, gencode: null, quantity: 2, deposit: '150.00' as any, status: 'En attente de Commande', isPromotionalPrice: false, customerNotified: false, notes: 'Livraison urgente demandée', createdAt: new Date('2025-01-15'), updatedAt: new Date('2025-01-15'), }; const testOrder2: CustomerOrder = { id: 2, supplierId: 1, groupId: 1, createdBy: 'admin', orderTaker: 'Admin', customerName: 'Pierre Martin', customerPhone: '0987654321', customerEmail: null, productDesignation: 'Chaises pliantes x4', productReference: null, gencode: null, quantity: 1, deposit: '80.00' as any, status: 'Commande passée', isPromotionalPrice: true, customerNotified: true, notes: null, createdAt: new Date('2025-01-10'), updatedAt: new Date('2025-01-12'), }; this.customerOrders.set(1, testOrder1); this.customerOrders.set(2, testOrder2); this.idCounters.customerOrder = 3; // Add test DLC products const testDlc1: DlcProduct = { id: 1, supplierId: 1, groupId: 1, createdBy: 'admin', productName: 'Yaourts bio', gencode: 'YAO001', dateType: 'DLC', expiryDate: '2025-08-20', status: 'en_cours', quantity: 24, unit: 'pièces', notes: 'À vendre rapidement' as string | null, location: 'Frigo principal', alertThreshold: 5, validatedBy: null as string | null, validatedAt: null, createdAt: new Date('2025-08-10'), updatedAt: new Date('2025-08-10'), }; const testDlc2: DlcProduct = { id: 2, supplierId: 1, groupId: 1, createdBy: 'admin', productName: 'Pain de mie complet', gencode: 'PAIN002', dateType: 'DLC', expiryDate: '2025-08-16', status: 'alerte', quantity: 8, unit: 'unités', notes: 'DLC proche, promotion conseillée' as string | null, location: 'Rayonnage A3', alertThreshold: 3, validatedBy: null as string | null, validatedAt: null, createdAt: new Date('2025-08-08'), updatedAt: new Date('2025-08-13'), }; this.dlcProducts.set(1, testDlc1); this.dlcProducts.set(2, testDlc2); this.idCounters.dlcProduct = 3; // Add test tasks const testTask1: Task = { id: 1, groupId: 1, createdBy: 'admin', title: 'Vérifier stock yaourts', description: 'Contrôler les DLC des yaourts et organiser la rotation', status: 'pending', priority: 'high', assignedTo: 'admin', dueDate: new Date('2025-08-15'), completedAt: null, completedBy: null, createdAt: new Date('2025-08-13'), updatedAt: new Date('2025-08-13'), }; const testTask2: Task = { id: 2, groupId: 1, createdBy: 'admin', title: 'Contacter fournisseur', description: 'Appeler le fournisseur pour confirmer la livraison de demain', status: 'in_progress', priority: 'medium', assignedTo: 'admin', dueDate: new Date('2025-08-14'), completedAt: null, completedBy: null, createdAt: new Date('2025-08-12'), updatedAt: new Date('2025-08-13'), }; this.tasks.set(1, testTask1); this.tasks.set(2, testTask2); this.idCounters.task = 3; // Initialize test SAV data this.initializeSavTestData(); } async updateTask(id: number, taskData: Partial): Promise { const existingTask = this.tasks.get(id); if (!existingTask) throw new Error('Task not found'); const updatedTask = { ...existingTask, ...taskData, updatedAt: new Date() }; this.tasks.set(id, updatedTask); return updatedTask; } async deleteTask(id: number): Promise { this.tasks.delete(id); } async completeTask(id: number, completedBy: string): Promise { const existingTask = this.tasks.get(id); if (!existingTask) throw new Error('Task not found'); const updatedTask = { ...existingTask, status: 'completed' as const, completedAt: new Date(), completedBy, updatedAt: new Date() }; this.tasks.set(id, updatedTask); } // SAV operations async getSavTickets(filters?: { groupIds?: number[]; status?: string; supplierId?: number; priority?: string; startDate?: string; endDate?: string; }): Promise { const tickets = Array.from(this.savTickets.values()); let filteredTickets = tickets; if (filters?.groupIds?.length) { filteredTickets = filteredTickets.filter(ticket => filters.groupIds!.includes(ticket.groupId)); } if (filters?.status) { filteredTickets = filteredTickets.filter(ticket => ticket.status === filters.status); } if (filters?.supplierId) { filteredTickets = filteredTickets.filter(ticket => ticket.supplierId === filters.supplierId); } if (filters?.priority) { filteredTickets = filteredTickets.filter(ticket => ticket.priority === filters.priority); } if (filters?.startDate) { const startDate = new Date(filters.startDate); filteredTickets = filteredTickets.filter(ticket => ticket.createdAt && ticket.createdAt >= startDate ); } if (filters?.endDate) { const endDate = new Date(filters.endDate); filteredTickets = filteredTickets.filter(ticket => ticket.createdAt && ticket.createdAt <= endDate ); } // Sort by creation date (newest first) filteredTickets.sort((a, b) => { const dateA = a.createdAt || new Date(0); const dateB = b.createdAt || new Date(0); return dateB.getTime() - dateA.getTime(); }); // Add relations for each ticket const ticketsWithRelations = await Promise.all( filteredTickets.map(async (ticket) => { const supplier = this.suppliers.get(ticket.supplierId); const group = this.groups.get(ticket.groupId); const creator = this.users.get(ticket.createdBy); const history = await this.getSavTicketHistory(ticket.id); return { ...ticket, supplier: supplier!, group: group!, creator: creator!, history, }; }) ); return ticketsWithRelations; } async getSavTicket(id: number): Promise { const ticket = this.savTickets.get(id); if (!ticket) return undefined; const supplier = this.suppliers.get(ticket.supplierId); const group = this.groups.get(ticket.groupId); const creator = this.users.get(ticket.createdBy); const history = await this.getSavTicketHistory(id); return { ...ticket, supplier: supplier!, group: group!, creator: creator!, history, }; } async createSavTicket(ticketData: InsertSavTicket): Promise { const id = this.idCounters.savTicket++; // Generate ticket number const currentYear = new Date().getFullYear(); const ticketNumber = `SAV-${currentYear}-${String(id).padStart(4, '0')}`; const ticket: SavTicket = { id, ticketNumber, ...ticketData, createdAt: new Date(), updatedAt: new Date(), resolvedAt: null, closedAt: null, }; this.savTickets.set(id, ticket); // Add initial history entry await this.addSavTicketHistory({ ticketId: id, action: 'created', description: `Ticket créé avec le statut "${ticket.status}"`, createdBy: ticket.createdBy, }); return ticket; } async updateSavTicket(id: number, ticketData: Partial): Promise { const existingTicket = this.savTickets.get(id); if (!existingTicket) throw new Error('SAV ticket not found'); const updatedTicket = { ...existingTicket, ...ticketData, updatedAt: new Date() }; // Set resolved/closed dates based on status if (ticketData.status === 'resolu' && !updatedTicket.resolvedAt) { updatedTicket.resolvedAt = new Date(); } if (ticketData.status === 'ferme' && !updatedTicket.closedAt) { updatedTicket.closedAt = new Date(); } this.savTickets.set(id, updatedTicket); return updatedTicket; } async deleteSavTicket(id: number): Promise { // Delete history first this.savTicketHistories.delete(id); // Delete ticket this.savTickets.delete(id); } async getSavTicketHistory(ticketId: number): Promise { const histories = this.savTicketHistories.get(ticketId) || []; const historiesWithCreators = histories.map(history => { const creator = this.users.get(history.createdBy); return { ...history, creator: creator!, }; }); // Sort by creation date (newest first) return historiesWithCreators.sort((a, b) => { const dateA = a.createdAt || new Date(0); const dateB = b.createdAt || new Date(0); return dateB.getTime() - dateA.getTime(); }); } async addSavTicketHistory(historyData: InsertSavTicketHistory): Promise { const id = this.idCounters.savTicketHistory++; const history: SavTicketHistory = { id, ...historyData, createdAt: new Date(), }; const existingHistories = this.savTicketHistories.get(historyData.ticketId) || []; existingHistories.push(history); this.savTicketHistories.set(historyData.ticketId, existingHistories); return history; } async getSavTicketStats(groupIds?: number[]): Promise<{ totalTickets: number; newTickets: number; inProgressTickets: number; resolvedTickets: number; criticalTickets: number; }> { let tickets = Array.from(this.savTickets.values()); if (groupIds?.length) { tickets = tickets.filter(ticket => groupIds.includes(ticket.groupId)); } const stats = { totalTickets: tickets.length, newTickets: tickets.filter(t => t.status === 'nouveau').length, inProgressTickets: tickets.filter(t => ['en_cours', 'attente_pieces', 'attente_echange'].includes(t.status) ).length, resolvedTickets: tickets.filter(t => ['resolu', 'ferme'].includes(t.status) ).length, criticalTickets: tickets.filter(t => t.priority === 'critique').length, }; return stats; } private initializeSavTestData() { // Test SAV tickets const testTicket1: SavTicket = { id: 1, ticketNumber: 'SAV-2025-0001', groupId: 1, supplierId: 1, clientName: 'Jean Dupont', clientPhone: '03 83 12 34 56', problemDescription: 'Produit défaillant après 2 jours d\'utilisation. Écran cassé et boutons non fonctionnels.', productGencode: '12345678901234', productReference: 'REF-ABC-123', productDesignation: 'Tablette Samsung Galaxy Tab A7', status: 'nouveau', priority: 'haute', createdBy: 'admin', createdAt: new Date('2025-08-10T08:30:00'), updatedAt: new Date('2025-08-10T08:30:00'), resolvedAt: null, closedAt: null, }; const testTicket2: SavTicket = { id: 2, ticketNumber: 'SAV-2025-0002', groupId: 1, supplierId: 2, clientName: 'Marie Martin', clientPhone: '06 12 34 56 78', problemDescription: 'Pièces manquantes dans le colis. Manque le chargeur et les écouteurs.', productGencode: '23456789012345', productReference: 'REF-XYZ-456', productDesignation: 'Smartphone iPhone 14', status: 'en_cours', priority: 'normale', createdBy: 'admin', createdAt: new Date('2025-08-09T14:15:00'), updatedAt: new Date('2025-08-12T10:20:00'), resolvedAt: null, closedAt: null, }; const testTicket3: SavTicket = { id: 3, ticketNumber: 'SAV-2025-0003', groupId: 1, supplierId: 1, clientName: 'Pierre Durand', clientPhone: '03 83 98 76 54', problemDescription: 'En attente de la pièce de rechange. Écran de remplacement commandé chez le fournisseur.', productGencode: '34567890123456', productReference: 'REF-DEF-789', productDesignation: 'Ordinateur portable Dell Inspiron', status: 'attente_pieces', priority: 'normale', createdBy: 'admin', createdAt: new Date('2025-08-08T09:45:00'), updatedAt: new Date('2025-08-13T16:30:00'), resolvedAt: null, closedAt: null, }; const testTicket4: SavTicket = { id: 4, ticketNumber: 'SAV-2025-0004', groupId: 1, supplierId: 3, clientName: 'Sophie Moreau', clientPhone: '06 98 76 54 32', problemDescription: 'Problème résolu. Produit réparé et testé. Prêt pour le retour client.', productGencode: '45678901234567', productReference: 'REF-GHI-012', productDesignation: 'Casque Sony WH-1000XM4', status: 'resolu', priority: 'faible', createdBy: 'admin', createdAt: new Date('2025-08-05T11:20:00'), updatedAt: new Date('2025-08-14T08:00:00'), resolvedAt: new Date('2025-08-14T08:00:00'), closedAt: null, }; const testTicket5: SavTicket = { id: 5, ticketNumber: 'SAV-2025-0005', groupId: 1, supplierId: 2, clientName: 'Luc Bernard', clientPhone: '03 83 45 67 89', problemDescription: 'URGENT - Produit en panne critique pour activité professionnelle. Besoin intervention rapide.', productGencode: '56789012345678', productReference: 'REF-JKL-345', productDesignation: 'Imprimante HP LaserJet Pro', status: 'en_cours', priority: 'critique', createdBy: 'admin', createdAt: new Date('2025-08-14T07:30:00'), updatedAt: new Date('2025-08-14T07:30:00'), resolvedAt: null, closedAt: null, }; // Store the tickets this.savTickets.set(1, testTicket1); this.savTickets.set(2, testTicket2); this.savTickets.set(3, testTicket3); this.savTickets.set(4, testTicket4); this.savTickets.set(5, testTicket5); // Add history entries for each ticket const histories = [ // Ticket 1 history { ticketId: 1, action: 'created', description: 'Ticket créé avec le statut "nouveau"', createdBy: 'admin', createdAt: new Date('2025-08-10T08:30:00') }, // Ticket 2 history { ticketId: 2, action: 'created', description: 'Ticket créé avec le statut "nouveau"', createdBy: 'admin', createdAt: new Date('2025-08-09T14:15:00') }, { ticketId: 2, action: 'status_change', description: 'Statut changé de "nouveau" vers "en_cours"', createdBy: 'admin', createdAt: new Date('2025-08-12T10:20:00') }, { ticketId: 2, action: 'comment', description: 'Contact avec le client pour confirmer les pièces manquantes. Commande des accessoires en cours.', createdBy: 'admin', createdAt: new Date('2025-08-12T10:25:00') }, // Ticket 3 history { ticketId: 3, action: 'created', description: 'Ticket créé avec le statut "nouveau"', createdBy: 'admin', createdAt: new Date('2025-08-08T09:45:00') }, { ticketId: 3, action: 'status_change', description: 'Statut changé de "nouveau" vers "en_cours"', createdBy: 'admin', createdAt: new Date('2025-08-10T14:00:00') }, { ticketId: 3, action: 'status_change', description: 'Statut changé de "en_cours" vers "attente_pieces"', createdBy: 'admin', createdAt: new Date('2025-08-13T16:30:00') }, { ticketId: 3, action: 'comment', description: 'Écran de remplacement commandé. Délai annoncé de 5-7 jours ouvrables.', createdBy: 'admin', createdAt: new Date('2025-08-13T16:35:00') }, // Ticket 4 history { ticketId: 4, action: 'created', description: 'Ticket créé avec le statut "nouveau"', createdBy: 'admin', createdAt: new Date('2025-08-05T11:20:00') }, { ticketId: 4, action: 'status_change', description: 'Statut changé de "nouveau" vers "en_cours"', createdBy: 'admin', createdAt: new Date('2025-08-06T09:00:00') }, { ticketId: 4, action: 'comment', description: 'Diagnostic effectué : problème de connectivité Bluetooth. Réparation en cours.', createdBy: 'admin', createdAt: new Date('2025-08-07T15:30:00') }, { ticketId: 4, action: 'status_change', description: 'Statut changé de "en_cours" vers "resolu"', createdBy: 'admin', createdAt: new Date('2025-08-14T08:00:00') }, { ticketId: 4, action: 'comment', description: 'Casque réparé avec succès. Module Bluetooth remplacé. Tests complets effectués.', createdBy: 'admin', createdAt: new Date('2025-08-14T08:05:00') }, // Ticket 5 history { ticketId: 5, action: 'created', description: 'Ticket créé avec le statut "nouveau"', createdBy: 'admin', createdAt: new Date('2025-08-14T07:30:00') }, { ticketId: 5, action: 'status_change', description: 'Statut changé de "nouveau" vers "en_cours"', createdBy: 'admin', createdAt: new Date('2025-08-14T07:30:00') }, { ticketId: 5, action: 'comment', description: 'Priorité critique - Intervention d\'urgence programmée pour ce matin.', createdBy: 'admin', createdAt: new Date('2025-08-14T07:35:00') }, ]; // Initialize history for each ticket histories.forEach((historyEntry) => { const id = this.idCounters.savTicketHistory++; const history: SavTicketHistory = { id, ...historyEntry, }; const existingHistories = this.savTicketHistories.get(historyEntry.ticketId) || []; existingHistories.push(history); this.savTicketHistories.set(historyEntry.ticketId, existingHistories); }); this.idCounters.savTicket = 6; console.log('✅ SAV test data initialized with 5 tickets and comprehensive history'); } // Weather operations async getWeatherSettings(): Promise { // In memory storage, return a default setting for development return { id: 1, apiKey: "6PSHYLBJB9EEYNZ7NDQ5BPGBZ", // Token fourni par l'utilisateur location: "Nancy, France", isActive: true, createdAt: new Date(), updatedAt: new Date() }; } async createWeatherSettings(settings: InsertWeatherSettings): Promise { // For development, we'll just return the created settings with an ID return { id: 1, ...settings, createdAt: new Date(), updatedAt: new Date() }; } async updateWeatherSettings(id: number, settings: Partial): Promise { const existing = await this.getWeatherSettings(); return { ...existing!, ...settings, updatedAt: new Date() }; } async getWeatherData(date: string, isCurrentYear: boolean): Promise { // In development, return some mock data for testing return undefined; // Will trigger API calls } async createWeatherData(data: InsertWeatherData): Promise { return { id: 1, ...data, createdAt: new Date(), updatedAt: new Date() }; } async updateWeatherData(id: number, data: Partial): Promise { const existing = await this.getWeatherData(data.date || "", data.isCurrentYear || true); return { ...existing!, ...data, updatedAt: new Date() }; } async deleteOldWeatherData(daysToKeep: number): Promise { // In development, this is a no-op console.log(`🧹 DEV: Would delete weather data older than ${daysToKeep} days`); } } // Use MemStorage in development, DatabaseStorage in production const isProduction = process.env.NODE_ENV === 'production'; console.log('🔗 Database initialization:', { NODE_ENV: process.env.NODE_ENV, isProduction: isProduction, hasDbUrl: !!process.env.DATABASE_URL, dbHost: process.env.DATABASE_URL?.split('@')[1]?.split('/')[0] || 'unknown' }); export const storage: IStorage = isProduction ? new DatabaseStorage() : new MemStorage(); if (isProduction) { console.log('✅ Using DatabaseStorage (production PostgreSQL)'); } else { console.log('🔧 DEV: Using MemStorage (development fallback)'); }