Update app/bank.py

app/bank.py

@@ -1,102 +1,360 @@
-# bank.py
-# functionen für die Community Bank
 from flask import jsonify
-import logging
-import datetime
-import random
-
 from datetime import datetime, timedelta
 
 class BankAccount:
     def __init__(self, user_id, balance=0.0, interest_rate=0.0):
-        """Initialisiert ein neues Bankkonto für den Benutzer."""
+        if not isinstance(user_id, (int, str)):
+            raise ValueError("user_id muss eine Zahl oder String sein")
+        if balance < 0:
+            raise ValueError("Startguthaben kann nicht negativ sein")
+        
         self.user_id = user_id
-        self.balance = balance
-        self.interest_rate = interest_rate  # z.B. 0.05 für 5% Zinsen, -0.05 für -5% (negative Zinsen)
+        self.balance = float(balance)
+        self.interest_rate = float(interest_rate)
         self.last_interest_time = datetime.now()
+        self.transaction_history = []
+
+    def add_transaction(self, transaction_type, amount, description=""):
+        transaction = {
+            "timestamp": datetime.now(),
+            "type": transaction_type,
+            "amount": amount,
+            "balance_after": self.balance,
+            "description": description
+        }
+        self.transaction_history.append(transaction)
 
     def deposit(self, amount):
-        """Funktion zum Einzahlen auf das Konto."""
         if amount <= 0:
             raise ValueError("Einzahlungsbetrag muss positiv sein.")
         self.balance += amount
+        self.add_transaction("deposit", amount)
         return self.balance
 
     def withdraw(self, amount):
-        """Funktion zum Abheben vom Konto."""
         if amount <= 0:
             raise ValueError("Abhebungsbetrag muss positiv sein.")
         if amount > self.balance:
             raise ValueError("Nicht genügend Geld auf dem Konto.")
         self.balance -= amount
+        self.add_transaction("withdraw", amount)
         return self.balance
 
     def apply_interest(self):
-        """Berechnet die Zinsen und fügt sie dem Konto hinzu (positive oder negative Zinsen)."""
         current_time = datetime.now()
         time_difference = current_time - self.last_interest_time
-
-        # Zinsen werden z.B. täglich angewendet (kann angepasst werden)
+        
         if time_difference >= timedelta(days=1):
             days_passed = time_difference.days
-            # Zinsen anwenden für jeden Tag, der seit der letzten Berechnung vergangen ist
-            for _ in range(days_passed):
-                self.balance += self.balance * self.interest_rate
+            old_balance = self.balance
+            self.balance *= (1 + self.interest_rate) ** days_passed
+            interest_earned = self.balance - old_balance
+            
+            self.add_transaction("interest", interest_earned, 
+                               f"Zinsen für {days_passed} Tage")
             self.last_interest_time = current_time
+        
         return self.balance
 
     def get_balance(self):
-        """Gibt den aktuellen Kontostand zurück (nach Zinsberechnung)."""
         self.apply_interest()
         return self.balance
 
+    def get_transaction_history(self):
+        return self.transaction_history
 
-# Beispiel für die Verwendung der Klassen und Funktionen
-#if __name__ == "__main__":
-    # Erstellen eines Kontos für einen Spieler mit 100 Einheiten und 5% Zinsen
-  #  player_account = BankAccount(user_id=12345, balance=100.0, interest_rate=0.05)
-
-    # Einzahlung
-  #  player_account.deposit(50)
-  #  print(f"Neuer Kontostand nach Einzahlung: {player_account.get_balance()}")
+    def transfer(self, target_account, amount):
+        if not isinstance(target_account, BankAccount):
+            raise ValueError("Ungültiges Zielkonto")
+        self.withdraw(amount)
+        target_account.deposit(amount)
+        self.add_transaction("transfer_out", amount, f"Transfer an {target_account.user_id}")
+        target_account.add_transaction("transfer_in", amount, f"Transfer von {self.user_id}")
 
