app.py

from viktor import ViktorController
from viktor.parametrization import ViktorParametrization
import viktor as vkt
import requests
import os
import pandas as pd
from io import BytesIO
import openpyxl


def _get_sharepoint_sites():
    integration = vkt.external.OAuth2Integration('microsoft-entra')
    access_token = integration.get_access_token()

    # Test SharePoint access by getting list of sites
    headers = {
        'Authorization': f'Bearer {access_token}',
        'Accept': 'application/json'
    }

    try:
        # Try to get SharePoint sites
        response = requests.get(
            'https://graph.microsoft.com/v1.0/sites?search=*',
            headers=headers
        )

        if response.status_code == 200:
            sites = response.json()
            return [
                vkt.OptionListElement(
                    label=str(site.get('displayName', 'N/A')),
                    value=str(site.get('webUrl', 'N/A'))
                ) for site in sites.get('value', [])
            ]
    except Exception as e:
        print("Error occurred, empty list: ", e)
        return []


def get_sharepoint_options(params, **kwargs):
    return _get_sharepoint_sites()


def is_file(params, type, **kwargs):
    if params.selected_name:
        return params.selected_name.split(".")[1] == type
    return False


class Parametrization(ViktorParametrization):
    header = vkt.Text("# Select SharePoint site")
    url = vkt.OptionField("SharePoint site", options=get_sharepoint_options)

    lb = vkt.LineBreak()
    header2 = vkt.Text("# Selected document to preview")
    selected_name = vkt.TextField("Selected document Name")
    selected_url = vkt.TextField("Selected document URL")

