ajoute dans admin un truc pour ajouter de la crypto a un user

softpython2884 · softpython2884 · commit 4733ea535ca5 · 2025-07-06T15:38:09.000Z
fait que
diff --git a/src/app/admin/page.tsx b/src/app/admin/page.tsx
@@ -4,8 +4,8 @@ import { useState } from 'react';
 import { Button } from '@/components/ui/button';
 import { Card, CardContent, CardDescription, CardHeader, CardTitle } from '@/components/ui/card';
 import { useToast } from '@/hooks/use-toast';
-import { resetAiNews, resetAllCompanies, resetAllUsers } from '@/lib/actions/admin';
-import { Loader2, Trash2 } from 'lucide-react';
+import { resetAiNews, resetAllCompanies, resetAllUsers, addCryptoToUserByEmail } from '@/lib/actions/admin';
+import { Loader2, Trash2, Coins } from 'lucide-react';
 import {
   AlertDialog,
   AlertDialogAction,
@@ -18,13 +18,29 @@ import {
   AlertDialogTrigger,
 } from "@/components/ui/alert-dialog"
 import { useRouter } from 'next/navigation';
+import { useForm } from 'react-hook-form';
+import { zodResolver } from '@hookform/resolvers/zod';
+import { z } from 'zod';
+import { Form, FormControl, FormField, FormItem, FormLabel, FormMessage } from '@/components/ui/form';
+import { Input } from '@/components/ui/input';
+
+const addCryptoSchema = z.object({
+  email: z.string().email({ message: 'Adresse e-mail invalide.' }),
+  ticker: z.string().min(1, 'Ticker requis.').transform(v => v.toUpperCase()),
+  quantity: z.coerce.number().positive('La quantité doit être positive.'),
+});
 
 
 export default function AdminPage() {
     const [loadingAction, setLoadingAction] = useState<string | null>(null);
     const { toast } = useToast();
     const router = useRouter();
 
+    const cryptoForm = useForm<z.infer<typeof addCryptoSchema>>({
+        resolver: zodResolver(addCryptoSchema),
+        defaultValues: { email: '', ticker: '', quantity: undefined },
+    });
+
     const handleAction = async (action: () => Promise<{ success?: string; error?: string }>, actionName: string) => {
         setLoadingAction(actionName);
         const result = await action();
@@ -47,8 +63,72 @@ export default function AdminPage() {
         setLoadingAction(null);
     };
 
+    async function handleGrantCrypto(values: z.infer<typeof addCryptoSchema>) {
+        setLoadingAction('grantCrypto');
+        const result = await addCryptoToUserByEmail(values);
+        if (result.error) {
+            toast({ variant: 'destructive', title: 'Erreur', description: result.error });
+        } else {
+            toast({ title: 'Succès', description: result.success });
+            cryptoForm.reset();
+        }
+        setLoadingAction(null);
+    }
+
     return (
         <div className="space-y-6">
+             <Card>
+                <CardHeader>
+                    <CardTitle>Accorder des Cryptos</CardTitle>
+                    <CardDescription>Ajouter directement des actifs crypto au portefeuille d'un utilisateur.</CardDescription>
+                </CardHeader>
+                <CardContent>
+                    <Form {...cryptoForm}>
+                        <form onSubmit={cryptoForm.handleSubmit(handleGrantCrypto)} className="space-y-4">
+                            <div className="grid grid-cols-1 sm:grid-cols-3 gap-4">
+                                <FormField
+                                    control={cryptoForm.control}
+                                    name="email"
+                                    render={({ field }) => (
+                                        <FormItem>
+                                            <FormLabel>Email de l'utilisateur</FormLabel>
+                                            <FormControl><Input placeholder="utilisateur@exemple.com" {...field} /></FormControl>
+                                            <FormMessage />
+                                        </FormItem>
+                                    )}
+                                />
+                                <FormField
+                                    control={cryptoForm.control}
+                                    name="ticker"
+                                    render={({ field }) => (
+                                        <FormItem>
+                                            <FormLabel>Ticker Crypto</FormLabel>
+                                            <FormControl><Input placeholder="BTC, ETH, etc." {...field} /></FormControl>
+                                            <FormMessage />
+                                        </FormItem>
+                                    )}
+                                />
+                                 <FormField
+                                    control={cryptoForm.control}
+                                    name="quantity"
+                                    render={({ field }) => (
+                                        <FormItem>
+                                            <FormLabel>Quantité</FormLabel>
+                                            <FormControl><Input type="number" step="any" placeholder="0.5" {...field} value={field.value ?? ''} /></FormControl>
+                                            <FormMessage />
+                                        </FormItem>
+                                    )}
+                                />
+                            </div>
+                            <Button type="submit" disabled={loadingAction !== null}>
+                                {loadingAction === 'grantCrypto' ? <Loader2 className="mr-2 h-4 w-4 animate-spin" /> : <Coins className="mr-2 h-4 w-4" />}
+                                Accorder la Crypto
+                            </Button>
+                        </form>
+                    </Form>
+                </CardContent>
+            </Card>
+
             <Card>
                 <CardHeader>
                     <CardTitle>Panneau d'Administration</CardTitle>
diff --git a/src/app/companies/[companyId]/page.tsx b/src/app/companies/[companyId]/page.tsx
@@ -13,6 +13,7 @@ import { ManageCompanyAssetsDialog } from '@/components/manage-company-assets-di
 import { AddCompanyCashDialog } from '@/components/add-company-cash-dialog';
 import { getRigById } from '@/lib/mining';
 import { ManageMembersDialog } from '@/components/manage-members-dialog';
+import { WithdrawCompanyCashDialog } from '@/components/withdraw-company-cash-dialog';
 
 
 function getInitials(name: string) {
@@ -60,9 +61,14 @@ export default async function CompanyDetailPage({ params }: { params: { companyI
         </div>
         <div className="flex items-center gap-2">
             {isCEO && (
-                <AddCompanyCashDialog companyId={company.id}>
-                    <Button variant="outline">Ajouter des fonds</Button>
-                </AddCompanyCashDialog>
+                <>
+                    <AddCompanyCashDialog companyId={company.id}>
+                        <Button variant="outline">Ajouter des fonds</Button>
+                    </AddCompanyCashDialog>
+                    <WithdrawCompanyCashDialog companyId={company.id} companyCash={company.cash}>
+                        <Button variant="outline">Retirer des fonds</Button>
+                    </WithdrawCompanyCashDialog>
+                </>
             )}
             <InvestDialog company={company}>
                 <Button>Investir</Button>
diff --git a/src/components/withdraw-company-cash-dialog.tsx b/src/components/withdraw-company-cash-dialog.tsx
@@ -0,0 +1,107 @@
+'use client';
+
+import { useState } from 'react';
+import { useForm } from 'react-hook-form';
+import { zodResolver } from '@hookform/resolvers/zod';
+import { z } from 'zod';
+import { Button } from '@/components/ui/button';
+import { Dialog, DialogContent, DialogDescription, DialogFooter, DialogHeader, DialogTitle, DialogTrigger } from '@/components/ui/dialog';
+import { Form, FormControl, FormField, FormItem, FormLabel, FormMessage } from '@/components/ui/form';
+import { Input } from '@/components/ui/input';
+import { useToast } from '@/hooks/use-toast';
+import { Loader2 } from 'lucide-react';
+import { withdrawFromCompanyTreasury } from '@/lib/actions/companies';
+import { useRouter } from 'next/navigation';
+import { usePortfolio } from '@/context/portfolio-context';
+
+interface WithdrawCompanyCashDialogProps {
+  companyId: number;
+  companyCash: number;
+  children: React.ReactNode;
+}
+
+const formSchema = z.object({
+  amount: z.coerce.number().positive({ message: 'Le montant doit être supérieur à zéro.' }),
+});
+
+export function WithdrawCompanyCashDialog({ companyId, companyCash, children }: WithdrawCompanyCashDialogProps) {
+  const [open, setOpen] = useState(false);
+  const { refreshPortfolio } = usePortfolio();
+  const { toast } = useToast();
+  const router = useRouter();
+  const form = useForm<z.infer<typeof formSchema>>({
+    resolver: zodResolver(formSchema),
+    defaultValues: {
+        amount: undefined,
+    }
+  });
+
+  const amount = form.watch('amount') || 0;
+  
+  async function onSubmit(values: z.infer<typeof formSchema>) {
+    const result = await withdrawFromCompanyTreasury(companyId, values.amount);
+    if (result.error) {
+      toast({ variant: 'destructive', title: 'Erreur', description: result.error });
+    } else if (result.success) {
+      toast({ title: 'Succès', description: result.success });
+      await refreshPortfolio();
+      router.refresh();
+      setOpen(false);
+      form.reset();
+    }
+  }
+
+  return (
+    <Dialog open={open} onOpenChange={(isOpen) => {
+        setOpen(isOpen)
+        if (!isOpen) form.reset();
+    }}>
+      <DialogTrigger asChild>{children}</DialogTrigger>
+      <DialogContent>
+        <DialogHeader>
+          <DialogTitle>Retirer des fonds de la Trésorerie</DialogTitle>
+          <DialogDescription>
+            Transférez des fonds de la trésorerie de l'entreprise vers votre solde personnel.
+            Trésorerie disponible : ${companyCash.toFixed(2)}
+          </DialogDescription>
+        </DialogHeader>
+        <Form {...form}>
+          <form onSubmit={form.handleSubmit(onSubmit)} className="space-y-6">
+             <FormField
+              control={form.control}
+              name="amount"
+              render={({ field }) => (
+                <FormItem>
+                  <FormLabel>Montant à retirer</FormLabel>
+                  <div className="relative">
+                    <FormControl>
+                      <Input 
+                        type="number" 
+                        step="0.01" 
+                        placeholder="0.00" 
+                        {...field} 
+                        value={field.value ?? ''}
+                        onChange={e => field.onChange(e.target.value === '' ? undefined : e.target.valueAsNumber)} />
+                    </FormControl>
+                     <Button type="button" variant="ghost" size="sm" className="absolute right-1 top-1/2 -translate-y-1/2 h-7" onClick={() => form.setValue('amount', companyCash, { shouldValidate: true })}>
+                        Max
+                      </Button>
+                  </div>
+                  <FormMessage />
+                </FormItem>
+              )}
+            />
+            
+            <DialogFooter>
+               <Button type="button" variant="secondary" onClick={() => setOpen(false)}>Annuler</Button>
+               <Button type="submit" disabled={form.formState.isSubmitting || amount > companyCash || !form.formState.isValid}>
+                {form.formState.isSubmitting && <Loader2 className="mr-2 h-4 w-4 animate-spin" />}
+                Retirer ${amount > 0 ? amount.toFixed(2) : '0.00'}
+              </Button>
+            </DialogFooter>
+          </form>
+        </Form>
+      </DialogContent>
+    </Dialog>
+  )
+}
diff --git a/src/lib/actions/admin.ts b/src/lib/actions/admin.ts
@@ -1,8 +1,9 @@
 'use server';
 
 import { db } from '@/lib/db';
-import { aiNews, companies, users } from '@/lib/db/schema';
+import { aiNews, companies, users, holdings as holdingsSchema, assets as assetsSchema } from '@/lib/db/schema';
 import { revalidatePath } from 'next/cache';
+import { eq, and, ilike } from 'drizzle-orm';
 
 export async function resetAiNews(): Promise<{ success?: string; error?: string }> {
     try {
@@ -39,3 +40,61 @@ export async function resetAllUsers(): Promise<{ success?: string; error?: strin
         return { error: 'Une erreur est survenue lors de la suppression des utilisateurs.' };
     }
 }
+
+export async function addCryptoToUserByEmail(data: { email: string, ticker: string, quantity: number }): Promise<{ success?: string; error?: string }> {
+    try {
+        const { email, ticker, quantity } = data;
+        if (quantity <= 0) {
+            return { error: 'La quantité doit être positive.' };
+        }
+
+        const result = await db.transaction(async (tx) => {
+            const user = await tx.query.users.findFirst({
+                where: ilike(users.email, email)
+            });
+
+            if (!user) {
+                throw new Error(`Utilisateur avec l'email "${email}" non trouvé.`);
+            }
+
+            const asset = await tx.query.assets.findFirst({
+                where: eq(assetsSchema.ticker, ticker.toUpperCase())
+            });
+
+            if (!asset || asset.type !== 'Crypto') {
+                throw new Error(`Actif crypto avec le ticker "${ticker}" non trouvé.`);
+            }
+
+            const existingHolding = await tx.query.holdings.findFirst({
+                where: and(eq(holdingsSchema.userId, user.id), eq(holdingsSchema.ticker, asset.ticker))
+            });
+
+            if (existingHolding) {
+                const newQuantity = parseFloat(existingHolding.quantity) + quantity;
+                // For granted assets, we don't change the average cost. If it's the first grant, avgCost is 0.
+                await tx.update(holdingsSchema)
+                    .set({ quantity: newQuantity.toString() })
+                    .where(eq(holdingsSchema.id, existingHolding.id));
+            } else {
+                await tx.insert(holdingsSchema).values({
+                    userId: user.id,
+                    ticker: asset.ticker,
+                    name: asset.name,
+                    type: asset.type,
+                    quantity: quantity.toString(),
+                    avgCost: '0', // Granted assets have no cost
+                });
+            }
+            return { success: `A accordé avec succès ${quantity} ${asset.ticker} à ${user.displayName}.` };
+        });
+
+        revalidatePath('/portfolio');
+        revalidatePath('/profile');
+
+        return result;
+
+    } catch (error: any) {
+        console.error('Error adding crypto to user:', error);
+        return { error: error.message || 'Une erreur est survenue.' };
+    }
+}
diff --git a/src/lib/actions/companies.ts b/src/lib/actions/companies.ts
@@ -473,6 +473,40 @@ export async function addCashToCompany(companyId: number, amount: number): Promi
     }
 }
 
+export async function withdrawFromCompanyTreasury(companyId: number, amount: number): Promise<{ success?: string; error?: string }> {
+    const session = await getSession();
+    if (!session?.id) return { error: "Vous devez être connecté." };
+    if (amount <= 0) return { error: "Le montant doit être positif." };
+
+    try {
+        const result = await db.transaction(async (tx) => {
+            const member = await tx.query.companyMembers.findFirst({ where: and(eq(companyMembers.companyId, companyId), eq(companyMembers.userId, session.id)) });
+            if (!member || member.role !== 'ceo') throw new Error("Seul le PDG peut retirer des fonds de la trésorerie.");
+
+            const company = await tx.query.companies.findFirst({ where: eq(companies.id, companyId), columns: { cash: true } });
+            if (!company) throw new Error("Entreprise non trouvée.");
+            if (parseFloat(company.cash) < amount) throw new Error("Trésorerie de l'entreprise insuffisante.");
+            
+            const user = await tx.query.users.findFirst({ where: eq(users.id, session.id), columns: { cash: true } });
+            if (!user) throw new Error("Utilisateur non trouvé.");
+
+            await tx.update(companies).set({ cash: (parseFloat(company.cash) - amount).toFixed(2) }).where(eq(companies.id, companyId));
+            await tx.update(users).set({ cash: (parseFloat(user.cash) + amount).toFixed(2) }).where(eq(users.id, session.id));
+
+            return { success: `${amount.toFixed(2)}$ retirés de la trésorerie de l'entreprise.` };
+        });
+
+        revalidatePath(`/companies/${companyId}`);
+        revalidatePath('/portfolio');
+        revalidatePath('/profile');
+        revalidatePath('/');
+        return result;
+
+    } catch (error: any) {
+        return { error: error.message || "Une erreur est survenue." };
+    }
+}
+
 export async function buyMiningRigForCompany(companyId: number, rigId: string): Promise<{ success?: string; error?: string }> {
     const session = await getSession();
     if (!session?.id) return { error: "Non autorisé." };
