nanopy-bank 1.0.8__py3-none-any.whl

nanopy_bank/__init__.py

@@ -0,0 +1,20 @@
+"""
+NanoPy Bank - Online Banking System
+"""
+
+__version__ = "1.0.0"
+__author__ = "NanoPy Team"
+
+from .core import Account, Transaction, Customer, TransactionType, Bank, get_bank
+from .sepa import SEPAGenerator, SEPAParser
+
+__all__ = [
+    "Account",
+    "Transaction",
+    "Customer",
+    "TransactionType",
+    "Bank",
+    "get_bank",
+    "SEPAGenerator",
+    "SEPAParser",
+]

nanopy_bank/api/__init__.py

@@ -0,0 +1,10 @@
+"""
+API Module - REST API for banking operations
+"""
+
+from .server import BankAPI, run_api
+
+__all__ = [
+    "BankAPI",
+    "run_api",
+]

nanopy_bank/api/server.py

@@ -0,0 +1,242 @@
+"""
+REST API Server for NanoPy Bank
+"""
+
+from aiohttp import web
+from decimal import Decimal
+from typing import Optional
+import json
+
+from ..core import Bank, get_bank, TransactionType, AccountType, Currency
+
+
+class BankAPI:
+    """
+    REST API for banking operations
+    """
+
+    def __init__(self, bank: Optional[Bank] = None, host: str = "0.0.0.0", port: int = 8888):
+        self.bank = bank or get_bank()
+        self.host = host
+        self.port = port
+        self.app = web.Application()
+        self._setup_routes()
+
+    def _setup_routes(self):
+        """Setup API routes"""
+        # Health
+        self.app.router.add_get("/api/health", self.api_health)
+        self.app.router.add_get("/api/stats", self.api_stats)
+
+        # Customers
+        self.app.router.add_get("/api/customers", self.api_customers)
+        self.app.router.add_post("/api/customers", self.api_create_customer)
+        self.app.router.add_get("/api/customers/{customer_id}", self.api_get_customer)
+
+        # Accounts
+        self.app.router.add_get("/api/accounts", self.api_accounts)
+        self.app.router.add_post("/api/accounts", self.api_create_account)
+        self.app.router.add_get("/api/accounts/{iban}", self.api_get_account)
+        self.app.router.add_get("/api/accounts/{iban}/balance", self.api_get_balance)
+        self.app.router.add_get("/api/accounts/{iban}/transactions", self.api_get_transactions)
+
+        # Transactions
+        self.app.router.add_post("/api/credit", self.api_credit)
+        self.app.router.add_post("/api/debit", self.api_debit)
+        self.app.router.add_post("/api/transfer", self.api_transfer)
+        self.app.router.add_post("/api/sepa/credit-transfer", self.api_sepa_credit_transfer)
+
+    # ========== HEALTH ==========
+
+    async def api_health(self, request):
+        """Health check"""
+        return web.json_response({"status": "ok", "service": "nanopy-bank"})
+
+    async def api_stats(self, request):
+        """Get bank statistics"""
+        stats = self.bank.get_stats()
+        return web.json_response(stats)
+
+    # ========== CUSTOMERS ==========
+
+    async def api_customers(self, request):
+        """List all customers"""
+        customers = [c.to_dict() for c in self.bank.customers.values()]
+        return web.json_response({"customers": customers, "count": len(customers)})
+
+    async def api_create_customer(self, request):
+        """Create a new customer"""
+        try:
+            data = await request.json()
+            customer = self.bank.create_customer(
+                first_name=data["first_name"],
+                last_name=data["last_name"],
+                email=data["email"],
+                phone=data.get("phone", ""),
+                address=data.get("address", ""),
+                city=data.get("city", ""),
+                postal_code=data.get("postal_code", ""),
+                country=data.get("country", "FR")
+            )
+            return web.json_response({"ok": True, "customer": customer.to_dict()})
+        except KeyError as e:
+            return web.json_response({"error": f"Missing field: {e}"}, status=400)
+        except Exception as e:
+            return web.json_response({"error": str(e)}, status=500)
+
+    async def api_get_customer(self, request):
+        """Get customer by ID"""
+        customer_id = request.match_info["customer_id"]
+        customer = self.bank.get_customer(customer_id)
+        if not customer:
+            return web.json_response({"error": "Customer not found"}, status=404)
+        return web.json_response(customer.to_dict())
+
+    # ========== ACCOUNTS ==========
+
+    async def api_accounts(self, request):
+        """List all accounts"""
+        accounts = [a.to_dict() for a in self.bank.accounts.values()]
+        return web.json_response({"accounts": accounts, "count": len(accounts)})
+
+    async def api_create_account(self, request):
+        """Create a new account"""
+        try:
+            data = await request.json()
+            account = self.bank.create_account(
+                customer_id=data["customer_id"],
+                account_type=AccountType(data.get("account_type", "checking")),
+                currency=Currency(data.get("currency", "EUR")),
+                initial_balance=Decimal(str(data.get("initial_balance", "0.00"))),
+                overdraft_limit=Decimal(str(data.get("overdraft_limit", "0.00"))),
+                account_name=data.get("account_name", "")
+            )
+            return web.json_response({"ok": True, "account": account.to_dict()})
+        except KeyError as e:
+            return web.json_response({"error": f"Missing field: {e}"}, status=400)
+        except Exception as e:
+            return web.json_response({"error": str(e)}, status=500)
+
+    async def api_get_account(self, request):
+        """Get account by IBAN"""
+        iban = request.match_info["iban"]
+        account = self.bank.get_account(iban)
+        if not account:
+            return web.json_response({"error": "Account not found"}, status=404)
+        return web.json_response(account.to_dict())
+
+    async def api_get_balance(self, request):
+        """Get account balance"""
+        iban = request.match_info["iban"]
+        account = self.bank.get_account(iban)
+        if not account:
+            return web.json_response({"error": "Account not found"}, status=404)
+        return web.json_response({
+            "iban": account.iban,
+            "balance": str(account.balance),
+            "available_balance": str(account.available_balance),
+            "currency": account.currency.value
+        })
+
+    async def api_get_transactions(self, request):
+        """Get account transactions"""
+        iban = request.match_info["iban"]
+        limit = int(request.query.get("limit", 50))
+        transactions = self.bank.get_account_transactions(iban, limit)
+        return web.json_response({
+            "iban": iban,
+            "transactions": [tx.to_dict() for tx in transactions],
+            "count": len(transactions)
+        })
+
+    # ========== TRANSACTIONS ==========
+
+    async def api_credit(self, request):
+        """Credit an account"""
+        try:
+            data = await request.json()
+            tx = self.bank.credit(
+                iban=data["iban"],
+                amount=Decimal(str(data["amount"])),
+                label=data["label"],
+                counterparty_name=data.get("counterparty_name", ""),
+                counterparty_iban=data.get("counterparty_iban", ""),
+                description=data.get("description", ""),
+                category=data.get("category", "")
+            )
+            return web.json_response({"ok": True, "transaction": tx.to_dict()})
+        except KeyError as e:
+            return web.json_response({"error": f"Missing field: {e}"}, status=400)
+        except Exception as e:
+            return web.json_response({"error": str(e)}, status=400)
+
+    async def api_debit(self, request):
+        """Debit an account"""
+        try:
+            data = await request.json()
+            tx = self.bank.debit(
+                iban=data["iban"],
+                amount=Decimal(str(data["amount"])),
+                label=data["label"],
+                counterparty_name=data.get("counterparty_name", ""),
+                counterparty_iban=data.get("counterparty_iban", ""),
+                description=data.get("description", ""),
+                category=data.get("category", "")
+            )
+            return web.json_response({"ok": True, "transaction": tx.to_dict()})
+        except KeyError as e:
+            return web.json_response({"error": f"Missing field: {e}"}, status=400)
+        except Exception as e:
+            return web.json_response({"error": str(e)}, status=400)
+
+    async def api_transfer(self, request):
+        """Transfer between accounts"""
+        try:
+            data = await request.json()
+            debit_tx, credit_tx = self.bank.transfer(
+                from_iban=data["from_iban"],
+                to_iban=data["to_iban"],
+                amount=Decimal(str(data["amount"])),
+                label=data["label"],
+                description=data.get("description", "")
+            )
+            return web.json_response({
+                "ok": True,
+                "debit_transaction": debit_tx.to_dict(),
+                "credit_transaction": credit_tx.to_dict() if credit_tx else None
+            })
+        except KeyError as e:
+            return web.json_response({"error": f"Missing field: {e}"}, status=400)
+        except Exception as e:
+            return web.json_response({"error": str(e)}, status=400)
+
+    async def api_sepa_credit_transfer(self, request):
+        """Execute SEPA Credit Transfer"""
+        try:
+            data = await request.json()
+            tx = self.bank.sepa_credit_transfer(
+                from_iban=data["from_iban"],
+                to_iban=data["to_iban"],
+                to_bic=data.get("to_bic", ""),
+                to_name=data["to_name"],
+                amount=Decimal(str(data["amount"])),
+                label=data["label"],
+                end_to_end_id=data.get("end_to_end_id", "")
+            )
+            return web.json_response({"ok": True, "transaction": tx.to_dict()})
+        except KeyError as e:
+            return web.json_response({"error": f"Missing field: {e}"}, status=400)
+        except Exception as e:
+            return web.json_response({"error": str(e)}, status=400)
+
+    def run(self):
+        """Run the API server"""
+        print(f"Starting NanoPy Bank API on http://{self.host}:{self.port}")
+        web.run_app(self.app, host=self.host, port=self.port, print=None)
+
+
+def run_api(host: str = "0.0.0.0", port: int = 8888, data_dir: str = None):
+    """Run the API server"""
+    bank = get_bank(data_dir)
+    api = BankAPI(bank, host, port)
+    api.run()