class Controller(ViktorController):
    label = "My Controller"
    parametrization = Parametrization

    @vkt.TableView("Excel File", duration_guess=1, visible=lambda params, **kwargs: is_file(params, "xlsx", **kwargs))
    def excel_view(self, params, **kwargs):
        if not params.selected_url:
            return vkt.TableResult(pd.DataFrame({"Error": ["No file selected"]}))

        # Get access token
        integration = vkt.external.OAuth2Integration('microsoft-entra')
        access_token = integration.get_access_token()

        # Download the file from SharePoint using the Graph API URL
        headers = {
            'Authorization': f'Bearer {access_token}',
        }

        try:
            response = requests.get(params.selected_url, headers=headers)

            if response.status_code != 200:
                return vkt.TableResult(pd.DataFrame({
                    "Error": [f"Failed to download file: {response.status_code}"]
                }))

            # Load Excel file from bytes
            excel_bytes = BytesIO(response.content)
            df = pd.read_excel(excel_bytes)

            return vkt.TableResult(df)

        except Exception as e:
            return vkt.TableResult(pd.DataFrame({
                "Error": [f"Error loading Excel file: {str(e)}"]
            }))


    @vkt.PDFView("Word File", duration_guess=1, visible=lambda params, **kwargs: is_file(params, "docx", **kwargs))
    def docx_view(self, params, **kwargs):
        # Get access token
        integration = vkt.external.OAuth2Integration('microsoft-entra')
        access_token = integration.get_access_token()

        # Download the file from SharePoint using the Graph API URL
        headers = {
            'Authorization': f'Bearer {access_token}',
        }

        try:
            response = requests.get(params.selected_url, headers=headers)

            if response.status_code != 200:
                # Return an empty PDF with error message
                raise Exception(f"Failed to download file: {response.status_code}")

            # Return PDF data
            word_file = vkt.File.from_data(response.content)
            with word_file.open_binary() as f:
                pdf_file = vkt.convert_word_to_pdf(f)
                return vkt.PDFResult(file=pdf_file)

        except Exception as e:
            # Create a simple error PDF or raise the exception
            raise Exception(f"Error loading PDF file: {str(e)}")

    @vkt.PDFView("PDF File", duration_guess=1, visible=lambda params, **kwargs: is_file(params, "pdf", **kwargs))
    def pdf_view(self, params, **kwargs):
        # Get access token
        integration = vkt.external.OAuth2Integration('microsoft-entra')
        access_token = integration.get_access_token()

        # Download the file from SharePoint using the Graph API URL
        headers = {
            'Authorization': f'Bearer {access_token}',
        }

        try:
            response = requests.get(params.selected_url, headers=headers)

            if response.status_code != 200:
                # Return an empty PDF with error message
                raise Exception(f"Failed to download file: {response.status_code}")

            # Return PDF data
            pdf_file = vkt.File.from_data(response.content)
            return vkt.PDFResult(file=pdf_file)

        except Exception as e:
            # Create a simple error PDF or raise the exception
            raise Exception(f"Error loading PDF file: {str(e)}")

    @vkt.WebView("Site Contents", duration_guess=1)
    def site_contents_view(self, params, **kwargs):
        if not params.url:
            return vkt.WebResult(html="<h2>Please select a SharePoint site first</h2>")

        integration = vkt.external.OAuth2Integration('microsoft-entra')
        access_token = integration.get_access_token()

        headers = {
            'Authorization': f'Bearer {access_token}',
            'Accept': 'application/json'
        }

        def get_folder_contents(drive_id, item_id=None, depth=0, max_depth=3):
            """Recursively get folder contents with depth limit"""
            if depth > max_depth:
                return ""

            # Build URL for items
            if item_id:
                url = f'https://graph.microsoft.com/v1.0/drives/{drive_id}/items/{item_id}/children'
            else:
                url = f'https://graph.microsoft.com/v1.0/drives/{drive_id}/root/children'

            items_response = requests.get(url, headers=headers)

            if items_response.status_code != 200:
                return f"<li class='error'>Error loading contents</li>"

            items = items_response.json().get('value', [])

            if not items:
                return "<li class='empty'>Empty folder</li>"

            html = ""
            folders = [item for item in items if 'folder' in item]
            files = [item for item in items if 'file' in item]

            # Show folders first
            for folder in folders:
                folder_name = folder.get('name', 'N/A')
                folder_id = folder.get('id')
                child_count = folder.get('folder', {}).get('childCount', 0)

                html += f"""
                <li class='folder-item'>
                    <details>
                        <summary>
                            <span class='folder-icon'>📁</span>
                            <span class='folder-name'>{folder_name}</span>
                            <span class='item-count'>({child_count} items)</span>
                        </summary>
                        <ul class='nested'>
                            {get_folder_contents(drive_id, folder_id, depth + 1, max_depth)}
                        </ul>
                    </details>
                </li>
                """

            # Show files
            for file in files:
                file_name = file.get('name', 'N/A')
                file_size = file.get('size', 0)
                file_url = file.get('webUrl', '#')
                file_id = file.get('id')

                # Construct Graph API download URL
                download_url = f"https://graph.microsoft.com/v1.0/drives/{drive_id}/items/{file_id}/content"

                # Convert size to readable format
                size_kb = file_size / 1024
                if size_kb < 1024:
                    size_str = f"{size_kb:.1f} KB"
                elif size_kb < 1024 * 1024:
                    size_str = f"{size_kb/1024:.1f} MB"
                else:
                    size_str = f"{size_kb/(1024*1024):.1f} GB"

                # Determine file icon based on extension
                ext = file_name.split('.')[-1].lower() if '.' in file_name else ''
                if ext in ['pdf']:
                    icon = '📄'
                elif ext in ['doc', 'docx']:
                    icon = '📝'
                elif ext in ['xls', 'xlsx']:
                    icon = '📊'
                elif ext in ['ppt', 'pptx']:
                    icon = '📽️'
                elif ext in ['jpg', 'jpeg', 'png', 'gif']:
                    icon = '🖼️'
                elif ext in ['zip', 'rar', '7z']:
                    icon = '📦'
                else:
                    icon = '📄'

                # Escape single quotes in file name and URL for JavaScript
                file_name_escaped = file_name.replace("'", "\\'")
                download_url_escaped = download_url.replace("'", "\\'")

                # Only show Load File button for supported file types
                load_button = ""
                if ext in ['docx', 'xlsx', 'pdf']:
                    load_button = f"<button class='load-btn' onclick=\"loadFile('{file_name_escaped}', '{download_url_escaped}');\">Load File</button>"

                html += f"""
                <li class='file-item'>
                    <span class='file-icon'>{icon}</span>
                    <a href='{file_url}' target='_blank' class='file-name'>{file_name}</a>
                    <span class='file-size'>{size_str}</span>
                    {load_button}
                </li>
                """

            return html

        # CSS styles and scripts
        css = """
        <!DOCTYPE html>
        <html lang="en">
        <head>
        <meta charset="UTF-8">
        <meta name="viewport" content="width=device-width, initial-scale=1.0">
        <script src="VIKTOR_JS_SDK"></script>
        <script>
            function loadFile(fileName, downloadUrl) {
                viktorSdk.sendParams({
                    selected_name: fileName,
                    selected_url: downloadUrl
                }, true);
            }
        </script>
        <style>
            body {
                font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, Cantarell, sans-serif;
                background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
                padding: 20px;
                margin: 0;
            }
            .container {
                max-width: 1200px;
                margin: 0 auto;
                background: white;
                border-radius: 12px;
                box-shadow: 0 20px 60px rgba(0,0,0,0.3);
                padding: 30px;
            }
            h2 {
                color: #2d3748;
                font-size: 28px;
                margin-bottom: 10px;
                font-weight: 600;
            }
            .site-url {
                color: #718096;
                font-size: 14px;
                margin-bottom: 30px;
                word-break: break-all;
            }
            .drive-section {
                margin-bottom: 30px;
            }
            .drive-title {q
                color: #4a5568;
                font-size: 20px;
                font-weight: 600;
                margin-bottom: 15px;
                padding: 12px;
                background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
                color: white;
                border-radius: 8px;
                display: flex;
                align-items: center;
                gap: 10px;
            }
            ul {
                list-style: none;
                padding-left: 0;
            }
            .nested {
                padding-left: 30px;
                margin-top: 8px;
            }
            details {
                margin: 4px 0;
            }
            summary {
                cursor: pointer;
                padding: 10px;
                border-radius: 6px;
                transition: background-color 0.2s;
                display: flex;
                align-items: center;
                gap: 8px;
                user-select: none;
            }
            summary:hover {
                background-color: #f7fafc;
            }
            details[open] > summary {
                background-color: #edf2f7;
                margin-bottom: 8px;
            }
            .folder-item {
                margin: 4px 0;
            }
            .folder-icon {
                font-size: 18px;
            }
            .folder-name {
                font-weight: 500;
                color: #2d3748;
            }
            .item-count {
                color: #a0aec0;
                font-size: 12px;
            }
            .file-item {
                padding: 10px;
                border-radius: 6px;
                transition: background-color 0.2s;
                display: flex;
                align-items: center;
                gap: 10px;
                margin: 4px 0;
            }
            .file-item:hover {
                background-color: #f7fafc;
            }
            .file-icon {
                font-size: 18px;
            }
            .file-name {
                flex: 1;
                color: #4299e1;
                text-decoration: none;
                font-weight: 500;
            }
            .file-name:hover {
                text-decoration: underline;
            }
            .file-size {
                color: #a0aec0;
                font-size: 12px;
                font-weight: 500;
                margin-right: 10px;
            }
            .load-btn {
                background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
                color: white;
                border: none;
                padding: 6px 12px;
                border-radius: 5px;
                font-size: 12px;
                font-weight: 600;
                cursor: pointer;
                transition: transform 0.2s, box-shadow 0.2s;
            }
            .load-btn:hover {
                transform: translateY(-2px);
                box-shadow: 0 4px 12px rgba(102, 126, 234, 0.4);
            }
            .load-btn:active {
                transform: translateY(0);
            }
            .empty {
                color: #a0aec0;
                font-style: italic;
                padding: 10px;
            }
            .error {
                color: #e53e3e;
                padding: 10px;
            }
            .stats {
                background: #f7fafc;
                padding: 15px;
                border-radius: 8px;
                margin-top: 30px;
                color: #4a5568;
                font-weight: 500;
            }
        </style>
        </head>
        <body>
        """

        html = css
        html += "<div class='container'>"
        html += "<h2>📂 SharePoint Site Contents</h2>"
        html += f"<div class='site-url'>{params.url}</div>"

        try:
            # First, get the site ID from the URL
            site_url = params.url.replace('https://', '')
            parts = site_url.split('/')
            hostname = parts[0]
            site_path = '/' + '/'.join(parts[1:]) if len(parts) > 1 else ''

            # Get site by URL
            response = requests.get(
                f'https://graph.microsoft.com/v1.0/sites/{hostname}:{site_path}',
                headers=headers
            )

            if response.status_code != 200:
                html += f"<div class='error'><h3>❌ Error getting site: {response.status_code}</h3>"
                html += f"<pre>{response.text}</pre></div>"
                html += "</div>"
                return vkt.WebResult(html=html)

            site = response.json()
            site_id = site.get('id')

            # Get document libraries (drives)
            drives_response = requests.get(
                f'https://graph.microsoft.com/v1.0/sites/{site_id}/drives',
                headers=headers
            )

            if drives_response.status_code != 200:
                html += f"<div class='error'>❌ Error getting drives: {drives_response.status_code}</div>"
                html += "</div>"
                return vkt.WebResult(html=html)

            drives = drives_response.json().get('value', [])

            if not drives:
                html += "<p class='empty'>No document libraries found</p>"
                html += "</div>"
                return vkt.WebResult(html=html)

            # List contents from all drives
            for drive in drives:
                drive_id = drive.get('id')
                drive_name = drive.get('name', 'Unknown')

                html += f"<div class='drive-section'>"
                html += f"<div class='drive-title'>🗄️ {drive_name}</div>"
                html += "<ul>"
                html += get_folder_contents(drive_id)
                html += "</ul>"
                html += "</div>"

        except Exception as e:
            html += f"<div class='error'><h3>❌ Error</h3>"
            html += f"<pre>{str(e)}</pre></div>"

        html += "</div>"
        html += "</body>"
        html += "</html>"

        # Replace the Viktor JS SDK path
        html = html.replace("VIKTOR_JS_SDK", os.environ["VIKTOR_JS_SDK_PATH"] + "v1.js")

        return vkt.WebResult(html=html)