-    # Abheben
- #   player_account.withdraw(30)
- #   print(f"Neuer Kontostand nach Abhebung: {player_account.get_balance()}")
+    def format_balance(self):
+        return f"{self.balance:,.2f} Credits"
 
-    # Zinsen anwenden (nur zur Demonstration, normalerweise täglich automatisch)
- #   player_account.apply_interest()
-  #  print(f"Kontostand nach Zinsanwendung: {player_account.get_balance()}")
+class BankSystem:
+    def __init__(self):
+        self.accounts = {}
+        
+    def create_account(self, user_id, initial_balance=0.0, interest_rate=0.05):
+        if user_id in self.accounts:
+            raise ValueError("Konto existiert bereits")
+        account = BankAccount(user_id, initial_balance, interest_rate)
+        self.accounts[user_id] = account
+        return account
+    
+    def get_account(self, user_id):
+        return self.accounts.get(user_id)
+    
+    def transfer_between_accounts(self, from_user_id, to_user_id, amount):
+        from_account = self.get_account(from_user_id)
+        to_account = self.get_account(to_user_id)
+        if not from_account or not to_account:
+            raise ValueError("Ein oder beide Konten existieren nicht")
+        from_account.transfer(to_account, amount)
 
-# b) /send Money to user
 def send_money_command(from_user_id, to_user_id, amount):
     if amount <= 0:
         return jsonify({"type": 4, "data": {"content": "Ungültiger Betrag!"}})
     
-    # Überprüfe, ob der Absender genug Credits hat
-    from_user_data = get_user_data(from_user_id)
-    if from_user_data['credits'] < amount:
-        return jsonify({"type": 4, "data": {"content": "Nicht genug Credits!"}})
-    
-    # Transaktion durchführen
-    update_user_data(from_user_id, {'credits': from_user_data['credits'] - amount})
-    to_user_data = get_user_data(to_user_id)
-    update_user_data(to_user_id, {'credits': to_user_data['credits'] + amount})
+    try:
+        # Überprüfe, ob der Absender genug Credits hat
+        from_user_data = get_user_data(from_user_id)
+        if from_user_data['credits'] < amount:
+            return jsonify({"type": 4, "data": {"content": "Nicht genug Credits!"}})
+        
+        # Transaktion durchführen
+        update_user_data(from_user_id, {'credits': from_user_data['credits'] - amount})
+        to_user_data = get_user_data(to_user_id)
+        update_user_data(to_user_id, {'credits': to_user_data['credits'] + amount})
+        
+        # Transaktion in History dokumentieren
+        transaction_time = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        log_transaction(from_user_id, to_user_id, amount, transaction_time)
+        
+        return jsonify({
+            "type": 4, 
+            "data": {
+                "content": f"Erfolgreich {amount:,.2f} Credits an den Benutzer {to_user_id} gesendet!"
+            }
+        })
     
-    return jsonify({"type": 4, "data": {"content": f"Erfolgreich {amount} Credits an den Benutzer gesendet!"}})
-    
-# c) /daily (Tägliche Belohnung)
+    except Exception as e:
+        logging.error(f"Fehler bei der Überweisung: {str(e)}")
+        return jsonify({
+            "type": 4, 
+            "data": {
+                "content": "Ein Fehler ist bei der Überweisung aufgetreten!"
+            }
+        })
+
 def daily_reward(user_id):
     """Gives daily reward of 100 credits to the user"""
