@mtldev514/retro-portfolio-engine 1.0.0

package/engine/admin/admin_api.py

@@ -0,0 +1,230 @@
+from flask import Flask, request, jsonify, send_from_directory
+from flask_cors import CORS
+import os
+import sys
+import json
+
+# Get user data directories from environment variables
+# These will be set by the npm admin script
+USER_DATA_DIR = os.environ.get('DATA_DIR', '../../data')
+USER_CONFIG_DIR = os.environ.get('CONFIG_DIR', '../../config')
+USER_LANG_DIR = os.environ.get('LANG_DIR', '../../lang')
+PORT = int(os.environ.get('PORT', 5001))
+
+# Add scripts directory to path
+SCRIPT_DIR = os.path.join(os.path.dirname(__file__), 'scripts')
+sys.path.append(SCRIPT_DIR)
+
+# Import manager and config loader
+import manager
+from config_loader import config
+
+# Override config paths to use user directories
+config.CONFIG_DIR = USER_CONFIG_DIR
+config.DATA_DIR = USER_DATA_DIR
+config.LANG_DIR = USER_LANG_DIR
+
+# Load configuration from user directories
+config.load_all()
+
+app = Flask(__name__,
+            static_folder='.',
+            static_url_path='')
+CORS(app)
+
+UPLOAD_FOLDER = os.environ.get('UPLOAD_FOLDER', 'temp_uploads')
+if not os.path.exists(UPLOAD_FOLDER):
+    os.makedirs(UPLOAD_FOLDER)
+
+# Serve admin.html
+@app.route('/admin.html')
+def serve_admin():
+    return send_from_directory('.', 'admin.html')
+
+@app.route('/admin.css')
+def serve_admin_css():
+    return send_from_directory('.', 'admin.css')
+
+@app.route('/api/upload', methods=['POST'])
+def upload_file():
+    if 'file' not in request.files:
+        return jsonify({"error": "No file part"}), 400
+
+    file = request.files['file']
+    if file.filename == '':
+        return jsonify({"error": "No selected file"}), 400
+
+    title = request.form.get('title')
+    category = request.form.get('category')
+    medium = request.form.get('medium')
+    genre = request.form.get('genre')
+    description = request.form.get('description')
+    created = request.form.get('created')
+
+    if not title or not category:
+        return jsonify({"error": "Title and Category are required"}), 400
+
+    # Save file temporarily
+    temp_path = os.path.join(UPLOAD_FOLDER, file.filename)
+    file.save(temp_path)
+
+    try:
+        # Use manager logic to upload to Cloudinary and update JSON
+        result = manager.upload_and_save(
+            temp_path,
+            title,
+            category,
+            medium=medium,
+            genre=genre,
+            description=description,
+            created=created
+        )
+        return jsonify({"success": True, "data": result})
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500
+    finally:
+        # Cleanup temp file
+        if os.path.exists(temp_path):
+            os.remove(temp_path)
+
+@app.route('/api/upload-bulk', methods=['POST'])
+def upload_bulk():
+    """Handle bulk file uploads"""
+    results = []
+    errors = []
+    file_keys = [k for k in request.files if k.startswith('file_')]
+    file_keys.sort(key=lambda k: int(k.split('_')[1]))
+
+    for key in file_keys:
+        idx = key.split('_')[1]
+        file = request.files[key]
+        title = request.form.get(f'title_{idx}', file.filename)
+        category = request.form.get(f'category_{idx}')
+        medium = request.form.get(f'medium_{idx}')
+        genre = request.form.get(f'genre_{idx}')
+        description = request.form.get(f'description_{idx}')
+        created = request.form.get(f'created_{idx}')
+
+        if not category:
+            errors.append({"file": file.filename, "error": "Missing category"})
+            continue
+
+        temp_path = os.path.join(UPLOAD_FOLDER, file.filename)
+        file.save(temp_path)
+
+        try:
+            result = manager.upload_and_save(
+                temp_path, title, category,
+                medium=medium, genre=genre,
+                description=description, created=created
+            )
+            results.append({"file": file.filename, "success": True, "data": result})
+        except Exception as e:
+            errors.append({"file": file.filename, "error": str(e)})
+        finally:
+            if os.path.exists(temp_path):
+                os.remove(temp_path)
+
+    return jsonify({
+        "success": len(results),
+        "errors": len(errors),
+        "results": results,
+        "errorDetails": errors
+    })
+
+@app.route('/api/content/<category>', methods=['GET'])
+def get_content(category):
+    """Get all content for a category"""
+    try:
+        data_file = os.path.join(USER_DATA_DIR, f'{category}.json')
+        if not os.path.exists(data_file):
+            return jsonify({"items": []})
+
+        with open(data_file, 'r', encoding='utf-8') as f:
+            data = json.load(f)
+        return jsonify(data)
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500
+
+@app.route('/api/content/<category>', methods=['POST'])
+def save_content(category):
+    """Save content for a category"""
+    try:
+        data = request.json
+        data_file = os.path.join(USER_DATA_DIR, f'{category}.json')
+
+        with open(data_file, 'w', encoding='utf-8') as f:
+            json.dump(data, f, indent=2, ensure_ascii=False)
+
+        return jsonify({"success": True})
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500
+
+@app.route('/api/translations/<lang>', methods=['GET'])
+def get_translations(lang):
+    """Get translations for a language"""
+    try:
+        lang_file = os.path.join(USER_LANG_DIR, f'{lang}.json')
+        if not os.path.exists(lang_file):
+            return jsonify({})
+
+        with open(lang_file, 'r', encoding='utf-8') as f:
+            data = json.load(f)
+        return jsonify(data)
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500
+
+@app.route('/api/translations/<lang>', methods=['POST'])
+def save_translations(lang):
+    """Save translations for a language"""
+    try:
+        data = request.json
+        lang_file = os.path.join(USER_LANG_DIR, f'{lang}.json')
+
+        with open(lang_file, 'w', encoding='utf-8') as f:
+            json.dump(data, f, indent=2, ensure_ascii=False)
+
+        return jsonify({"success": True})
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500
+
+@app.route('/api/config/<config_name>', methods=['GET'])
+def get_config(config_name):
+    """Get configuration"""
+    try:
+        config_file = os.path.join(USER_CONFIG_DIR, f'{config_name}.json')
+        if not os.path.exists(config_file):
+            return jsonify({})
+
+        with open(config_file, 'r', encoding='utf-8') as f:
+            data = json.load(f)
+        return jsonify(data)
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500
+
+@app.route('/api/config/<config_name>', methods=['POST'])
+def save_config(config_name):
+    """Save configuration"""
+    try:
+        data = request.json
+        config_file = os.path.join(USER_CONFIG_DIR, f'{config_name}.json')
+
+        with open(config_file, 'w', encoding='utf-8') as f:
+            json.dump(data, f, indent=2, ensure_ascii=False)
+
+        # Reload config after save
+        config.load_all()
+
+        return jsonify({"success": True})
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500
+
+if __name__ == '__main__':
+    print(f"🔧 Admin API starting...")
+    print(f"   Data dir: {os.path.abspath(USER_DATA_DIR)}")
+    print(f"   Config dir: {os.path.abspath(USER_CONFIG_DIR)}")
+    print(f"   Lang dir: {os.path.abspath(USER_LANG_DIR)}")
+    print(f"   Port: {PORT}")
+    print(f"\n✨ Admin interface: http://localhost:{PORT}/admin.html\n")
+
+    app.run(host='0.0.0.0', port=PORT, debug=True)

