added app files

Author: leoBitto

app/__init__.py

@@ -1,15 +1,41 @@
-from flask import Flask, render_template
-import pandas as pd
+ app/__init__.py
+from flask import Flask
+from flask_login import LoginManager
+import os
 
 def create_app():
     app = Flask(__name__)
-
-    @app.route("/")
-    def index():
-        df = pd.DataFrame({
-            "date": pd.date_range(end=pd.Timestamp.today(), periods=10),
-            "price": range(100, 110)
-        })
-        return render_template("index.html", data=df.to_dict(orient="records"))
-
+    app.config['SECRET_KEY'] = os.environ.get('SECRET_KEY', 'dev-key-change-in-production')
+    
+    # Login Manager setup
+    login_manager = LoginManager()
+    login_manager.init_app(app)
+    login_manager.login_view = 'auth.login'
+    login_manager.login_message = 'Please log in to access the trading dashboard.'
+    login_manager.login_message_category = 'info'
+    
+    @login_manager.user_loader
+    def load_user(user_id):
+        from app.auth import User
+        return User.get(user_id)
+    
+    # Register Blueprints
+    from app.routes.main import main_bp
+    from app.routes.portfolio import portfolio_bp
+    from app.routes.signals import signals_bp
+    from app.routes.backtest import backtest_bp
+    from app.routes.query import query_bp
+    from app.routes.admin import admin_bp
+    from app.routes.api import api_bp
+    from app.routes.auth import auth_bp
+    
+    app.register_blueprint(main_bp)
+    app.register_blueprint(portfolio_bp, url_prefix='/portfolio')
+    app.register_blueprint(signals_bp, url_prefix='/signals')
+    app.register_blueprint(backtest_bp, url_prefix='/backtest')
+    app.register_blueprint(query_bp, url_prefix='/query')
+    app.register_blueprint(admin_bp, url_prefix='/admin')
+    app.register_blueprint(api_bp, url_prefix='/api')
+    app.register_blueprint(auth_bp, url_prefix='/auth')
+    
     return app

app/auth.py

@@ -0,0 +1,44 @@
+# app/auth.py
+"""
+Semplice sistema di autenticazione con password hash.
+In produzione, considera di usare un database per gli utenti.
+"""
+import hashlib
+import os
+from flask_login import UserMixin
+
+class User(UserMixin):
+    def __init__(self, username):
+        self.id = username
+        self.username = username
+    
+    @staticmethod
+    def get(username):
+        # Lista utenti hardcoded - in produzione usare DB
+        valid_users = ['admin', 'trader', 'analyst']
+        if username in valid_users:
+            return User(username)
+        return None
+    
+    @staticmethod
+    def authenticate(username, password):
+        """
+        Autentica utente con password.
+        Password di default: 'trading123' (cambiarla in produzione!)
+        """
+        user = User.get(username)
+        if not user:
+            return None
+        
+        # Hash della password con salt
+        salt = os.environ.get('PASSWORD_SALT', 'default_salt_change_me')
+        expected_hash = hashlib.sha256((password + salt).encode()).hexdigest()
+        
+        # Password di default per tutti gli utenti (in produzione: DB lookup)
+        default_password = 'trading123'
+        default_hash = hashlib.sha256((default_password + salt).encode()).hexdigest()
+        
+        if expected_hash == default_hash:
+            return user
+        
+        return None

app/routes.py

@@ -0,0 +1,45 @@
+# app/routes/admin.py
+from flask import Blueprint, render_template, jsonify
+from flask_login import login_required
+
+from scripts.database import execute_query
+from scripts.portfolio import create_portfolio_tables
+
+admin_bp = Blueprint('admin', __name__)
+
+@admin_bp.route('/')
+@login_required
+def index():
+    """Pagina amministrativa per gestione sistema"""
+    try:
+        # Statistiche database
+        stats_queries = {
+            'total_records': "SELECT COUNT(*) FROM universe",
+            'unique_tickers': "SELECT COUNT(DISTINCT ticker) FROM universe",
+            'date_range': "SELECT MIN(date), MAX(date) FROM universe",
+            'last_update': "SELECT MAX(date) FROM universe",
+            'portfolios_count': "SELECT COUNT(DISTINCT portfolio_name) FROM portfolio_snapshots"
+        }
+        
+        stats = {}
+        for stat_name, query in stats_queries.items():
+            try:
+                result = execute_query(query)
+                stats[stat_name] = result[0] if result else None
+            except:
+                stats[stat_name] = "Error"
+        
+        return render_template("admin/index.html", stats=stats)
+    
+    except Exception as e:
+        return render_template("admin/index.html", error=str(e))
+
+@admin_bp.route('/init_portfolio_tables', methods=['POST'])
+@login_required
+def init_portfolio_tables():
+    """Inizializza tabelle portfolio"""
+    try:
+        create_portfolio_tables()
+        return jsonify({'success': True, 'message': 'Portfolio tables initialized'})
+    except Exception as e:
+        return jsonify({'error': str(e)}), 400

app/routes/admin.py

