forms.py

# forms.py

import uuid
from typing import List

from markupsafe import Markup
from starlette_wtf import StarletteForm
from wtforms import BooleanField, FieldList, Form, FormField, SelectField, URLField
from wtforms.validators import URL, Optional
from wtforms.widgets import ListWidget, html_params

import maptomethod


class ListWidgetBootstrap(ListWidget):
    def __init__(self, html_tag="div", prefix_label=True, col_class=""):
        assert html_tag in ("div", "a")
        self.html_tag = html_tag
        self.prefix_label = prefix_label
        self.col_class = col_class

    def __call__(self, field, **kwargs):
        kwargs.setdefault("id", field.id)
        html = [f"<{self.html_tag} {html_params(**kwargs)}>"]
        for subfield in field:
            # if subfield we have to traverse once more down
            if isinstance(subfield, Form):
                for subsubfield in subfield:
                    if self.prefix_label:
                        html.append(
                            f"<div class={self.col_class}>{subsubfield.label} {subsubfield()}</div>"
                        )
                    else:
                        html.append(
                            f"<div class={self.col_class}>{subsubfield()} {subsubfield.label}</div>"
                        )
            # print(dir(subfield))
            else:
                if self.prefix_label:
                    html.append(
                        f"<div class={self.col_class}>{subfield.label} {subfield()}</div>"
                    )
                else:
                    html.append(
                        f"<div class={self.col_class}>{subfield()} {subfield.label}</div>"
                    )
        html.append("</%s>" % self.html_tag)
        return Markup("".join(html))


from wtforms import StringField

class AdvancedForm(Form):
    # Hidden field to store data subject types as comma-separated values (using StringField to avoid URL validation)
    data_subject_types = StringField(
        "Data Subject Types",
        validators=[Optional()],
        render_kw={"class": "form-control d-none", "id": "data-subject-types-hidden"},
        default=f"{maptomethod.OA.Annotation},{maptomethod.CSVW.Column}",
        description="Types to query for subjects in data document.",
    )
    
    mapping_predicate_uri = URLField(
        "URL Mapping Predicat",
        # validators=[DataRequired(),URL()],
        render_kw={"class": "form-control"},
        default=maptomethod.ContentToBearingRelation,
        description="URI of object property to use as predicate.",
    )
    
    # Hidden field to store template object types as comma-separated values (using StringField to avoid URL validation)
    template_object_types = StringField(
        "Template Object Types",
        validators=[Optional()],
        render_kw={"class": "form-control d-none", "id": "template-object-types-hidden"},
        default=f"{maptomethod.InformtionContentEntity},{maptomethod.TemporalRegionClass}",
        description="Types to query for objects in template document.",
    )


class StartForm(StarletteForm):
    data_url = URLField(
        "URL Meta Data",
        # validators=[DataRequired(),URL()],
        render_kw={
            "placeholder": "https://github.com/Mat-O-Lab/CSVToCSVW/raw/main/examples/example-metadata.json",
            "class": "form-control",
        },
        description="Paste URL to meta data json file create from CSVToCSVW",
    )
    template_url = URLField(
        "URL Template Data",
        render_kw={
            "placeholder": "https://raw.githubusercontent.com/Mat-O-Lab/MSEO/main/methods/DIN_EN_ISO_527-3.drawio.ttl",
            "class": "form-control"
        },
        validators=[Optional(), URL()],
        description="Paste URL to template graph create with MSEO",
    )
    # disabled uing d-none bootrap class
    use_template_rowwise = BooleanField(
        "Duplicate Template for Table Data",
        render_kw={
            "class": "form-check form-check-input form-control-lg",
            "role": "switch",
        },
        description="Check to duplicate the template template for each row in the table.",
        default=False,
    )
    advanced = FormField(
        AdvancedForm, render_kw={"class": "collapse"}, widget=ListWidgetBootstrap()
    )


class SelectForm(Form):
    select = SelectField(
        "Placeholder",
        default=(0, "None"),
        choices=[],
        validate_choice=False,
        render_kw={"class": "form-control col-s-3"},
    )


class MappingFormList(StarletteForm):
    assignments = FieldList(
        FormField(SelectForm, render_kw={"class": "form-control"}),
        widget=ListWidgetBootstrap(col_class="col-sm-4"),
        render_kw={"class": "row"},
    )


def get_select_entries(objects_dict: dict, choices: List, abbreviate_fn=None) -> List[SelectForm]:
    """Converts custom metadata to a forms.SelectForm(), which can then be
    used by SelectFormlist() to dynamically render select items.

    Args:
        objects_dict (dict): Dict of objects with their metadata including types
        choices (List): List of choices for the selects
        abbreviate_fn (callable): Function to abbreviate IRIs

    Returns:
        List[SelectForm]: _description_
    """
    all_select_items = []
    for name, value in objects_dict.items():
        _id = uuid.uuid1()  # allows for multiple selects
        select_form = SelectForm()
        
        # Create label with type badge
        entity_type = value.get("type") if isinstance(value, dict) else None
        if entity_type and abbreviate_fn:
            type_abbrev = abbreviate_fn(entity_type)
            # Extract prefix for color coding
            prefix = type_abbrev.split('#')[0] if '#' in type_abbrev else type_abbrev.split(':')[0]
            # Create HTML with badge - will be colored by JavaScript
            label_html = Markup(f'{name} <span class="badge type-badge" data-prefix="{prefix}" title="{entity_type}">{type_abbrev}</span>')
            select_form.select.label = label_html
        else:
            select_form.select.label = name
            
        select_form.select.name = name
        select_form.select.id = f"{name}-{_id}"
        select_form.select.choices = choices
        all_select_items.append(select_form)
    return all_select_items