package/engine/admin/scripts/backup.sh

@@ -0,0 +1,116 @@
+#!/bin/bash
+
+# Backup Personal Data
+# Creates a timestamped backup of your personal configuration and content
+
+set -e
+
+echo ""
+echo "═══════════════════════════════════════════════════════════"
+echo "  📦 Backup Personal Data"
+echo "═══════════════════════════════════════════════════════════"
+echo ""
+
+# Create backup directory with timestamp
+BACKUP_DIR=".backup-personal"
+TIMESTAMP=$(date +%Y%m%d-%H%M%S)
+BACKUP_PATH="$BACKUP_DIR/$TIMESTAMP"
+
+echo "Creating backup at: $BACKUP_PATH"
+echo ""
+
+# Create backup directory structure
+mkdir -p "$BACKUP_PATH"
+
+# Track what we backed up
+BACKED_UP=0
+
+# Backup config
+if [ -d "config" ]; then
+    cp -r config "$BACKUP_PATH/"
+    echo "  ✓ Backed up config/ ($(find config -type f | wc -l | xargs) files)"
+    BACKED_UP=$((BACKED_UP + 1))
+else
+    echo "  ⚠️  config/ not found"
+fi
+
+# Backup data
+if [ -d "data" ]; then
+    cp -r data "$BACKUP_PATH/"
+    echo "  ✓ Backed up data/ ($(find data -type f | wc -l | xargs) files)"
+    BACKED_UP=$((BACKED_UP + 1))
+else
+    echo "  ⚠️  data/ not found"
+fi
+
+# Backup lang
+if [ -d "lang" ]; then
+    cp -r lang "$BACKUP_PATH/"
+    echo "  ✓ Backed up lang/ ($(find lang -type f | wc -l | xargs) files)"
+    BACKED_UP=$((BACKED_UP + 1))
+else
+    echo "  ⚠️  lang/ not found"
+fi
+
+# Backup .env
+if [ -f ".env" ]; then
+    cp .env "$BACKUP_PATH/"
+    echo "  ✓ Backed up .env"
+    BACKED_UP=$((BACKED_UP + 1))
+else
+    echo "  ⚠️  .env not found"
+fi
+
+
+# Create backup info file
+cat > "$BACKUP_PATH/BACKUP_INFO.txt" << EOF
+Backup Information
+==================
+
+Date: $(date)
+Location: $BACKUP_PATH
+Hostname: $(hostname)
+User: $(whoami)
+
+Contents:
+$(ls -la "$BACKUP_PATH")
+
+To restore this backup:
+  ./scripts/restore.sh $TIMESTAMP
+
+Or manually:
+  cp -r $BACKUP_PATH/config ./
+  cp -r $BACKUP_PATH/data ./
+  cp -r $BACKUP_PATH/lang ./
+  cp $BACKUP_PATH/.env ./
+EOF
+
+echo ""
+echo "═══════════════════════════════════════════════════════════"
+
+if [ $BACKED_UP -gt 0 ]; then
+    echo "  ✅ Backup Complete!"
+    echo "═══════════════════════════════════════════════════════════"
+    echo ""
+    echo "📂 Backup location: $BACKUP_PATH"
+    echo "📊 Items backed up: $BACKED_UP"
+    echo ""
+    echo "To restore:"
+    echo "  ./scripts/restore.sh $TIMESTAMP"
+    echo ""
+else
+    echo "  ⚠️  Nothing to backup"
+    echo "═══════════════════════════════════════════════════════════"
+    echo ""
+    echo "No personal data found. Have you run ./init.sh yet?"
+    echo ""
+fi
+
+# Clean up old backups (keep last 5)
+echo "Cleaning up old backups (keeping last 5)..."
+ls -t "$BACKUP_DIR" | tail -n +6 | while read old_backup; do
+    rm -rf "$BACKUP_DIR/$old_backup"
+    echo "  Removed old backup: $old_backup"
+done
+
+echo ""