@@ -0,0 +1,53 @@
+# app/routes/api.py
+from flask import Blueprint, jsonify, request
+from flask_login import login_required
+from datetime import datetime, timedelta
+
+from scripts.database import get_universe_data, get_available_tickers
+
+api_bp = Blueprint('api', __name__)
+
+@api_bp.route('/ticker/<ticker>/chart')
+@login_required
+def ticker_chart_data(ticker):
+    """API per dati chart di un singolo ticker"""
+    try:
+        days = int(request.args.get('days', 30))
+        end_date = datetime.now().strftime('%Y-%m-%d')
+        start_date = (datetime.now() - timedelta(days=days)).strftime('%Y-%m-%d')
+        
+        df = get_universe_data(start_date=start_date, end_date=end_date, tickers=[ticker])
+        
+        if df.empty:
+            return jsonify({'error': f'No data for {ticker}'}), 404
+        
+        chart_data = [
+            {
+                'date': row['date'].strftime('%Y-%m-%d'),
+                'open': row['Open'],
+                'high': row['High'],
+                'low': row['Low'],
+                'close': row['Close'],
+                'volume': row['Volume']
+            }
+            for _, row in df.iterrows()
+        ]
+        
+        return jsonify({'data': chart_data, 'ticker': ticker})
+    
+    except Exception as e:
+        return jsonify({'error': str(e)}), 400
+
+@api_bp.route('/tickers/search')
+@login_required
+def search_tickers():
+    """API per ricerca tickers"""
+    query = request.args.get('q', '').upper()
+    all_tickers = get_available_tickers()
+    
+    if query:
+        filtered = [t for t in all_tickers if query in t]
+    else:
+        filtered = all_tickers[:20]  # Prime 20
+    
+    return jsonify({'tickers': filtered})

app/routes/api.py

@@ -0,0 +1,38 @@
+# app/routes/auth.py
+from flask import Blueprint, render_template, request, redirect, url_for, flash
+from flask_login import login_user, logout_user, login_required, current_user
+from app.auth import User
+
+auth_bp = Blueprint('auth', __name__)
+
+@auth_bp.route('/login', methods=['GET', 'POST'])
+def login():
+    if current_user.is_authenticated:
+        return redirect(url_for('main.index'))
+    
+    if request.method == 'POST':
+        username = request.form.get('username', '').strip().lower()
+        password = request.form.get('password', '')
+        remember = bool(request.form.get('remember'))
+        
+        if not username or not password:
+            flash('Username and password are required.', 'danger')
+            return render_template('auth/login.html')
+        
+        user = User.authenticate(username, password)
+        if user:
+            login_user(user, remember=remember)
+            next_page = request.args.get('next')
+            flash(f'Welcome back, {username}!', 'success')
+            return redirect(next_page or url_for('main.index'))
+        else:
+            flash('Invalid username or password.', 'danger')
+    
+    return render_template('auth/login.html')
+
+@auth_bp.route('/logout')
+@login_required
+def logout():
+    logout_user()
+    flash('You have been logged out.', 'info')
+    return redirect(url_for('auth.login'))

app/routes/auth.py

@@ -0,0 +1,85 @@
+# app/routes/backtest.py
+from flask import Blueprint, render_template, request, jsonify
+from flask_login import login_required
+
+from scripts.database import get_available_tickers
+from scripts import strategies
+from scripts.config import DEFAULT_STRATEGY_PARAMS
+from scripts.backtest import run_backtest
+
+backtest_bp = Blueprint('backtest', __name__)
+
+@backtest_bp.route('/')
+@login_required
+def index():
+    """Pagina per eseguire backtest"""
+    try:
+        # Strategie disponibili
+        strategy_functions = []
+        for name in dir(strategies):
+            if not name.startswith('_') and callable(getattr(strategies, name)):
+                strategy_functions.append(name)
+        
+        tickers = get_available_tickers()
+        
+        return render_template("backtest/index.html",
+                             strategies=strategy_functions,
+                             tickers=tickers,
+                             default_params=DEFAULT_STRATEGY_PARAMS)
+    
+    except Exception as e:
+        return render_template("backtest/index.html", error=str(e))
+
+@backtest_bp.route('/run', methods=['POST'])
+@login_required
+def run_backtest_route():
+    """Esegue backtest di una strategia"""
+    try:
+        strategy_name = request.form.get('strategy')
+        start_date = request.form.get('start_date')
+        end_date = request.form.get('end_date')
+        selected_tickers = request.form.getlist('tickers')
+        initial_capital = float(request.form.get('initial_capital', 100000))
+        
+        if not all([strategy_name, start_date, end_date, selected_tickers]):
+            return jsonify({'error': 'All fields are required'}), 400
+        
+        # Carica strategia
+        strategy_fn = getattr(strategies, strategy_name)
+        
+        # Parametri custom
+        params = DEFAULT_STRATEGY_PARAMS.get(strategy_name, {}).copy()
+        for key, default_value in params.items():
+            form_value = request.form.get(f'param_{key}')
+            if form_value:
+                if isinstance(default_value, int):
+                    params[key] = int(form_value)
+                elif isinstance(default_value, float):
+                    params[key] = float(form_value)
+        
+        # Esegui backtest
+        results = run_backtest(
+            strategy_fn=strategy_fn,
+            start_date=start_date,
+            end_date=end_date,
+            tickers=selected_tickers,
+            initial_capital=initial_capital,
+            **params
+        )
+        
+        # Prepara dati per visualizzazione
+        portfolio_history = results['portfolio_history'].to_dict('records')
+        trades_history = results['trades_history'].to_dict('records')
+        
+        return jsonify({
+            'success': True,
+            'results': results['portfolio_metrics'],
+            'trade_metrics': results['trade_metrics'],
+            'portfolio_history': portfolio_history,
+            'trades_history': trades_history,
+            'strategy': strategy_name,
+            'period': f"{start_date} to {end_date}"
+        })
+    
+    except Exception as e:
+        return jsonify({'error': str(e)}), 400