dsp-tools 0.9.13__py3-none-any.whl → 18.3.0.post13__py3-none-any.whl

dsp_tools/commands/excel2xml/propertyelement.py

@@ -0,0 +1,47 @@
+from dataclasses import dataclass
+from typing import Optional
+from typing import Union
+
+from dsp_tools.error.exceptions import BaseError
+
+# ruff: noqa: E501 (line-too-long)
+
+
+@dataclass(frozen=True)
+class PropertyElement:
+    """
+    A PropertyElement object carries more information about a property value than the value itself.
+    The "value" is the value that could be passed to a method as plain string/int/float/bool. Use a PropertyElement
+    instead to define more precisely what attributes your value tag (e.g. `<text>`, `<uri>`, ...) will have.
+
+    Args:
+        value: This is the content that will be written into the value tag (e.g. `<text>`, `<uri>`, ...)
+        permissions: This is the permissions that your `<text>` tag (for example) will have
+        comment: This is the comment that your `<text>` tag (for example) will have
+        encoding: For `<text>` tags only. If provided, it must be "xml" or "utf8".
+
+    Examples:
+        See the difference between the first and the second example:
+
+        >>> excel2xml.make_text_prop(":testproperty", "first text")
+                <text-prop name=":testproperty">
+                    <text encoding="utf8" permissions="public">
+                        first text
+                    </text>
+                </text-prop>
+        >>> excel2xml.make_text_prop(":testproperty", excel2xml.PropertyElement("first text", permissions="private", encoding="xml"))
+                <text-prop name=":testproperty">
+                    <text encoding="xml" permissions="private">
+                        first text
+                    </text>
+                </text-prop>
+    """
+
+    value: Union[str, int, float, bool]
+    permissions: str = "public"
+    comment: Optional[str] = None
+    encoding: Optional[str] = None
+
+    def __post_init__(self) -> None:
+        if self.encoding not in ["utf8", "xml", None]:
+            raise BaseError(f"'{self.encoding}' is not a valid encoding for a PropertyElement")

dsp_tools/commands/get/get.py