package/engine/admin/scripts/config_loader.py

@@ -0,0 +1,180 @@
+"""
+Configuration Loader for Backend
+Loads all configuration files and makes them available to Python scripts
+"""
+
+import json
+import os
+from pathlib import Path
+
+
+class ConfigLoader:
+    """Centralized configuration loader"""
+
+    def __init__(self, content_root=None):
+        if content_root is None:
+            content_root = os.environ.get('PORTFOLIO_CONTENT_ROOT', '.')
+        
+        self.content_root = Path(content_root).resolve()
+        self.config_dir = self.content_root / 'config'
+        self.data_dir = self.content_root / 'data'
+        self.lang_dir = self.content_root / 'lang'
+        
+        self.app_config = None
+        self.languages_config = None
+        self.categories_config = None
+        self.media_types_config = None
+
+    def load_all(self):
+        """Load all configuration files"""
+        try:
+            # Ensure directories exist
+            for d in [self.config_dir, self.data_dir, self.lang_dir]:
+                if not d.exists():
+                    try:
+                        os.makedirs(d)
+                    except OSError:
+                        pass # Might be read-only or we just can't create it
+
+            with open(self.config_dir / 'app.json', 'r', encoding='utf-8') as f:
+                self.app_config = json.load(f)
+
+            with open(self.config_dir / 'languages.json', 'r', encoding='utf-8') as f:
+                self.languages_config = json.load(f)
+
+            with open(self.config_dir / 'categories.json', 'r', encoding='utf-8') as f:
+                self.categories_config = json.load(f)
+
+            with open(self.config_dir / 'media-types.json', 'r', encoding='utf-8') as f:
+                self.media_types_config = json.load(f)
+
+            print(f'✅ Configuration loaded from {self.content_root}')
+            return True
+        except Exception as e:
+            print(f'❌ Failed to load configuration from {self.content_root}: {e}')
+            return False
+
+    # ... (getters) ...
+
+    def get_category_data_file(self, category_id):
+        """Get absolute data file path for a category"""
+        cat = self.get_content_type(category_id)
+        filename = f'{category_id}.json'
+        if cat and 'dataFile' in cat:
+            # If dataFile is specified, use it (removing data/ prefix if present to avoid doubling)
+            filename = cat['dataFile'].replace('data/', '')
+        
+        return str(self.data_dir / filename)
+
+    def get_port(self):
+        """Get API port"""
+        return self.app_config.get('api', {}).get('port', 5001)
+
+    def get_host(self):
+        """Get API host"""
+        return self.app_config.get('api', {}).get('host', '127.0.0.1')
+
+    def get_language_codes(self):
+        """Get list of supported language codes"""
+        return [lang['code'] for lang in self.languages_config.get('supportedLanguages', [])]
+
+    def get_default_language(self):
+        """Get default language code"""
+        return self.languages_config.get('defaultLanguage', 'en')
+
+    def get_content_types(self):
+        """Get all content type configurations (new name for categories)"""
+        return self.categories_config.get('contentTypes', self.categories_config.get('categories', []))
+
+    def get_categories(self):
+        """Get all category configurations (legacy method, now returns content types)"""
+        return self.get_content_types()
+
+    def get_content_type(self, content_type_id):
+        """Get specific content type configuration"""
+        for ct in self.get_content_types():
+            if ct['id'] == content_type_id:
+                return ct
+        return None
+
+    def get_category(self, category_id):
+        """Get specific category configuration (legacy method)"""
+        return self.get_content_type(category_id)
+
+    def get_category_data_file(self, category_id):
+        """Get absolute data file path for a category"""
+        cat = self.get_content_type(category_id)
+        filename = f'{category_id}.json'
+        if cat and 'dataFile' in cat:
+            # If dataFile is specified, ensure it's relative to data_dir
+            # We strip 'data/' prefix if it was hardcoded in the config
+            clean_name = cat['dataFile'].replace('data/', '')
+            return str(self.data_dir / clean_name)
+        return str(self.data_dir / filename)
+
+    def get_category_map(self):
+        """Get mapping of category ID to absolute data file path"""
+        return {cat['id']: self.get_category_data_file(cat['id']) for cat in self.get_content_types()}
+
+    def get_gallery_categories(self):
+        """Get list of categories that support galleries (based on media type)"""
+        gallery_types = []
+        for ct in self.get_content_types():
+            media_type = self.get_media_type(ct.get('mediaType'))
+            if media_type and media_type.get('supportsGallery', False):
+                gallery_types.append(ct['id'])
+        return gallery_types
+
+    def get_media_types(self):
+        """Get all media type configurations"""
+        if self.media_types_config is None:
+            return []
+        return self.media_types_config.get('mediaTypes', [])
+
+    def get_media_type(self, media_type_id):
+        """Get specific media type configuration"""
+        for mt in self.get_media_types():
+            if mt['id'] == media_type_id:
+                return mt
+        return None
+
+    def get_content_types_by_media(self, media_type_id):
+        """Get all content types that use a specific media type"""
+        return [ct for ct in self.get_content_types() if ct.get('mediaType') == media_type_id]
+
+    def get_github_config(self):
+        """Get GitHub configuration"""
+        return self.app_config.get('github', {})
+
+    def get_github_repo(self):
+        """Get full GitHub repository path (username/repo)"""
+        github = self.get_github_config()
+        username = github.get('username', '')
+        repo_name = github.get('repoName', '')
+        if username and repo_name:
+            return f"{username}/{repo_name}"
+        # Fallback to old 'repo' key if it exists
+        return github.get('repo', 'yourusername/retro-portfolio')
+
+    def get_path(self, path_key):
+        """Get configured path (dataDir, langDir, etc.)"""
+        return self.app_config.get('paths', {}).get(path_key, path_key)
+
+    def create_multilingual_object(self, value):
+        """Create a multilingual object with all supported languages"""
+        return {code: value for code in self.get_language_codes()}
+
+    def get_setting(self, path):
+        """Get app setting by dot-notation path (e.g., 'app.name')"""
+        parts = path.split('.')
+        value = self.app_config
+        for part in parts:
+            if isinstance(value, dict):
+                value = value.get(part)
+            else:
+                return None
+        return value
+
+
+# Global instance
+config = ConfigLoader()