-    user_data = get_user_data(user_id)
-    last_claimed = user_data.get('last_claimed', None)
+    try:
+        user_data = get_user_data(user_id)
+        last_claimed = user_data.get('last_claimed', None)
+        
+        if last_claimed:
+            last_claimed_date = datetime.fromisoformat(str(last_claimed))
+            if last_claimed_date.date() == datetime.now().date():
+                return jsonify({
+                    "type": 4, 
+                    "data": {
+                        "content": "Du hast bereits deine tägliche Belohnung erhalten!"
+                    }
+                })
+        
+        # Zufällige Belohnung zwischen 50 und 150 Credits
+        reward_amount = random.randint(50, 150)
+        new_credits = user_data.get('credits', 0) + reward_amount
+        
+        # Update user data
+        update_user_data(user_id, {
+            'credits': new_credits,
+            'last_claimed': datetime.now()
+        })
+        
+        return jsonify({
+            "type": 4,
+            "data": {
+                "content": f"Du hast deine tägliche Belohnung erhalten: {reward_amount} Credits!"
+            }
+        })
+    
+    except Exception as e:
+        logging.error(f"Fehler bei der täglichen Belohnung: {str(e)}")
+        return jsonify({
+            "type": 4,
+            "data": {
+                "content": "Ein Fehler ist beim Abholen der täglichen Belohnung aufgetreten!"
+            }
+        })
+
+# Hilfsfunktionen (müssen implementiert werden)
+def get_user_data(user_id):
+    """Implementiere diese Funktion, um Benutzerdaten aus der Datenbank zu holen"""
+    pass
+
+def update_user_data(user_id, data):
+    """Implementiere diese Funktion, um Benutzerdaten in der Datenbank zu aktualisieren"""
+    pass
+def log_transaction(from_user_id, to_user_id, amount, timestamp):
+    """Implementiere diese Funktion, um Transaktionen in einem Log festzuhalten"""
+    try:
+        transaction_log = {
+            "from_user": from_user_id,
+            "to_user": to_user_id,
+            "amount": amount,
+            "timestamp": timestamp,
+            "transaction_id": generate_transaction_id()
+        }
+        
+        # Hier könnte die Speicherung in einer Datenbank erfolgen
+        save_transaction_to_db(transaction_log)
+        
+        logging.info(f"Transaktion erfolgreich protokolliert: {transaction_log}")
+        return True
+    
+    except Exception as e:
+        logging.error(f"Fehler beim Protokollieren der Transaktion: {str(e)}")
+        return False
+
+def generate_transaction_id():
+    """Generiert eine einzigartige Transaktions-ID"""
+    timestamp = datetime.now().strftime('%Y%m%d%H%M%S')
+    random_suffix = ''.join(random.choices('0123456789ABCDEF', k=6))
+    return f"TRX-{timestamp}-{random_suffix}"
+
+def save_transaction_to_db(transaction_data):
+    """Implementiere diese Funktion zur Speicherung in der Datenbank"""
+    pass
+
+def get_user_transaction_history(user_id):
+    """Gibt die Transaktionshistorie eines Benutzers zurück"""
+    try:
+        # Implementiere hier die Datenbankabfrage
+        transactions = []  # Hole Transaktionen aus der Datenbank
+        return jsonify({
+            "type": 4,
+            "data": {
+                "content": "Transaktionshistorie",
+                "transactions": transactions
+            }
+        })
+    except Exception as e:
+        logging.error(f"Fehler beim Abrufen der Transaktionshistorie: {str(e)}")
+        return jsonify({
+            "type": 4,
+            "data": {
+                "content": "Fehler beim Abrufen der Transaktionshistorie"
+            }
+        })
+
+def check_account_status(user_id):
+    """Überprüft den Status eines Bankkontos"""
+    try:
+        user_data = get_user_data(user_id)
+        account = BankAccount(user_id, user_data.get('credits', 0))
+        
+        status_info = {
+            "balance": account.format_balance(),
+            "last_transaction": user_data.get('last_transaction'),
+            "account_age": calculate_account_age(user_data.get('created_at')),
+            "interest_rate": f"{account.interest_rate * 100}%"
+        }
+        
+        return jsonify({
+            "type": 4,
+            "data": {
+                "content": "Kontostatus",
+                "status": status_info
+            }
+        })
+    except Exception as e:
+        logging.error(f"Fehler beim Abrufen des Kontostatus: {str(e)}")
+        return jsonify({
+            "type": 4,
+            "data": {
+                "content": "Fehler beim Abrufen des Kontostatus"
+            }
+        })
+
+def calculate_account_age(created_at):
+    """Berechnet das Alter eines Kontos"""
+    if not created_at:
+        return "Unbekannt"
+    
+    created_date = datetime.fromisoformat(str(created_at))
+    age = datetime.now() - created_date
+    return f"{age.days} Tage"
+
+# Error Handler
+def handle_transaction_error(error_type, message):
+    """Zentrale Fehlerbehandlung für Transaktionen"""
+    logging.error(f"Transaktionsfehler: {error_type} - {message}")
+    return jsonify({
+        "type": 4,
+        "data": {
+            "content": f"Ein Fehler ist aufgetreten: {message}",
+            "error_type": error_type,
+            "timestamp": datetime.now().isoformat()
+        }
+    })
+
+class TransactionError(Exception):
+    """Benutzerdefinierte Exception für Transaktionsfehler"""
+    def __init__(self, message, error_type="TRANSACTION_ERROR"):
+        self.message = message
+        self.error_type = error_type
+        super().__init__(self.message)
+
+# Hilfreiche Utility-Funktionen
+def validate_transaction(from_user_id, to_user_id, amount):
+    """Überprüft, ob eine Transaktion gültig ist"""
+    if from_user_id == to_user_id:
+        raise TransactionError("Selbstüberweisung nicht möglich", "SELF_TRANSACTION_ERROR")
     