@@ -0,0 +1,166 @@
+import json
+import warnings
+from typing import Any
+
+import regex
+
+from dsp_tools.cli.args import ServerCredentials
+from dsp_tools.clients.authentication_client_live import AuthenticationClientLive
+from dsp_tools.clients.connection import Connection
+from dsp_tools.clients.connection_live import ConnectionLive
+from dsp_tools.commands.get.get_permissions import get_default_permissions
+from dsp_tools.commands.get.legacy_models.group import Group
+from dsp_tools.commands.get.legacy_models.listnode import ListNode
+from dsp_tools.commands.get.legacy_models.ontology import Ontology
+from dsp_tools.commands.get.legacy_models.project import Project
+from dsp_tools.commands.get.legacy_models.user import User
+from dsp_tools.error.exceptions import BaseError
+
+
+def get_project(
+    project_identifier: str,
+    outfile_path: str,
+    creds: ServerCredentials,
+    verbose: bool = False,
+) -> bool:
+    """
+    This function writes a project from a DSP server into a JSON file.
+
+    Args:
+        project_identifier: the project identifier, either shortcode, shortname or IRI of the project
+        outfile_path: the output file the JSON content should be written to
+        creds: the credentials to access the DSP server
+        verbose: verbose option for the command, if used more output is given to the user
+
+    Raises:
+        BaseError: if something went wrong
+
+    Returns:
+        True if the process finishes without errors
+    """
+    auth = AuthenticationClientLive(creds.server, creds.user, creds.password)
+    try:
+        auth.get_token()
+        con = ConnectionLive(creds.server, auth)
+        authenticated = True
+    except BaseError:
+        warnings.warn("WARNING: Missing or wrong credentials. You won't get sensitive data of this project.")
+        con = ConnectionLive(creds.server)
+        authenticated = False
+
+    project = _create_project(con, project_identifier)
+
+    project = project.read()
+    project_obj = project.createDefinitionFileObj()
+
+    prefixes, ontos = _get_ontologies(con, str(project.iri), verbose)
+
+    if authenticated:
+        default_permissions, default_permissions_overrule = get_default_permissions(auth, str(project.iri), prefixes)
+        project_obj["default_permissions"] = default_permissions
+        if default_permissions_overrule:
+            project_obj["default_permissions_overrule"] = default_permissions_overrule
+    else:
+        project_obj["default_permissions"] = "Please provide credentials to retrieve the permissions of this project."
+
+    project_obj["groups"] = _get_groups(con, str(project.iri), verbose)
+
+    if users := _get_users(con, project, verbose):
+        project_obj["users"] = users
+
+    project_obj["lists"] = _get_lists(con, project, verbose)
+
+    project_obj["ontologies"] = ontos
+
+    schema = "https://raw.githubusercontent.com/dasch-swiss/dsp-tools/main/src/dsp_tools/resources/schema/project.json"
+    outfile_content = {
+        "prefixes": prefixes,
+        "$schema": schema,
+        "project": project_obj,
+    }
+
+    with open(outfile_path, "w", encoding="utf-8") as f:
+        json.dump(outfile_content, f, indent=4, ensure_ascii=False)
+
+    return True
+
+
+def _create_project(con: Connection, project_identifier: str) -> Project:
+    if regex.match("[0-9A-F]{4}", project_identifier):  # shortcode
+        return Project(con=con, shortcode=project_identifier)
+    elif regex.match("^[\\w-]+$", project_identifier):  # shortname
+        return Project(con=con, shortname=project_identifier.lower())
+    elif regex.match("^(http)s?://([\\w\\.\\-~]+:?\\d{,4})(/[\\w\\-~]+)+$", project_identifier):  # iri
+        return Project(con=con, shortname=project_identifier)
+    else:
+        raise BaseError(
+            f"ERROR Invalid project identifier '{project_identifier}'. Use the project's shortcode, shortname or IRI."
+        )
+
+
+def _get_groups(con: Connection, project_iri: str, verbose: bool) -> list[dict[str, Any]]:
+    if verbose:
+        print("Getting groups...")
+    groups_obj: list[dict[str, Any]] = []
+    if groups := Group.getAllGroupsForProject(con=con, proj_iri=project_iri):
+        for group in groups:
+            groups_obj.append(group.createDefinitionFileObj())
+            if verbose:
+                print(f"    Got group '{group.name}'")
+    return groups_obj
+
+
+def _get_users(con: Connection, project: Project, verbose: bool) -> list[dict[str, Any]] | None:
+    if verbose:
+        print("Getting users...")
+    try:
+        users = User.getAllUsersForProject(con=con, proj_shortcode=str(project.shortcode))
+    except BaseError:
+        return None
+    if users is None:
+        return None
+
+    users_obj: list[dict[str, Any]] = []
+    for usr in users:
+        users_obj.append(
+            usr.createDefinitionFileObj(
+                con=con,
+                proj_shortname=str(project.shortname),
+                proj_iri=str(project.iri),
+            )
+        )
+        if verbose:
+            print(f"    Got user '{usr.username}'")
+    return users_obj
+
+
+def _get_lists(con: Connection, project: Project, verbose: bool) -> list[dict[str, Any]]:
+    if verbose:
+        print("Getting lists...")
+    list_obj: list[dict[str, Any]] = []
+    if list_roots := ListNode.getAllLists(con=con, project_iri=project.iri):
+        for list_root in list_roots:
+            complete_list = list_root.getAllNodes()
+            list_obj.append(complete_list.createDefinitionFileObj())
+            if verbose:
+                print(f"    Got list '{list_root.name}'")
+    return list_obj
+
+
+def _get_ontologies(con: Connection, project_iri: str, verbose: bool) -> tuple[dict[str, str], list[dict[str, Any]]]:
+    if verbose:
+        print("Getting ontologies...")
+    ontos = []
+    prefixes: dict[str, str] = {}
+    ontologies = Ontology.getProjectOntologies(con, project_iri)
+    ontology_ids = [onto.iri for onto in ontologies]
+    for ontology_id in ontology_ids:
+        onto_url_parts = ontology_id.split("/")  # an id has the form http://0.0.0.0:3333/ontology/4123/testonto/v2
+        name = onto_url_parts[len(onto_url_parts) - 2]
+        shortcode = onto_url_parts[len(onto_url_parts) - 3]
+        ontology = Ontology.getOntologyFromServer(con=con, shortcode=shortcode, name=name)
+        ontos.append(ontology.createDefinitionFileObj())
+        prefixes.update(ontology.context.get_externals_used())
+        if verbose:
+            print(f"    Got ontology '{name}'")
+    return prefixes, ontos

dsp_tools/commands/get/get_permissions.py