nanopy_bank/app.py

@@ -0,0 +1,282 @@
+"""
+NanoPy Bank - Streamlit UI with shadcn components
+"""
+
+import streamlit as st
+from streamlit_option_menu import option_menu
+
+try:
+    from .core import get_bank
+    from .core.auth import get_auth_service, UserRole
+    from .ui.pages import (
+        render_dashboard, render_accounts, render_transfers,
+        render_beneficiaries, render_cards, render_loans,
+        render_fees, render_branches, render_sepa,
+        render_audit, render_settings, render_advisor, render_holding
+    )
+    from .ui.pages.login import render_login
+except ImportError:
+    from nanopy_bank.core import get_bank
+    from nanopy_bank.core.auth import get_auth_service, UserRole
+    from nanopy_bank.ui.pages import (
+        render_dashboard, render_accounts, render_transfers,
+        render_beneficiaries, render_cards, render_loans,
+        render_fees, render_branches, render_sepa,
+        render_audit, render_settings, render_advisor, render_holding
+    )
+    from nanopy_bank.ui.pages.login import render_login
+
+
+# Page config
+st.set_page_config(
+    page_title="NanoPy Bank",
+    page_icon="🏦",
+    layout="wide",
+    initial_sidebar_state="expanded"
+)
+
+# Custom CSS
+st.markdown("""
+<style>
+    .stApp {
+        background: linear-gradient(135deg, #1a1a2e 0%, #16213e 100%);
+    }
+    .main-header {
+        background: linear-gradient(90deg, #00d4ff, #7b2cbf);
+        -webkit-background-clip: text;
+        -webkit-text-fill-color: transparent;
+        font-size: 2.5rem;
+        font-weight: bold;
+        margin-bottom: 2rem;
+    }
+    .user-badge {
+        background: linear-gradient(135deg, #1e3a5f, #2d1b4e);
+        padding: 10px 15px;
+        border-radius: 10px;
+        margin-bottom: 15px;
+    }
+</style>
+""", unsafe_allow_html=True)
+
+
+def init_session_state():
+    """Initialize session state"""
+    if "bank" not in st.session_state:
+        st.session_state.bank = get_bank()
+    if "current_account" not in st.session_state:
+        st.session_state.current_account = None
+    if "current_customer" not in st.session_state:
+        st.session_state.current_customer = None
+    if "logged_in" not in st.session_state:
+        st.session_state.logged_in = False
+    if "user" not in st.session_state:
+        st.session_state.user = None
+    if "session_id" not in st.session_state:
+        st.session_state.session_id = None
+
+
+def logout():
+    """Logout user"""
+    if st.session_state.session_id:
+        auth = get_auth_service()
+        auth.logout(st.session_state.session_id)
+    st.session_state.logged_in = False
+    st.session_state.user = None
+    st.session_state.session_id = None
+    st.rerun()
+
+
+def get_role_label(role: UserRole) -> str:
+    """Get French label for role"""
+    labels = {
+        UserRole.CLIENT: "Client",
+        UserRole.ADVISOR: "Conseiller",
+        UserRole.DIRECTOR: "Directeur",
+        UserRole.ADMIN: "Administrateur",
+        UserRole.HOLDING: "Holding",
+    }
+    return labels.get(role, "Utilisateur")
+
+
+def get_role_color(role: UserRole) -> str:
+    """Get color for role"""
+    colors = {
+        UserRole.CLIENT: "#00d4ff",
+        UserRole.ADVISOR: "#7b2cbf",
+        UserRole.DIRECTOR: "#ff6b6b",
+        UserRole.ADMIN: "#ffd93d",
+        UserRole.HOLDING: "#00ff88",
+    }
+    return colors.get(role, "#888888")
+
+
+def render_sidebar():
+    """Render sidebar navigation based on user role"""
+    user = st.session_state.user
+    role = user.role if user else UserRole.CLIENT
+
+    with st.sidebar:
+        # Logo
+        st.markdown("""
+        <div style="display: flex; align-items: center; gap: 12px; margin-bottom: 20px;">
+            <svg xmlns="http://www.w3.org/2000/svg" width="32" height="32" viewBox="0 0 24 24" fill="none" stroke="#00d4ff" stroke-width="2">
+                <rect x="1" y="4" width="22" height="16" rx="2" ry="2"></rect>
+                <line x1="1" y1="10" x2="23" y2="10"></line>
+            </svg>
+            <span style="font-size: 1.5rem; font-weight: bold; background: linear-gradient(90deg, #00d4ff, #7b2cbf); -webkit-background-clip: text; -webkit-text-fill-color: transparent;">NanoPy Bank</span>
+        </div>
+        """, unsafe_allow_html=True)
+
+        # User info
+        role_color = get_role_color(role)
+        st.markdown(f"""
+        <div class="user-badge">
+            <div style="font-size: 14px; font-weight: bold; color: white;">{user.display_name}</div>
+            <div style="font-size: 12px; color: {role_color};">{get_role_label(role)}</div>
+        </div>
+        """, unsafe_allow_html=True)
+
+        # Logout button
+        if st.button("Deconnexion", use_container_width=True):
+            logout()
+
+        st.divider()
+
+        page = None
+        page2 = None
+        page3 = None
+
+        # Holding user - only sees Group menu
+        if role == UserRole.HOLDING:
+            st.markdown("##### Espace Groupe")
+            page3 = option_menu(
+                menu_title=None,
+                options=["Tableau de bord", "Tresorerie", "Investissements", "Assurances", "Filiales", "Consolidation", "Risques", "Gouvernance"],
+                icons=["speedometer2", "bank", "graph-up-arrow", "shield", "building", "bar-chart", "shield-exclamation", "people"],
+                default_index=0,
+                key="menu3",
+                styles={
+                    "container": {"padding": "0!important", "background-color": "transparent"},
+                    "icon": {"color": "#00ff88", "font-size": "16px"},
+                    "nav-link": {"font-size": "13px", "text-align": "left", "margin": "2px 0", "padding": "8px 10px", "--hover-color": "#1e1e2f", "border-radius": "6px"},
+                    "nav-link-selected": {"background-color": "#1b4e2d", "color": "#00ff88"},
+                }
+            )
+        else:
+            # Client menu - visible to CLIENT, ADVISOR, DIRECTOR, ADMIN
+            st.markdown("##### Espace Client")
+            page = option_menu(
+                menu_title=None,
+                options=["Dashboard", "Comptes", "Virements", "Beneficiaires", "Cartes", "Credits", "Frais", "SEPA"],
+                icons=["speedometer2", "wallet2", "arrow-left-right", "people", "credit-card", "cash-stack", "percent", "file-earmark-code"],
+                default_index=0,
+                styles={
+                    "container": {"padding": "0!important", "background-color": "transparent"},
+                    "icon": {"color": "#00d4ff", "font-size": "16px"},
+                    "nav-link": {"font-size": "13px", "text-align": "left", "margin": "2px 0", "padding": "8px 10px", "--hover-color": "#1e1e2f", "border-radius": "6px"},
+                    "nav-link-selected": {"background-color": "#1e3a5f", "color": "#00d4ff"},
+                }
+            )
+
+            # Bank menu - visible to ADVISOR and above (but not HOLDING)
+            if user.can_access(UserRole.ADVISOR) and role != UserRole.HOLDING:
+                st.divider()
+                st.markdown("##### Espace Banque")
+
+                bank_options = ["Conseiller"]
+                bank_icons = ["person-badge"]
+
+                if user.can_access(UserRole.DIRECTOR):
+                    bank_options.extend(["Agences", "Audit"])
+                    bank_icons.extend(["building", "shield-check"])
+
+                if user.can_access(UserRole.ADMIN):
+                    bank_options.append("Administration")
+                    bank_icons.append("gear")
+
+                page2 = option_menu(
+                    menu_title=None,
+                    options=bank_options,
+                    icons=bank_icons,
+                    default_index=0,
+                    key="menu2",
+                    styles={
+                        "container": {"padding": "0!important", "background-color": "transparent"},
+                        "icon": {"color": "#7b2cbf", "font-size": "16px"},
+                        "nav-link": {"font-size": "13px", "text-align": "left", "margin": "2px 0", "padding": "8px 10px", "--hover-color": "#1e1e2f", "border-radius": "6px"},
+                        "nav-link-selected": {"background-color": "#2d1b4e", "color": "#7b2cbf"},
+                    }
+                )
+
+        st.divider()
+
+        # Quick stats
+        bank = st.session_state.bank
+        stats = bank.get_stats()
+        col1, col2 = st.columns(2)
+        with col1:
+            st.metric("Comptes", stats["total_accounts"])
+        with col2:
+            st.metric("Transactions", stats["total_transactions"])
+
+        return page, page2, page3
+
+
+def main():
+    """Main app entry point"""
+    init_session_state()
+
+    # Check if logged in
+    if not st.session_state.logged_in:
+        render_login()
+        return
+
+    page, page2, page3 = render_sidebar()
+    user = st.session_state.user
+
+    # Map French menu to render functions
+    client_pages = {
+        "Dashboard": render_dashboard,
+        "Comptes": render_accounts,
+        "Virements": render_transfers,
+        "Beneficiaires": render_beneficiaries,
+        "Cartes": render_cards,
+        "Credits": render_loans,
+        "Frais": render_fees,
+        "SEPA": render_sepa,
+    }
+
+    bank_pages = {
+        "Conseiller": render_advisor,
+        "Agences": render_branches,
+        "Audit": render_audit,
+        "Administration": render_settings,
+    }
+
+    # Holding has separate pages per tab
+    group_pages = {
+        "Tableau de bord": "dashboard",
+        "Tresorerie": "tresorerie",
+        "Investissements": "investissements",
+        "Assurances": "assurances",
+        "Filiales": "filiales",
+        "Consolidation": "consolidation",
+        "Risques": "risques",
+        "Gouvernance": "gouvernance",
+    }
+
+    # Determine active page from menus
+    active_page = None
+    if page3 and page3 in group_pages:
+        # Holding user - render holding page with selected tab
+        render_holding(tab=group_pages[page3])
+    elif page2 and page2 in bank_pages:
+        active_page = page2
+        bank_pages[active_page]()
+    elif page and page in client_pages:
+        active_page = page
+        client_pages[active_page]()
+
+
+if __name__ == "__main__":
+    main()