-    if last_claimed:
-        if last_claimed.date() == datetime.datetime.now().date():
-            return jsonify({"type": 4, "data": {"content": "Du hast bereits deine tägliche Belohnung erhalten!"}})
+    if amount <= 0:
+        raise TransactionError("Ungültiger Betrag", "INVALID_AMOUNT_ERROR")
     
-    # Tägliche Belohnung vergeben
-    new_credits = user_data.get('credits', 0) + 100  # Beispiel für eine tägliche Belohnung
-    update_user_data(user_id, {'credits': new_credits, 'last_claimed': datetime.datetime.now()})
+    if not isinstance(amount, (int, float)):
+        raise TransactionError("Betrag muss eine Zahl sein", "INVALID_TYPE_ERROR")
     
-    return jsonify({"type": 4, "data": {"content": "Du hast deine tägliche Belohnung erhalten: 100 Credits!"}})
+    return True
+
+def format_currency(amount):
+    """Formatiert einen Geldbetrag"""
+    return f"{amount:,.2f} Credits"
+
+def get_account_summary(user_id):
+    """Erstellt eine Zusammenfassung des Kontos"""
+    try:
+        account = get_user_data(user_id)
+        if not account:
+            raise TransactionError("Konto nicht gefunden", "ACCOUNT_NOT_FOUND")
+        
+        return {
+            "user_id": user_id,
+            "balance": format_currency(account.get('credits', 0)),
+            "last_transaction": account.get('last_transaction'),
+            "account_status": "aktiv" if account.get('is_active', True) else "inaktiv",
+            "created_at": account.get('created_at'),
+            "last_daily_claim": account.get('last_claimed')
+        }
+    except Exception as e:
+        logging.error(f"Fehler beim Erstellen der Kontozusammenfassung: {str(e)}")
+        raise
+
+# Initialisierung des Logging-Systems
+def setup_logging():
+    """Konfiguriert das Logging-System"""
+    logging.basicConfig(
+        level=logging.INFO,
+        format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+        handlers=[
+            logging.FileHandler('bank_transactions.log'),
+            logging.StreamHandler()
+        ]
+    )
+
+# Hauptfunktion zum Starten des Bank-Systems
+def initialize_bank_system():
+    """Initialisiert das Bank-System"""
+    try:
+        setup_logging()
+        logging.info("Bank-System wird gestartet...")
+        bank_system = BankSystem()
+        logging.info("Bank-System erfolgreich initialisiert")
+        return bank_system
+    except Exception as e:
+        logging.error(f"Fehler beim Initialisieren des Bank-Systems: {str(e)}")
+        raise
+
+if __name__ == "__main__":
+    try:
+        bank_system = initialize_bank_system()
+        logging.info("Bank-System läuft und ist bereit")
+    except Exception as e:
+        logging.critical(f"Kritischer Fehler beim Starten des Bank-Systems: {str(e)}")