@@ -0,0 +1,257 @@
+from typing import Any
+from typing import Literal
+
+import regex
+
+from dsp_tools.clients.authentication_client import AuthenticationClient
+from dsp_tools.clients.permissions_client import PermissionsClient
+from dsp_tools.commands.get.get_permissions_legacy import parse_legacy_doaps
+from dsp_tools.commands.get.models.permissions_models import DoapCategories
+from dsp_tools.error.exceptions import UnknownDOAPException
+
+
+def get_default_permissions(
+    auth: AuthenticationClient, project_iri: str, prefixes: dict[str, str]
+) -> tuple[str, dict[str, list[str] | Literal["all"]] | None]:
+    """
+    Retrieve the DOAPs of a project from the server,
+    and try to fit them into our system of "default_permissions" and "default_permissions_overrule".
+    If an anomaly is found, return an error message for "default_permissions",
+    and None for "default_permissions_overrule".
+
+    Returns:
+        "default_permissions": "public" or "private" or error message
+        "default_permissions_overrule": {"private": [<classes_or_props>], "limited_view": ["all" or <img_classes>]}
+    """
+    perm_client = PermissionsClient(auth, project_iri)
+    project_doaps = perm_client.get_project_doaps()
+    fallback_text = (
+        "We cannot determine if this project is public or private. "
+        "The DSP-TOOLS devs can assist you in analysing the existing DOAPs, "
+        "and help you decide if the original intent was rather public or rather private."
+    )
+    try:
+        default_permissions = _parse_default_permissions(project_doaps)
+        default_permissions_overrule = _parse_default_permissions_overrule(project_doaps, prefixes)
+    except UnknownDOAPException:
+        default_permissions = fallback_text
+        default_permissions_overrule = None
+    return default_permissions, default_permissions_overrule
+
+
+def _parse_default_permissions(project_doaps: list[dict[str, Any]]) -> str:
+    """
+    First tries to parse legacy DOAPs with multiple groups, then falls back to new-style parsing.
+    New-style parsing: If the DOAPs exactly match our definition of public/private, return public/private.
+    Otherwise, raise an exception.
+    """
+    # First, try to parse legacy DOAPs (multiple groups: ProjectAdmin, ProjectMember)
+    if legacy_result := parse_legacy_doaps(project_doaps):
+        return legacy_result
+
+    # Fall back to new-style parsing (single ProjectMember group)
+    unsupported_groups = ("SystemAdmin", "ProjectAdmin", "Creator", "KnownUser", "UnknownUser")
+    if [x for x in project_doaps if x.get("forGroup", "").endswith(unsupported_groups)]:
+        raise UnknownDOAPException("The only supported target group for DOAPs is ProjectMember.")
+    proj_member_doaps = [x for x in project_doaps if x.get("forGroup", "").endswith("ProjectMember")]
+    if len(proj_member_doaps) != 1:
+        raise UnknownDOAPException("There must be exactly 1 DOAP for ProjectMember.")
+    perms = proj_member_doaps[0]["hasPermissions"]
+    if len(perms) not in [2, 4]:
+        err_msg = "The only allowed permissions are 'private' (with 2 elements), and 'limited_view' (with 4 elements)"
+        raise UnknownDOAPException(err_msg)
+    proj_adm_perms = [x for x in perms if x["additionalInformation"].endswith("ProjectAdmin")]
+    proj_mem_perms = [x for x in perms if x["additionalInformation"].endswith("ProjectMember")]
+    knwn_usr_perms = [x for x in perms if x["additionalInformation"].endswith("KnownUser")]
+    unkn_usr_perms = [x for x in perms if x["additionalInformation"].endswith("UnknownUser")]
+    if not (len(proj_adm_perms) == len(proj_mem_perms) == 1):
+        raise UnknownDOAPException("There must be always 1 permission for ProjectAdmin and 1 for ProjectMember")
+    if proj_adm_perms[0]["name"] != "CR" or proj_mem_perms[0]["name"] != "D":
+        raise UnknownDOAPException("ProjectAdmin must always have CR and ProjectMember must always have D")
+    if len(knwn_usr_perms) == len(unkn_usr_perms) == 0:
+        return "private"
+    if not (len(knwn_usr_perms) == len(unkn_usr_perms) == 1):
+        raise UnknownDOAPException("In case of 'limited_view', there must be 1 for KnownUser and 1 for UnknownUser")
+    if knwn_usr_perms[0]["name"] != "V" or unkn_usr_perms[0]["name"] != "V":
+        raise UnknownDOAPException("In case of 'public', KnownUser and UnknownUser must always have V")
+    return "public"
+
+
+def _parse_default_permissions_overrule(
+    project_doaps: list[dict[str, Any]], prefixes: dict[str, str]
+) -> dict[str, list[str] | Literal["all"]] | None:
+    """
+    The DOAPs retrieved from the server are examined if they fit into our system of the overrules.
+    If yes, an overrule object is returned. Otherwise, an exception is raised.
+
+    Args:
+        project_doaps: DOAPs as retrieved from the server
+        prefixes: dict in the form {"my-onto": "http://0.0.0.0:3333/ontology/1234/my-onto/v2"}
+
+    Returns:
+        an overrule object that can be written into the JSON project definition file, in this form:
+        "default_permissions_overrule": {"private": [<classes_or_props>], "limited_view": ["all" or <img_classes>]}
+
+    Raises:
+        UnknownDOAPException: if there are DOAPs that do not fit into our system
+    """
+    prefixes_knora_base_inverted = _convert_prefixes(prefixes)
+    doap_categories = _categorize_doaps(project_doaps)
+    _validate_doap_categories(doap_categories)
+    return _construct_overrule_object(doap_categories, prefixes_knora_base_inverted)
+
+
+def _convert_prefixes(prefixes: dict[str, str]) -> dict[str, str]:
+    """
+    Convert knora-api form of prefixes into knora-base form (used by DOAPs), and invert it.
+
+    Args:
+        prefixes: dict in the form of {"my-onto": "http://0.0.0.0:3333/ontology/1234/my-onto/v2"}
+
+    Returns:
+        dict in the form of {"http://www.knora.org/ontology/1234/my-onto": "my-onto"}
+    """
+    prefixes_knora_base_inverted = {}
+    for onto_shorthand, knora_api_iri in prefixes.items():
+        if match := regex.search(r"/ontology/([0-9A-Fa-f]{4})/([^/]+)/v2", knora_api_iri):
+            shortcode, onto_name = match.groups()
+            prefixes_knora_base_inverted[f"http://www.knora.org/ontology/{shortcode}/{onto_name}"] = onto_shorthand
+    return prefixes_knora_base_inverted
+
+
+def _categorize_doaps(project_doaps: list[dict[str, Any]]) -> DoapCategories:
+    """
+    The overrule object of the JSON project definition file has 2 categories: private and limited_view.
+    - "private" is a list of classes/properties that are private.
+      The DOAPs for these correspond 1:1 to the classes/properties.
+    - "limited_view" is
+        - a list of image classes that are limited_view:
+          The DOAPs for these are for knora-api:hasStillImageFileValue and the respective class.
+        - or the string "all". The DOAPs for these are only for knora-api:hasStillImageFileValue.
+
+    This function groups the DOAPs into these categories.
+
+    Args:
+        project_doaps: the DOAPs as retrieved from the server
+
+    Raises:
+        UnknownDOAPException: if there are DOAPs that do not fit into our system
+
+    Returns:
+        a DTO with the categories
+    """
+    class_doaps = []
+    prop_doaps = []
+    has_img_all_classes_doaps = []
+    has_img_specific_class_doaps = []
+    other_doaps = []
+    for doap in project_doaps:
+        match (doap.get("forResourceClass"), doap.get("forProperty")):
+            case (for_class, None) if for_class:
+                class_doaps.append(doap)
+            case (None, for_prop) if for_prop and "hasStillImageFileValue" not in for_prop:
+                prop_doaps.append(doap)
+            case (None, for_prop) if for_prop and "hasStillImageFileValue" in for_prop:
+                has_img_all_classes_doaps.append(doap)
+            case (for_class, for_prop) if for_class and for_prop and "hasStillImageFileValue" in for_prop:
+                has_img_specific_class_doaps.append(doap)
+            case _:
+                other_doaps.append(doap)
+    # Only validate other_doaps if there are any
+    if other_doaps:
+        try:
+            _parse_default_permissions(other_doaps)
+        except UnknownDOAPException:
+            raise UnknownDOAPException("Found DOAPs that do not fit into our system") from None
+    return DoapCategories(
+        class_doaps=class_doaps,
+        prop_doaps=prop_doaps,
+        has_img_all_classes_doaps=has_img_all_classes_doaps,
+        has_img_specific_class_doaps=has_img_specific_class_doaps,
+    )
+
+
+def _validate_doap_categories(doap_categories: DoapCategories) -> None:
+    for expected_private_doap in doap_categories.class_doaps + doap_categories.prop_doaps:
+        perm = sorted(expected_private_doap["hasPermissions"], key=lambda x: x["name"])
+        if len(perm) != 2:
+            raise UnknownDOAPException("'private' is defined as CR ProjectAdmin|D ProjectMember")
+        CR, D = perm
+        if CR["name"] != "CR" or not CR["additionalInformation"].endswith("ProjectAdmin"):
+            raise UnknownDOAPException("'private' is defined as CR ProjectAdmin|D ProjectMember")
+        if D["name"] != "D" or not D["additionalInformation"].endswith("ProjectMember"):
+            raise UnknownDOAPException("'private' is defined as CR ProjectAdmin|D ProjectMember")
+
+    for expected_limited_view in (
+        doap_categories.has_img_all_classes_doaps + doap_categories.has_img_specific_class_doaps
+    ):
+        err_msg = "'limited_view' is defined as CR ProjectAdmin|D ProjectMember|RV KnownUser|RV UnknownUser"
+        perm = sorted(expected_limited_view["hasPermissions"], key=lambda x: x["name"])
+        if len(perm) != 4:
+            raise UnknownDOAPException(err_msg)
+        CR, D, RV1, RV2 = perm
+        if CR["name"] != "CR" or not CR["additionalInformation"].endswith("ProjectAdmin"):
+            raise UnknownDOAPException(err_msg)
+        if D["name"] != "D" or not D["additionalInformation"].endswith("ProjectMember"):
+            raise UnknownDOAPException(err_msg)
+        if RV1["name"] != "RV" or not RV2["additionalInformation"].endswith("nownUser"):
+            raise UnknownDOAPException(err_msg)
+        if RV2["name"] != "RV" or not RV2["additionalInformation"].endswith("nownUser"):
+            raise UnknownDOAPException(err_msg)
+
+
+def _construct_overrule_object(
+    doap_categories: DoapCategories, prefixes_knora_base_inverted: dict[str, str]
+) -> dict[str, list[str] | Literal["all"]]:
+    """
+    Construct the final overrules object that can be written into the JSON project definition file.
+    To do so, the fully qualified IRIs of the classes/properties must be converted to prefixed IRIs.
+
+    Args:
+        doap_categories: The categorized DOAPs from the server
+        prefixes_knora_base_inverted: lookup from fully qualified IRIs to prefixed IRIs
+
+    Raises:
+        UnknownDOAPException: if the DOAPs do not fit into our system
+
+    Returns:
+        the final overrules object that can be written into the JSON project definition file
+    """
+    privates: list[str] = []
+    for class_doap in doap_categories.class_doaps:
+        privates.append(_get_prefixed_iri(class_doap["forResourceClass"], prefixes_knora_base_inverted))
+    for prop_doap in doap_categories.prop_doaps:
+        privates.append(_get_prefixed_iri(prop_doap["forProperty"], prefixes_knora_base_inverted))
+
+    limited_views: list[str] | Literal["all"]
+    if len(doap_categories.has_img_all_classes_doaps) > 1:
+        raise UnknownDOAPException("There can only be 1 all-images DOAP for 'hasStillImageFileValue'")
+    if len(doap_categories.has_img_all_classes_doaps) == 1 and len(doap_categories.has_img_specific_class_doaps) > 0:
+        raise UnknownDOAPException("If there is a DOAP for all images, there cannot be DOAPs for specific img classes")
+    if len(doap_categories.has_img_all_classes_doaps) == 1:
+        limited_views = "all"
+    else:
+        limited_views = []
+        for img_doap in doap_categories.has_img_specific_class_doaps:
+            limited_views.append(_get_prefixed_iri(img_doap["forResourceClass"], prefixes_knora_base_inverted))
+
+    result: dict[str, list[str] | Literal["all"]] = {}
+    if privates:
+        result["private"] = privates
+    if limited_views:
+        result["limited_view"] = limited_views
+    return result
+
+
+def _get_prefixed_iri(full_iri: str, prefixes_inverted: dict[str, str]) -> str:
+    # example:
+    #    - full_iri = "http://www.knora.org/ontology/1234/my-onto/v2#MyClass"
+    #    - prefixes_inverted = {"http://www.knora.org/ontology/1234/my-onto": "my-onto"}
+    #    - output = "my-onto:MyClass"
+    if "#" not in full_iri:
+        raise ValueError(f"{full_iri} is not a valid full IRI")
+    before_hashtag, after_hashtag = full_iri.rsplit("#", maxsplit=1)
+    if before_hashtag not in prefixes_inverted:
+        raise ValueError(f"{full_iri} belongs to an unknown ontology. It cannot be found in the prefixes.")
+    prefix = prefixes_inverted[before_hashtag]
+    return f"{prefix}:{after_hashtag}"