package/engine/admin/scripts/init.sh

@@ -0,0 +1,141 @@
+#!/bin/bash
+
+# Portfolio Initialization Script
+# Copies .example files to create your working configuration
+
+set -e
+
+echo ""
+echo "═══════════════════════════════════════════════════════════"
+echo "  🎨 Retro Portfolio - Initialization"
+echo "═══════════════════════════════════════════════════════════"
+echo ""
+
+# Check if already initialized
+if [ -d "config" ] && [ -f "config/app.json" ]; then
+    echo "⚠️  Portfolio appears to be already initialized."
+    echo ""
+    read -p "Reinitialize and overwrite existing files? (y/N): " -n 1 -r
+    echo
+    if [[ ! $REPLY =~ ^[Yy]$ ]]; then
+        echo "Aborted."
+        exit 0
+    fi
+fi
+
+echo "📁 Creating directory structure..."
+
+# Create directories
+mkdir -p config
+mkdir -p data
+mkdir -p lang
+
+echo "📋 Copying configuration examples..."
+
+# Copy config files
+if [ -d "config.example" ]; then
+    for file in config.example/*.example; do
+        if [ -f "$file" ]; then
+            basename=$(basename "$file" .example)
+            cp "$file" "config/$basename"
+            echo "  ✓ config/$basename"
+        fi
+    done
+else
+    echo "  ⚠️  config.example/ not found, skipping"
+fi
+
+echo ""
+echo "📋 Copying data examples..."
+
+# Copy data files
+if [ -d "data.example" ]; then
+    for file in data.example/*.example; do
+        if [ -f "$file" ]; then
+            basename=$(basename "$file" .example)
+            cp "$file" "data/$basename"
+            echo "  ✓ data/$basename"
+        fi
+    done
+else
+    echo "  ⚠️  data.example/ not found, skipping"
+fi
+
+echo ""
+echo "🌐 Copying language files..."
+
+# Copy lang files
+if [ -d "lang.example" ]; then
+    for file in lang.example/*.example; do
+        if [ -f "$file" ]; then
+            basename=$(basename "$file" .example)
+            cp "$file" "lang/$basename"
+            echo "  ✓ lang/$basename"
+        fi
+    done
+else
+    echo "  ⚠️  lang.example/ not found, skipping"
+fi
+
+echo ""
+echo "🔐 Setting up environment..."
+
+# Copy .env if doesn't exist
+if [ ! -f ".env" ]; then
+    if [ -f ".env.example" ]; then
+        cp .env.example .env
+        echo "  ✓ .env created from .env.example"
+        echo "  ⚠️  IMPORTANT: Edit .env with your Cloudinary credentials!"
+    else
+        echo "  ⚠️  .env.example not found"
+    fi
+else
+    echo "  ✓ .env already exists"
+fi
+
+# Copy config-source.json if doesn't exist
+if [ ! -f "config-source.json" ]; then
+    if [ -f "config-source.json.example" ]; then
+        cp config-source.json.example config-source.json
+        echo "  ✓ config-source.json created"
+    fi
+else
+    echo "  ✓ config-source.json already exists"
+fi
+
+echo ""
+echo "═══════════════════════════════════════════════════════════"
+echo "  ✅ Initialization Complete!"
+echo "═══════════════════════════════════════════════════════════"
+echo ""
+echo "Next steps:"
+echo ""
+echo "1. Edit your credentials:"
+echo "   nano .env"
+echo "   (Add your CLOUDINARY_CLOUD_NAME, API_KEY, API_SECRET)"
+echo ""
+echo "2. Customize your portfolio:"
+echo "   - config/app.json      (app settings)"
+echo "   - config/categories.json (content types)"
+echo "   - config/languages.json  (supported languages)"
+echo ""
+echo "3. Add your content:"
+echo "   - data/painting.json"
+echo "   - data/photography.json"
+echo "   - etc..."
+echo ""
+echo "4. Customize translations:"
+echo "   - lang/en.json"
+echo "   - lang/fr.json"
+echo "   - etc..."
+echo ""
+echo "5. Start the backend:"
+echo "   python3 admin_api.py"
+echo ""
+echo "6. Open in browser:"
+echo "   open index.html"
+echo "   or"
+echo "   python3 -m http.server 8000"
+echo ""
+echo "📚 See README.md for full documentation"
+echo ""