- {/* Product Information */}
-
-
-
-
-
-
(
-
- Nom de famille *
+ {/* Identity Information */}
+
+
- {/* Identity Document */}
-
-
- {/* Identity Photos */}
-
-
-
-
- {/* Photo Recto */}
-
-
Photo Recto
-
- {photos.recto ? (
-
-
-
deletePhoto('recto')}
- className="mt-2 text-destructive hover:text-destructive"
- >
-
-
- ) : (
-
-
-
Aucune photo
-
handlePhotoCapture('recto')}
- className="bg-primary text-white hover:bg-primary/90"
- >
-
-
- )}
-
-
-
- {/* Photo Verso */}
-
-
Photo Verso
-
- {photos.verso ? (
-
-
-
deletePhoto('verso')}
- className="mt-2 text-destructive hover:text-destructive"
- >
-
-
- ) : (
-
-
-
Aucune photo
-
handlePhotoCapture('verso')}
- className="bg-primary text-white hover:bg-primary/90"
- >
-
-
- )}
-
-
-
-
-
- {/* Form Actions - Always visible */}
-
- {
- form.reset({
- vendeur: '',
- dateVente: new Date().toISOString().split('T')[0],
- typeArticle: '',
- categorie: '',
- quantite: '',
- gencode: '',
- nom: '',
- prenom: '',
- dateNaissance: '',
- lieuNaissance: '',
- typeIdentite: '',
- numeroIdentite: '',
- autoriteDelivrance: '',
- dateDelivrance: '',
- });
- setPhotos({});
- }}>
-
-
-
-
-
-
-
-
-
-
{
- try {
- const photoData = await camera.capturePhoto();
- if (camera.currentPhotoType) {
- handlePhotoTaken(camera.currentPhotoType, photoData);
- }
- camera.stopCamera();
- } catch (error) {
- toast({
- title: "Erreur",
- description: "Erreur lors de la capture de la photo",
- variant: "destructive",
- });
- }
- }}
- />
-
+ {/* Form Actions - Always visible */}
+
+ {
+ form.reset({
+ vendeur: '',
+ dateVente: new Date().toISOString().split('T')[0],
+ typeArticle: '',
+ categorie: '',
+ quantite: '',
+ gencode: '',
+ nom: '',
+ prenom: '',
+ dateNaissance: '',
+ lieuNaissance: '',
+ typeIdentite: '',
+ numeroIdentite: '',
+ autoriteDelivrance: '',
+ dateDelivrance: '',
+ });
+ }}>
+
+
+
+
+
+
+
+
);
-}
+}
\ No newline at end of file
diff --git a/client/src/components/SalesHistory.tsx b/client/src/components/SalesHistory.tsx
index 2644eb4..a341d55 100644
--- a/client/src/components/SalesHistory.tsx
+++ b/client/src/components/SalesHistory.tsx
@@ -1,284 +1,286 @@
import { useState } from 'react';
-import { Card, CardHeader, CardTitle, CardContent } from '@/components/ui/card';
+import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query';
+import { Card, CardContent, CardHeader, CardTitle } from '@/components/ui/card';
import { Button } from '@/components/ui/button';
-import { Badge } from '@/components/ui/badge';
+import { Input } from '@/components/ui/input';
import { Table, TableBody, TableCell, TableHead, TableHeader, TableRow } from '@/components/ui/table';
+import { Dialog, DialogContent, DialogHeader, DialogTitle, DialogTrigger } from '@/components/ui/dialog';
import { useToast } from '@/hooks/use-toast';
-import { Download, Save, Search, Eye, Trash2, BarChart3, AlertCircle } from 'lucide-react';
-import { Sale } from '@/types/sale';
-import { exportToCSV, formatDate } from '@/lib/export';
-import { downloadBackup, getAutoBackup } from '@/lib/storage';
-import SaleDetailsModal from './SaleDetailsModal';
+import { apiRequest } from '@/lib/queryClient';
+import type { Sale } from '@shared/schema';
+import { History, Download, Trash2, Eye, Filter } from 'lucide-react';
interface SalesHistoryProps {
- sales: Sale[];
- isLoading: boolean;
- error: string | null;
- onDeleteSale: (id: number) => Promise;
+ canDelete?: boolean;
}
-export default function SalesHistory({ sales, isLoading, error, onDeleteSale }: SalesHistoryProps) {
+export default function SalesHistory({ canDelete = false }: SalesHistoryProps) {
const { toast } = useToast();
+ const queryClient = useQueryClient();
const [selectedSale, setSelectedSale] = useState(null);
- const [isDeleting, setIsDeleting] = useState(null);
+ const [startDate, setStartDate] = useState('');
+ const [endDate, setEndDate] = useState('');
- const handleExportCSV = () => {
- if (sales.length === 0) {
- toast({
- title: "Aucune vente à exporter",
- description: "Il n'y a aucune vente enregistrée",
- });
- return;
- }
+ // Query for sales
+ const { data: sales = [], isLoading } = useQuery({
+ queryKey: ['/api/sales', startDate, endDate],
+ queryFn: () => {
+ const params = new URLSearchParams();
+ if (startDate) params.append('startDate', startDate);
+ if (endDate) params.append('endDate', endDate);
+ const queryString = params.toString();
+ return apiRequest(`/api/sales${queryString ? `?${queryString}` : ''}`);
+ },
+ });
- try {
- exportToCSV(sales);
- toast({
- title: "Export réussi !",
- description: `${sales.length} vente(s) exportée(s)`,
- });
- } catch (error) {
- toast({
- title: "Erreur d'export",
- description: "Impossible d'exporter les données",
- variant: "destructive",
- });
- }
- };
-
- const handleDownloadBackup = () => {
- const backup = getAutoBackup();
- if (!backup) {
- toast({
- title: "Aucune sauvegarde disponible",
- description: "Aucun backup automatique trouvé",
- });
- return;
- }
-
- try {
- downloadBackup();
- toast({
- title: "Backup téléchargé",
- description: "Sauvegarde téléchargée avec succès",
- });
- } catch (error) {
- toast({
- title: "Erreur",
- description: "Impossible de télécharger la sauvegarde",
- variant: "destructive",
- });
- }
- };
-
- const handleDiagnostic = () => {
- console.log('=== DIAGNOSTIC COMPLET ===');
- console.log('Nombre de ventes:', sales.length);
- console.log('Données:', sales);
- console.log('LocalStorage backup:', getAutoBackup());
-
- toast({
- title: "Diagnostic affiché",
- description: "Vérifiez la console pour les détails",
- });
- };
-
- const handleDeleteSale = async (sale: Sale) => {
- const confirmed = window.confirm(
- `Supprimer définitivement la vente de ${sale.nom} ${sale.prenom} ?\n\n⚠️ Cette action est irréversible !\n\nID: ${sale.id}`
- );
-
- if (!confirmed) return;
-
- try {
- setIsDeleting(sale.id);
- await onDeleteSale(sale.id);
+ // Delete mutation
+ const deleteSaleMutation = useMutation({
+ mutationFn: (saleId: number) =>
+ apiRequest(`/api/sales/${saleId}`, { method: 'DELETE' }),
+ onSuccess: () => {
+ queryClient.invalidateQueries({ queryKey: ['/api/sales'] });
toast({
title: "Vente supprimée",
- description: `Vente de ${sale.nom} ${sale.prenom} supprimée`,
+ description: "La vente a été supprimée avec succès",
});
- } catch (error) {
+ },
+ onError: () => {
toast({
title: "Erreur",
description: "Impossible de supprimer la vente",
variant: "destructive",
});
- } finally {
- setIsDeleting(null);
+ },
+ });
+
+ const handleDeleteSale = async (sale: Sale) => {
+ if (confirm(`Êtes-vous sûr de vouloir supprimer cette vente ?`)) {
+ deleteSaleMutation.mutate(sale.id);
}
};
- const backup = getAutoBackup();
+ const exportToCSV = () => {
+ if (sales.length === 0) {
+ toast({
+ title: "Aucune donnée",
+ description: "Aucune vente à exporter",
+ variant: "destructive",
+ });
+ return;
+ }
- if (isLoading) {
- return (
-
-
-
-
-
Chargement des ventes...
-
-
- );
- }
+ const csvHeader = [
+ 'Date/Heure',
+ 'Vendeur',
+ 'Date de vente',
+ 'Type d\'article',
+ 'Catégorie',
+ 'Quantité',
+ 'Gencode',
+ 'Nom client',
+ 'Prénom client',
+ 'Date de naissance',
+ 'Lieu de naissance',
+ 'Type identité',
+ 'Numéro identité',
+ 'Autorité délivrance',
+ 'Date délivrance'
+ ].join(',');
- if (error) {
- return (
-
-
-
-
-
- );
- }
+ const csvData = sales.map(sale => [
+ new Date(sale.timestamp!).toLocaleString('fr-FR'),
+ sale.vendeur,
+ sale.dateVente,
+ sale.typeArticle,
+ sale.categorie,
+ sale.quantite,
+ sale.gencode,
+ sale.nom,
+ sale.prenom,
+ sale.dateNaissance,
+ sale.lieuNaissance || '',
+ sale.typeIdentite,
+ sale.numeroIdentite,
+ sale.autoriteDelivrance,
+ sale.dateDelivrance
+ ].map(field => `"${field}"`).join(',')).join('\n');
+
+ const csvContent = csvHeader + '\n' + csvData;
+ const blob = new Blob([csvContent], { type: 'text/csv;charset=utf-8;' });
+ const link = document.createElement('a');
+ link.href = URL.createObjectURL(blob);
+ link.download = `ventes_fireworks_${new Date().toISOString().split('T')[0]}.csv`;
+ link.click();
+
+ toast({
+ title: "Export réussi",
+ description: `${sales.length} ventes exportées`,
+ });
+ };
+
+ const formatDate = (dateString: string) => {
+ return new Date(dateString).toLocaleDateString('fr-FR');
+ };
+
+ const formatDateTime = (dateString: string) => {
+ return new Date(dateString).toLocaleString('fr-FR');
+ };
return (
- <>
-
-
-
+
+
+
+
+
+
+ {/* Filters */}
+
+
-
-
-
- Gestion et export des ventes enregistrées
-
+
Date de début
+
setStartDate(e.target.value)}
+ />
-
-
-
-
-
-
-
+
+ Date de fin
+
-
-
- {/* Status Information */}
-
-
-
-
-
- Données stockées localement ({sales.length} vente{sales.length !== 1 ? 's' : ''}) • Export CSV compatible Excel • Sauvegarde automatique à chaque ajout
-
-
-
- {backup ? (
-
- Dernier backup: {formatDate(backup.timestamp)} ({backup.recordCount} enreg.)
-
- ) : (
- Dernier backup: Aucun
- )}
-
+
+
-
- {sales.length === 0 ? (
-
-
-
-
Aucune vente enregistrée
-
-
-
-
- Date
- Vendeur
- Client
- Produit
- Catégorie
- Quantité
- Actions
-
-
-
- {sales.map((sale) => (
-
-
- {formatDate(sale.dateVente)}
-
-
- {sale.vendeur || 'Non spécifié'}
-
-
-
-
{sale.nom} {sale.prenom}
- {sale.typeIdentite && (
-
{sale.typeIdentite}
- )}
-
-
-
-
{sale.typeArticle}
- {sale.gencode && (
-
{sale.gencode}
- )}
-
-
-
+ {/* Sales Table */}
+ {isLoading ? (
+
+ ) : sales.length === 0 ? (
+
+ Aucune vente trouvée
+
+ ) : (
+
+
+
+
+ Date/Heure
+ Vendeur
+ Client
+ Article
+ Quantité
+ Gencode
+ Actions
+
+
+
+ {sales.map((sale) => (
+
+ {formatDateTime(sale.timestamp!)}
+ {sale.vendeur}
+
+
+
{sale.nom} {sale.prenom}
+
+ {formatDate(sale.dateNaissance)}
+
+
+
+
+
{sale.typeArticle}
+
{sale.categorie}
-
-
-
- {sale.quantite}
-
-
-
- setSelectedSale(sale)}
- title="Voir les détails"
- >
-
+
+
+
+ {sale.quantite}
+ {sale.gencode}
+
+
+
+
+ setSelectedSale(sale)}
+ >
+
+
+
+
+ Détails de la vente
+
+ {selectedSale && (
+
+
+
Informations générales
+
Date/Heure : {formatDateTime(selectedSale.timestamp!)}
+
Vendeur : {selectedSale.vendeur}
+
Date de vente : {formatDate(selectedSale.dateVente)}
+
+
+
Produit
+
Type : {selectedSale.typeArticle}
+
Catégorie : {selectedSale.categorie}
+
Quantité : {selectedSale.quantite}
+
Gencode : {selectedSale.gencode}
+
+
+
Client
+
Nom : {selectedSale.nom}
+
Prénom : {selectedSale.prenom}
+
Date de naissance : {formatDate(selectedSale.dateNaissance)}
+ {selectedSale.lieuNaissance && (
+
Lieu de naissance : {selectedSale.lieuNaissance}
+ )}
+
+
+
Pièce d'identité
+
Type : {selectedSale.typeIdentite}
+
Numéro : {selectedSale.numeroIdentite}
+
Autorité : {selectedSale.autoriteDelivrance}
+
Date délivrance : {formatDate(selectedSale.dateDelivrance)}
+
+
+
+ {canDelete && (
handleDeleteSale(sale)}
- disabled={isDeleting === sale.id}
- className="text-destructive hover:text-destructive"
- title="Supprimer la vente"
+ disabled={deleteSaleMutation.isPending}
>
-
-
-
- ))}
-
-
-
setSelectedSale(null)}
- />
-
+ )}
+
+
+
+ ))}
+
+
+
+
);
-}
+}
\ No newline at end of file
diff --git a/client/src/hooks/useAuth.ts b/client/src/hooks/useAuth.ts
new file mode 100644
index 0000000..c2d6027
--- /dev/null
+++ b/client/src/hooks/useAuth.ts
@@ -0,0 +1,67 @@
+import { useState, useEffect } from "react";
+import { useMutation, useQueryClient } from "@tanstack/react-query";
+import { apiRequest } from "@/lib/queryClient";
+import type { User, LoginData } from "@shared/schema";
+
+export function useAuth() {
+ const queryClient = useQueryClient();
+ const [user, setUser] = useState
(null);
+ const [isLoading, setIsLoading] = useState(true);
+
+ useEffect(() => {
+ const checkAuth = async () => {
+ try {
+ const response = await fetch('/api/auth/me', {
+ credentials: 'include',
+ });
+
+ if (response.ok) {
+ const userData = await response.json();
+ setUser(userData);
+ } else {
+ setUser(null);
+ }
+ } catch (error) {
+ setUser(null);
+ } finally {
+ setIsLoading(false);
+ }
+ };
+
+ checkAuth();
+ }, []);
+
+ const loginMutation = useMutation({
+ mutationFn: async (credentials: LoginData) => {
+ const response = await apiRequest('/api/auth/login', {
+ method: 'POST',
+ body: JSON.stringify(credentials)
+ });
+ return response.json();
+ },
+ onSuccess: (data) => {
+ setUser(data.user);
+ queryClient.clear();
+ },
+ });
+
+ const logoutMutation = useMutation({
+ mutationFn: async () => {
+ await apiRequest('/api/auth/logout', { method: 'POST' });
+ },
+ onSuccess: () => {
+ setUser(null);
+ queryClient.clear();
+ },
+ });
+
+ return {
+ user,
+ isLoading,
+ isAuthenticated: !!user,
+ login: loginMutation.mutateAsync,
+ logout: logoutMutation.mutateAsync,
+ isLoggingIn: loginMutation.isPending,
+ isLoggingOut: logoutMutation.isPending,
+ };
+}
\ No newline at end of file
diff --git a/client/src/lib/queryClient.ts b/client/src/lib/queryClient.ts
index f315a14..faaed00 100644
--- a/client/src/lib/queryClient.ts
+++ b/client/src/lib/queryClient.ts
@@ -8,14 +8,22 @@ async function throwIfResNotOk(res: Response) {
}
export async function apiRequest(
- method: string,
url: string,
- data?: unknown | undefined,
+ options: {
+ method?: string;
+ headers?: Record;
+ body?: string;
+ } = {}
): Promise {
+ const { method = 'GET', headers = {}, body } = options;
+
const res = await fetch(url, {
method,
- headers: data ? { "Content-Type": "application/json" } : {},
- body: data ? JSON.stringify(data) : undefined,
+ headers: {
+ 'Content-Type': 'application/json',
+ ...headers,
+ },
+ body,
credentials: "include",
});
@@ -44,7 +52,7 @@ export const getQueryFn: (options: {
export const queryClient = new QueryClient({
defaultOptions: {
queries: {
- queryFn: getQueryFn({ on401: "throw" }),
+ queryFn: getQueryFn({ on401: "returnNull" }),
refetchInterval: false,
refetchOnWindowFocus: false,
staleTime: Infinity,
diff --git a/client/src/pages/Dashboard.tsx b/client/src/pages/Dashboard.tsx
new file mode 100644
index 0000000..4c644df
--- /dev/null
+++ b/client/src/pages/Dashboard.tsx
@@ -0,0 +1,105 @@
+import { useState } from "react";
+import { Card, CardContent, CardHeader, CardTitle } from "@/components/ui/card";
+import { Button } from "@/components/ui/button";
+import { Tabs, TabsContent, TabsList, TabsTrigger } from "@/components/ui/tabs";
+import { useAuth } from "@/hooks/useAuth";
+import NewSaleForm from "@/components/NewSaleForm";
+import SalesHistory from "@/components/SalesHistory";
+import Administration from "@/components/Administration";
+import { Package, History, Settings, LogOut, User } from "lucide-react";
+import { useToast } from "@/hooks/use-toast";
+
+export default function Dashboard() {
+ const { user, logout } = useAuth();
+ const { toast } = useToast();
+ const [activeTab, setActiveTab] = useState("new-sale");
+
+ const handleLogout = async () => {
+ try {
+ await logout();
+ toast({
+ title: "Déconnexion réussie",
+ description: "À bientôt !",
+ });
+ } catch (error) {
+ toast({
+ title: "Erreur",
+ description: "Erreur lors de la déconnexion",
+ variant: "destructive",
+ });
+ }
+ };
+
+ const canAccessAdmin = user?.role === "admin";
+ const canDeleteSales = user?.role === "admin" || user?.role === "manager";
+
+ return (
+
+ {/* Header */}
+
+
+
+
+
+
+
Registre des Ventes
+
Gestion des feux d'artifice
+
+
+
+
+
+
+ {user?.firstName} {user?.lastName}
+
+
{user?.role}
+
+
+
+
+
+
+
+ {/* Main Content */}
+
+
+
+
+
+
+
+ {canAccessAdmin && (
+
+
+ )}
+
+
+
+
+
+
+
+
+ {canAccessAdmin && (
+
+
+ )}
+
+
+
({
+ resolver: zodResolver(loginSchema),
+ defaultValues: {
+ username: "",
+ password: "",
+ },
+ });
+
+ const onSubmit = async (data: LoginData) => {
+ try {
+ await login(data);
+ toast({
+ title: "Connexion réussie",
+ description: "Bienvenue dans l'application !",
+ });
+ } catch (error) {
+ toast({
+ title: "Erreur de connexion",
+ description: "Nom d'utilisateur ou mot de passe incorrect",
+ variant: "destructive",
+ });
+ }
+ };
+
+ return (
+
+
+
+
+ Registre des Ventes
+ Connectez-vous pour accéder à l'application
+
+
+
+
+
+
+
Compte par défaut :
+
+
Utilisateur : admin
+
Mot de passe : admin123
+
+
+
+
{
- // put application routes here
- // prefix all routes with /api
+ // Session configuration with PostgreSQL store
+ const pgStore = connectPg(session);
+ app.use(session({
+ store: new pgStore({
+ conString: process.env.DATABASE_URL,
+ createTableIfMissing: false,
+ tableName: 'sessions',
+ }),
+ secret: process.env.SESSION_SECRET || 'fireworks-secret-key-2024',
+ resave: false,
+ saveUninitialized: false,
+ cookie: {
+ secure: false, // Set to true in production with HTTPS
+ maxAge: 24 * 60 * 60 * 1000 // 24 hours
+ }
+ }));
- // use storage to perform CRUD operations on the storage interface
- // e.g. storage.insertUser(user) or storage.getUserByUsername(username)
+ // Initialize default admin if needed
+ const initResult = await storage.initializeDefaults();
+ if (initResult.defaultAdminCredentials) {
+ console.log('\n=== DEFAULT ADMIN CREATED ===');
+ console.log('Username:', initResult.defaultAdminCredentials.username);
+ console.log('Password:', initResult.defaultAdminCredentials.password);
+ console.log('Please change this password after first login!');
+ console.log('==============================\n');
+ }
+
+ // Auth routes
+ app.post('/api/auth/login', async (req, res) => {
+ try {
+ const { username, password } = loginSchema.parse(req.body);
+
+ const user = await storage.authenticateUser(username, password);
+ if (!user) {
+ return res.status(401).json({ error: "Invalid credentials" });
+ }
+
+ req.session.userId = user.id;
+ res.json({ user: { ...user, password: undefined } });
+ } catch (error) {
+ console.error('Login error:', error);
+ if (error instanceof z.ZodError) {
+ return res.status(400).json({ error: "Invalid input", details: error.errors });
+ }
+ res.status(500).json({ error: "Login failed" });
+ }
+ });
+
+ app.post('/api/auth/logout', (req, res) => {
+ req.session.destroy((err) => {
+ if (err) {
+ console.error('Logout error:', err);
+ return res.status(500).json({ error: "Logout failed" });
+ }
+ res.json({ message: "Logged out successfully" });
+ });
+ });
+
+ app.get('/api/auth/me', requireAuth, async (req, res) => {
+ try {
+ const user = await storage.getUser(req.session.userId!);
+ if (!user) {
+ return res.status(404).json({ error: "User not found" });
+ }
+ res.json({ ...user, password: undefined });
+ } catch (error) {
+ console.error('Get user error:', error);
+ res.status(500).json({ error: "Failed to get user info" });
+ }
+ });
+
+ // Sales routes
+ app.get('/api/sales', requireAuth, async (req, res) => {
+ try {
+ const user = await storage.getUser(req.session.userId!);
+ if (!user) {
+ return res.status(404).json({ error: "User not found" });
+ }
+
+ const { startDate, endDate } = req.query;
+ const sales = await storage.getSalesByStore(
+ user.storeId!,
+ startDate as string,
+ endDate as string
+ );
+ res.json(sales);
+ } catch (error) {
+ console.error('Get sales error:', error);
+ res.status(500).json({ error: "Failed to get sales" });
+ }
+ });
+
+ app.post('/api/sales', requireAuth, async (req, res) => {
+ try {
+ const user = await storage.getUser(req.session.userId!);
+ if (!user) {
+ return res.status(404).json({ error: "User not found" });
+ }
+
+ const saleData = insertSaleSchema.parse({
+ ...req.body,
+ storeId: user.storeId,
+ userId: user.id
+ });
+
+ const sale = await storage.createSale(saleData);
+ res.status(201).json(sale);
+ } catch (error) {
+ console.error('Create sale error:', error);
+ if (error instanceof z.ZodError) {
+ return res.status(400).json({ error: "Invalid input", details: error.errors });
+ }
+ res.status(500).json({ error: "Failed to create sale" });
+ }
+ });
+
+ app.delete('/api/sales/:id', requireRole(['admin', 'manager']), async (req, res) => {
+ try {
+ const saleId = parseInt(req.params.id);
+ await storage.deleteSale(saleId);
+ res.json({ message: "Sale deleted successfully" });
+ } catch (error) {
+ console.error('Delete sale error:', error);
+ res.status(500).json({ error: "Failed to delete sale" });
+ }
+ });
+
+ // Admin routes - Users
+ app.get('/api/admin/users', requireRole(['admin']), async (req, res) => {
+ try {
+ const users = await storage.getAllUsers();
+ const safeUsers = users.map(user => ({ ...user, password: undefined }));
+ res.json(safeUsers);
+ } catch (error) {
+ console.error('Get users error:', error);
+ res.status(500).json({ error: "Failed to get users" });
+ }
+ });
+
+ app.post('/api/admin/users', requireRole(['admin']), async (req, res) => {
+ try {
+ const userData = insertUserSchema.parse(req.body);
+ const user = await storage.createUser(userData);
+ res.status(201).json({ ...user, password: undefined });
+ } catch (error) {
+ console.error('Create user error:', error);
+ if (error instanceof z.ZodError) {
+ return res.status(400).json({ error: "Invalid input", details: error.errors });
+ }
+ res.status(500).json({ error: "Failed to create user" });
+ }
+ });
+
+ app.put('/api/admin/users/:id', requireRole(['admin']), async (req, res) => {
+ try {
+ const userId = parseInt(req.params.id);
+ const userData = insertUserSchema.partial().parse(req.body);
+ const user = await storage.updateUser(userId, userData);
+ if (!user) {
+ return res.status(404).json({ error: "User not found" });
+ }
+ res.json({ ...user, password: undefined });
+ } catch (error) {
+ console.error('Update user error:', error);
+ if (error instanceof z.ZodError) {
+ return res.status(400).json({ error: "Invalid input", details: error.errors });
+ }
+ res.status(500).json({ error: "Failed to update user" });
+ }
+ });
+
+ // Admin routes - Stores
+ app.get('/api/admin/stores', requireRole(['admin']), async (req, res) => {
+ try {
+ const stores = await storage.getAllStores();
+ res.json(stores);
+ } catch (error) {
+ console.error('Get stores error:', error);
+ res.status(500).json({ error: "Failed to get stores" });
+ }
+ });
+
+ app.post('/api/admin/stores', requireRole(['admin']), async (req, res) => {
+ try {
+ const storeData = insertStoreSchema.parse(req.body);
+ const store = await storage.createStore(storeData);
+ res.status(201).json(store);
+ } catch (error) {
+ console.error('Create store error:', error);
+ if (error instanceof z.ZodError) {
+ return res.status(400).json({ error: "Invalid input", details: error.errors });
+ }
+ res.status(500).json({ error: "Failed to create store" });
+ }
+ });
+
+ app.put('/api/admin/stores/:id', requireRole(['admin']), async (req, res) => {
+ try {
+ const storeId = parseInt(req.params.id);
+ const storeData = insertStoreSchema.partial().parse(req.body);
+ const store = await storage.updateStore(storeId, storeData);
+ if (!store) {
+ return res.status(404).json({ error: "Store not found" });
+ }
+ res.json(store);
+ } catch (error) {
+ console.error('Update store error:', error);
+ if (error instanceof z.ZodError) {
+ return res.status(400).json({ error: "Invalid input", details: error.errors });
+ }
+ res.status(500).json({ error: "Failed to update store" });
+ }
+ });
const httpServer = createServer(app);
-
return httpServer;
}
diff --git a/server/storage.ts b/server/storage.ts
index e01abec..d40c9fb 100644
--- a/server/storage.ts
+++ b/server/storage.ts
@@ -1,39 +1,198 @@
-import { users, type User, type InsertUser } from "@shared/schema";
-
-// modify the interface with any CRUD methods
-// you might need
+import {
+ users,
+ stores,
+ sales,
+ type User,
+ type InsertUser,
+ type Store,
+ type InsertStore,
+ type Sale,
+ type InsertSale,
+} from "@shared/schema";
+import { db } from "./db";
+import { eq, and, gte, lte, desc } from "drizzle-orm";
+import bcrypt from "bcryptjs";
export interface IStorage {
+ // User operations
getUser(id: number): Promise;
getUserByUsername(username: string): Promise;
createUser(user: InsertUser): Promise;
+ updateUser(id: number, user: Partial): Promise;
+ getAllUsers(): Promise;
+
+ // Store operations
+ getStore(id: number): Promise;
+ createStore(store: InsertStore): Promise;
+ getAllStores(): Promise;
+ updateStore(id: number, store: Partial): Promise;
+
+ // Sale operations
+ getSale(id: number): Promise;
+ createSale(sale: InsertSale): Promise;
+ getSalesByStore(storeId: number, startDate?: string, endDate?: string): Promise;
+ deleteSale(id: number): Promise;
+
+ // Auth operations
+ authenticateUser(username: string, password: string): Promise;
+ hashPassword(password: string): Promise;
+ initializeDefaults(): Promise<{ defaultAdminCredentials?: { username: string; password: string } }>;
}
-export class MemStorage implements IStorage {
- private users: Map;
- currentId: number;
-
- constructor() {
- this.users = new Map();
- this.currentId = 1;
- }
-
+export class DatabaseStorage implements IStorage {
+ // User operations
async getUser(id: number): Promise {
- return this.users.get(id);
+ const [user] = await db.select().from(users).where(eq(users.id, id));
+ return user;
}
async getUserByUsername(username: string): Promise {
- return Array.from(this.users.values()).find(
- (user) => user.username === username,
- );
+ const [user] = await db.select().from(users).where(eq(users.username, username));
+ return user;
}
- async createUser(insertUser: InsertUser): Promise {
- const id = this.currentId++;
- const user: User = { ...insertUser, id };
- this.users.set(id, user);
+ async createUser(userData: InsertUser): Promise {
+ // Hash password if provided
+ if (userData.password) {
+ userData.password = await this.hashPassword(userData.password);
+ }
+
+ const [user] = await db
+ .insert(users)
+ .values(userData)
+ .returning();
return user;
}
+
+ async updateUser(id: number, userData: Partial): Promise {
+ // Hash password if provided
+ if (userData.password) {
+ userData.password = await this.hashPassword(userData.password);
+ }
+
+ const [user] = await db
+ .update(users)
+ .set(userData)
+ .where(eq(users.id, id))
+ .returning();
+ return user;
+ }
+
+ async getAllUsers(): Promise {
+ return await db.select().from(users).orderBy(desc(users.createdAt));
+ }
+
+ // Store operations
+ async getStore(id: number): Promise {
+ const [store] = await db.select().from(stores).where(eq(stores.id, id));
+ return store;
+ }
+
+ async createStore(storeData: InsertStore): Promise {
+ const [store] = await db
+ .insert(stores)
+ .values(storeData)
+ .returning();
+ return store;
+ }
+
+ async getAllStores(): Promise {
+ return await db.select().from(stores).orderBy(desc(stores.createdAt));
+ }
+
+ async updateStore(id: number, storeData: Partial): Promise {
+ const [store] = await db
+ .update(stores)
+ .set(storeData)
+ .where(eq(stores.id, id))
+ .returning();
+ return store;
+ }
+
+ // Sale operations
+ async getSale(id: number): Promise {
+ const [sale] = await db.select().from(sales).where(eq(sales.id, id));
+ return sale;
+ }
+
+ async createSale(saleData: InsertSale): Promise {
+ const [sale] = await db
+ .insert(sales)
+ .values(saleData)
+ .returning();
+ return sale;
+ }
+
+ async getSalesByStore(storeId: number, startDate?: string, endDate?: string): Promise {
+ let query = db.select().from(sales).where(eq(sales.storeId, storeId));
+
+ if (startDate && endDate) {
+ query = db.select().from(sales).where(
+ and(
+ eq(sales.storeId, storeId),
+ gte(sales.dateVente, startDate),
+ lte(sales.dateVente, endDate)
+ )
+ );
+ }
+
+ return await query.orderBy(desc(sales.timestamp));
+ }
+
+ async deleteSale(id: number): Promise {
+ await db.delete(sales).where(eq(sales.id, id));
+ }
+
+ // Auth operations
+ async authenticateUser(username: string, password: string): Promise {
+ const user = await this.getUserByUsername(username);
+ if (!user || !user.isActive) {
+ return null;
+ }
+
+ const isValid = await bcrypt.compare(password, user.password);
+ return isValid ? user : null;
+ }
+
+ async hashPassword(password: string): Promise {
+ return await bcrypt.hash(password, 12);
+ }
+
+ // Initialize default admin user and store if none exist
+ async initializeDefaults(): Promise<{ defaultAdminCredentials?: { username: string; password: string } }> {
+ const existingUsers = await this.getAllUsers();
+
+ if (existingUsers.length === 0) {
+ // Create default store
+ const defaultStore = await this.createStore({
+ name: "Magasin Principal",
+ address: "À définir",
+ isActive: true,
+ });
+
+ // Create default admin user
+ const defaultPassword = "admin123";
+ const adminUser = await this.createUser({
+ username: "admin",
+ password: defaultPassword,
+ email: "admin@example.com",
+ firstName: "Administrateur",
+ lastName: "Principal",
+ role: "admin",
+ storeId: defaultStore.id,
+ isActive: true,
+ });
+
+ return {
+ defaultAdminCredentials: {
+ username: "admin",
+ password: defaultPassword
+ }
+ };
+ }
+
+ return {};
+ }
}
-export const storage = new MemStorage();
+export const storage = new DatabaseStorage();
diff --git a/shared/schema.ts b/shared/schema.ts
index e58e0af..ecb7d7d 100644
--- a/shared/schema.ts
+++ b/shared/schema.ts
@@ -1,17 +1,144 @@
-import { pgTable, text, serial, integer, boolean } from "drizzle-orm/pg-core";
+import {
+ pgTable,
+ text,
+ varchar,
+ timestamp,
+ jsonb,
+ index,
+ serial,
+ integer,
+ boolean,
+} from "drizzle-orm/pg-core";
+import { relations } from "drizzle-orm";
import { createInsertSchema } from "drizzle-zod";
import { z } from "zod";
+// Session storage table
+export const sessions = pgTable(
+ "sessions",
+ {
+ sid: varchar("sid").primaryKey(),
+ sess: jsonb("sess").notNull(),
+ expire: timestamp("expire").notNull(),
+ },
+ (table) => [index("IDX_session_expire").on(table.expire)],
+);
+
+// Magasins table
+export const stores = pgTable("stores", {
+ id: serial("id").primaryKey(),
+ name: varchar("name", { length: 255 }).notNull(),
+ address: text("address"),
+ phone: varchar("phone", { length: 20 }),
+ email: varchar("email", { length: 255 }),
+ isActive: boolean("is_active").default(true),
+ createdAt: timestamp("created_at").defaultNow(),
+ updatedAt: timestamp("updated_at").defaultNow(),
+});
+
+// Users table with authentication
export const users = pgTable("users", {
id: serial("id").primaryKey(),
- username: text("username").notNull().unique(),
- password: text("password").notNull(),
+ username: varchar("username", { length: 50 }).unique().notNull(),
+ password: varchar("password", { length: 255 }).notNull(), // Will be hashed
+ email: varchar("email", { length: 255 }).unique(),
+ firstName: varchar("first_name", { length: 100 }),
+ lastName: varchar("last_name", { length: 100 }),
+ role: varchar("role", { length: 20 }).notNull().default("employee"), // admin, manager, employee
+ storeId: integer("store_id").references(() => stores.id),
+ isActive: boolean("is_active").default(true),
+ createdAt: timestamp("created_at").defaultNow(),
+ updatedAt: timestamp("updated_at").defaultNow(),
});
-export const insertUserSchema = createInsertSchema(users).pick({
- username: true,
- password: true,
+// Sales table
+export const sales = pgTable("sales", {
+ id: serial("id").primaryKey(),
+ storeId: integer("store_id").references(() => stores.id).notNull(),
+ userId: integer("user_id").references(() => users.id).notNull(),
+ timestamp: timestamp("timestamp").defaultNow(),
+
+ // Vendeur
+ vendeur: varchar("vendeur", { length: 255 }).notNull(),
+ dateVente: varchar("date_vente", { length: 10 }).notNull(),
+
+ // Produit
+ typeArticle: varchar("type_article", { length: 255 }).notNull(),
+ categorie: varchar("categorie", { length: 2 }).notNull(),
+ quantite: integer("quantite").notNull(),
+ gencode: varchar("gencode", { length: 13 }).notNull(),
+
+ // Client
+ nom: varchar("nom", { length: 255 }).notNull(),
+ prenom: varchar("prenom", { length: 255 }).notNull(),
+ dateNaissance: varchar("date_naissance", { length: 10 }).notNull(),
+ lieuNaissance: varchar("lieu_naissance", { length: 255 }),
+
+ // Identité
+ typeIdentite: varchar("type_identite", { length: 50 }).notNull(),
+ numeroIdentite: varchar("numero_identite", { length: 100 }).notNull(),
+ autoriteDelivrance: varchar("autorite_delivrance", { length: 255 }).notNull(),
+ dateDelivrance: varchar("date_delivrance", { length: 10 }).notNull(),
+
+ // Photos
+ photoRecto: text("photo_recto"),
+ photoVerso: text("photo_verso"),
});
-export type InsertUser = z.infer;
+// Relations
+export const storesRelations = relations(stores, ({ many }) => ({
+ users: many(users),
+ sales: many(sales),
+}));
+
+export const usersRelations = relations(users, ({ one, many }) => ({
+ store: one(stores, {
+ fields: [users.storeId],
+ references: [stores.id],
+ }),
+ sales: many(sales),
+}));
+
+export const salesRelations = relations(sales, ({ one }) => ({
+ store: one(stores, {
+ fields: [sales.storeId],
+ references: [stores.id],
+ }),
+ user: one(users, {
+ fields: [sales.userId],
+ references: [users.id],
+ }),
+}));
+
+// Insert schemas
+export const insertUserSchema = createInsertSchema(users).omit({
+ id: true,
+ createdAt: true,
+ updatedAt: true,
+});
+
+export const insertStoreSchema = createInsertSchema(stores).omit({
+ id: true,
+ createdAt: true,
+ updatedAt: true,
+});
+
+export const insertSaleSchema = createInsertSchema(sales).omit({
+ id: true,
+ timestamp: true,
+});
+
+// Login schema
+export const loginSchema = z.object({
+ username: z.string().min(1, "Nom d'utilisateur requis"),
+ password: z.string().min(1, "Mot de passe requis"),
+});
+
+// Types
export type User = typeof users.$inferSelect;
+export type InsertUser = typeof users.$inferInsert;
+export type Store = typeof stores.$inferSelect;
+export type InsertStore = typeof stores.$inferInsert;
+export type Sale = typeof sales.$inferSelect;
+export type InsertSale = typeof sales.$inferInsert;
+export type LoginData = z.infer;