dsp_tools/commands/get/get_permissions_legacy.py

@@ -0,0 +1,89 @@
+from typing import Any
+from typing import Literal
+
+
+def parse_legacy_doaps(project_doaps: list[dict[str, Any]]) -> Literal["public", "private"] | None:
+    """
+    Check if DOAPs match one of the legacy patterns.
+
+    Legacy private:
+    - For group ProjectAdmin: ProjectAdmin CR, ProjectMember CR/M
+    - For group ProjectMember: ProjectAdmin CR, ProjectMember CR/M
+
+    Legacy public:
+    - For group ProjectAdmin: ProjectAdmin CR, (optionally: Creator CR), ProjectMember D/M, KnownUser V, UnknownUser V
+    - For group ProjectMember: ProjectAdmin CR, (optionally: Creator CR), ProjectMember D/M, KnownUser V, UnknownUser V
+    """
+    if len(project_doaps) != 2:
+        return None
+    admin_doaps = [x for x in project_doaps if x.get("forGroup", "").endswith("ProjectAdmin")]
+    member_doaps = [x for x in project_doaps if x.get("forGroup", "").endswith("ProjectMember")]
+    if len(admin_doaps) != 1 or len(member_doaps) != 1:
+        return None
+
+    admin_perms = admin_doaps[0]["hasPermissions"]
+    member_perms = member_doaps[0]["hasPermissions"]
+    if all([_is_legacy_private(admin_perms), _is_legacy_private(member_perms)]):
+        return "private"
+    if all([_is_legacy_public(admin_perms), _is_legacy_public(member_perms)]):
+        return "public"
+
+    return None
+
+
+def _is_legacy_private(perms: list[dict[str, Any]]) -> bool:
+    """
+    Check if permissions match the legacy private pattern: ProjectAdmin CR, ProjectMember M/D
+
+    Args:
+        perms: List of permission objects
+    """
+    if len(perms) != 2:
+        return False
+
+    sorted_perms = sorted(perms, key=lambda x: x.get("name", ""))
+
+    # First should be CR for ProjectAdmin
+    if sorted_perms[0]["name"] != "CR" or not sorted_perms[0]["additionalInformation"].endswith("ProjectAdmin"):
+        return False
+
+    # Second should be D or M for ProjectMember
+    if sorted_perms[1]["name"] not in ["D", "M"] or not sorted_perms[1]["additionalInformation"].endswith(
+        "ProjectMember"
+    ):
+        return False
+
+    return True
+
+
+def _is_legacy_public(perms: list[dict[str, Any]]) -> bool:
+    """
+    Check if permissions match the public pattern:
+    ProjectAdmin CR, (optionally: Creator CR), ProjectMember D/M, KnownUser V, UnknownUser V
+    """
+    # Should have exactly 4 permissions after filtering out Creator
+    filtered_perms = [p for p in perms if not p["additionalInformation"].endswith("Creator")]
+    if len(filtered_perms) != 4:
+        return False
+
+    sorted_perms = sorted(filtered_perms, key=lambda x: x.get("name", ""))
+
+    # First should be CR for ProjectAdmin
+    if sorted_perms[0]["name"] != "CR" or not sorted_perms[0]["additionalInformation"].endswith("ProjectAdmin"):
+        return False
+
+    # Second should be D or M for ProjectMember
+    if sorted_perms[1]["name"] not in ["D", "M"] or not sorted_perms[1]["additionalInformation"].endswith(
+        "ProjectMember"
+    ):
+        return False
+
+    # Third/Fourth should be V for KnownUser
+    if sorted_perms[2]["name"] != "V" or not sorted_perms[2]["additionalInformation"].endswith("nownUser"):
+        return False
+
+    # Third/Fourth should be V for UnknownUser
+    if sorted_perms[3]["name"] != "V" or not sorted_perms[3]["additionalInformation"].endswith("nownUser"):
+        return False
+
+    return True