from django.core.management.base import BaseCommand from django.contrib.auth import get_user_model from django.db import transaction from apps.shares.models import ShareType, ShareSubscription from apps.members.models import Member from apps.banking.models import Account class Command(BaseCommand): help = "Initializes basic shares data: creates a share type, subscription, and payment." def handle(self, *args, **options): User = get_user_model() self.stdout.write(self.style.SUCCESS("--- Initializing Shares Data ---")) try: # Recherche d'utilisateurs existants regular_user = User.objects.filter(email="user@example.com").first() superuser = User.objects.filter(is_superuser=True, is_active=True).first() if not regular_user: self.stdout.write( self.style.ERROR( "Utilisateur régulier introuvable. Exécutez init_auth_data d'abord." ) ) return if not superuser: self.stdout.write( self.style.ERROR( "Superutilisateur introuvable. Créez un superutilisateur d'abord." ) ) return # Vérifier que l'utilisateur a un profil customer if not hasattr(regular_user, "customer"): self.stdout.write( self.style.ERROR( f"L'utilisateur {regular_user.email} n'a pas de profil client. Exécutez init_customers_data d'abord." ) ) return # Vérifier que le customer a un profil member if not hasattr(regular_user.customer, "member"): self.stdout.write( self.style.ERROR( f"Le client {regular_user.email} n'est pas encore membre. Exécutez init_members_data d'abord." ) ) return member = regular_user.customer.member # Rechercher les comptes nécessaires member_current_account = Account.objects.filter( owner=regular_user, type=Account.AccountType.CURRENT ).first() # Si pas de compte CURRENT, créer un pour les tests if not member_current_account: member_current_account = Account.objects.create( owner=regular_user, name=f"Compte Courant - {regular_user.get_full_name()}", type=Account.AccountType.CURRENT, balance=100000.00, # Solde initial de 100 000 FCFA pour pouvoir payer les parts created_by=superuser, ) self.stdout.write( self.style.SUCCESS(f"Compte courant créé pour {regular_user.email}") ) coop_share_capital_account = Account.objects.filter( owner=superuser, type=Account.AccountType.SHARE_CAPITAL ).first() if not coop_share_capital_account: self.stdout.write( self.style.ERROR( "Compte capital social de la coopérative introuvable. Exécutez initialize_cooperative_accounts d'abord." ) ) return except Exception as e: self.stdout.write( self.style.ERROR(f"Erreur lors de la récupération des données: {e}") ) return with transaction.atomic(): # Create ShareType selon les statuts de COOP-CA AMIFOND share_type_name = "Part Sociale Ordinaire COOP-CA AMIFOND" share_type_nominal_value = 10000.00 # 10 000 FCFA selon les statuts share_type, created = ShareType.objects.get_or_create( name=share_type_name, defaults={ "nominal_value": share_type_nominal_value, "created_by": superuser, }, ) if created: self.stdout.write( self.style.SUCCESS(f'ShareType "{share_type_name}" created.') ) else: self.stdout.write( self.style.WARNING(f'ShareType "{share_type_name}" already exists.') ) # Create ShareSubscription - Souscription de 3 parts (30 000 FCFA) subscribed_quantity = 3 subscription, created = ShareSubscription.objects.get_or_create( member=member, share_type=share_type, defaults={ "subscribed_quantity": subscribed_quantity, "created_by": superuser, }, ) if created: self.stdout.write( self.style.SUCCESS( f"ShareSubscription for {member.user.email} created." ) ) else: self.stdout.write( self.style.WARNING( f"ShareSubscription for {member.user.email} already exists." ) ) # Simuler un paiement de parts - Paiement de 1 part (10 000 FCFA) sur les 3 souscrites payment_quantity = 1 if subscription.paid_quantity < payment_quantity: self.stdout.write( f"Simulation d'un paiement de {payment_quantity} parts pour {member.user.email}..." ) # Vérifier que le compte a assez de fonds from decimal import Decimal payment_amount = Decimal( str(payment_quantity * share_type.nominal_value) ) if member_current_account.balance >= payment_amount: try: # Simuler le paiement en créant une transaction from apps.banking.models import Transaction, TransactionCategory transaction_obj = Transaction.objects.create( from_account=member_current_account, to_account=coop_share_capital_account, amount=payment_amount, description=f"Paiement de {payment_quantity} parts sociales", category=TransactionCategory.SHARE_PAYMENT, created_by=regular_user, ) # Mettre à jour les soldes member_current_account.balance -= payment_amount member_current_account.save() coop_share_capital_account.balance += payment_amount coop_share_capital_account.save() # Créer un objet SharePayment au lieu de modifier la propriété from apps.shares.models import SharePayment payment = SharePayment.objects.create( subscription=subscription, paid_quantity=payment_quantity, financial_transaction=transaction_obj, created_by=regular_user, ) self.stdout.write( self.style.SUCCESS( f"Paiement de {payment_quantity} parts réalisé avec succès. Transaction: {transaction_obj.id}" ) ) except Exception as e: self.stdout.write( self.style.ERROR(f"Erreur lors du paiement: {e}") ) else: self.stdout.write( self.style.WARNING( f"Fonds insuffisants dans le compte. Solde: {member_current_account.balance}, Requis: {payment_amount}" ) ) else: self.stdout.write( self.style.WARNING( f"ShareSubscription pour {member.user.email} a déjà {subscription.paid_quantity} parts payées." ) ) self.stdout.write( self.style.SUCCESS( f"\n--- Résumé ---\n" f"Type de part créé: {share_type.name} (valeur: {share_type.nominal_value} FCFA)\n" f"Souscription: {subscription.subscribed_quantity} parts souscrites ({subscription.subscribed_quantity * share_type.nominal_value} FCFA)\n" f"Paiement: {subscription.paid_quantity} parts payées ({subscription.paid_quantity * share_type.nominal_value} FCFA)\n" f"Reste à payer: {subscription.subscribed_quantity - subscription.paid_quantity} parts ({(subscription.subscribed_quantity - subscription.paid_quantity) * share_type.nominal_value} FCFA)" ) ) self.stdout.write( self.style.SUCCESS("--- Initialisation des Données de Parts Terminée ---") )