event_handlers

class BaseAction(BaseHandler):
    """Custom Action base class.

    Simplify action discovery and launch. This implementation represents
    single action with single callback. To change the behavior implement
    custom callbacks or override '_discover' and '_launch' methods.

    Attributes:
        label (str): Label of action of group name of action. Can be combined
            with 'variant' attribute.
        variant (str): Variant under 'label'. Can be combined with 'label' e.g.
            when 'label' is "Admin" and variant is "Kill jobs". In case
            there is more variants for "Admin" label they'll grouped in ftrack
            UI widgets.
        identifier (str): Action identifier. Is used to trigger the launch
            logic of action.
        icon (str): Url to icon (Browser which should show the icon must have
            access to the resource).
        description (str): Hint of action which is showed to user hovering
            over the action.

    Args:
        session (ftrack_api.Session): Connected ftrack session.

    """
    __ignore_handler_class = True

    label: Optional[str] = None
    variant: Optional[str] = None
    identifier: Optional[str] = None
    description: Optional[str] = None
    icon: Optional[str] = None
    handler_type: str = "Action"
    preactions: List[str] = []

    _full_label: Optional[str] = None
    _discover_identifier: Optional[str] = None
    _launch_identifier: Optional[str] = None

    settings_frack_subkey: str = "user_handlers"
    settings_enabled_key: str = "enabled"

    def __init__(self, session: ftrack_api.Session):
        # Validate minimum requirements
        if not self.label:
            raise ValueError("Action missing 'label'.")

        if not self.identifier:
            raise ValueError("Action missing 'identifier'.")

        super().__init__(session)
        self.setup_launch_wrapper()

    def setup_launch_wrapper(self):
        self._launch = self.launch_wrapper(self._launch)

    @property
    def discover_identifier(self) -> str:
        return self.identifier

    @property
    def launch_identifier(self) -> str:
        return self.identifier

    @property
    def handler_label(self) -> str:
        return self.full_label

    @property
    def full_label(self) -> str:
        """Full label of action.

        Value of full label is cached.

        Returns:
            str: Label created from 'label' and 'variant' attributes.

        """
        if self._full_label is None:
            if self.variant:
                label = "{} {}".format(self.label, self.variant)
            else:
                label = self.label
            self._full_label = label
        return self._full_label

    def register(self):
        """Register to ftrack topics to discover and launch action."""
        self.session.event_hub.subscribe(
            "topic=ftrack.action.discover",
            self._discover,
            priority=self.priority
        )

        launch_subscription = (
            "topic=ftrack.action.launch and data.actionIdentifier={}"
        ).format(self.launch_identifier)
        self.session.event_hub.subscribe(launch_subscription, self._launch)

    def _translate_event(
        self,
        event: ftrack_api.event.base.Event,
        session: Optional[ftrack_api.Session] = None
    ) -> List[ftrack_api.entity.base.Entity]:
        """Translate event to receive entities based on it's data."""
        if session is None:
            session = self.session

        _entities = event["data"].get("entities_object", None)
        if _entities is not None and not _entities:
            return _entities

        if (
            _entities is None
            or _entities[0].get("link") == ftrack_api.symbol.NOT_SET
        ):
            _entities = [
                item
                for item in self._get_entities(event, session=session)
                if item is not None
            ]
            event["data"]["entities_object"] = _entities

        return _entities

    def _discover(
        self, event: ftrack_api.event.base.Event
    ) -> Optional[Dict[str, Any]]:
        """Decide if and how will be action showed to user in ftrack.

        Args:
            event (ftrack_api.Event): Event with topic which triggered this
                callback.

        Returns:
            Union[None, Dict[str, Any]]: None if action is not returned
                otherwise returns items to show in UI (structure of items is
                defined by ftrack and can be found in documentation).

        """
        entities = self._translate_event(event)
        if not entities:
            return None

        accepts = self.discover(self.session, entities, event)
        if not accepts:
            return None

        self.log.debug("Discovering action with selection: {}".format(
            event["data"].get("selection") or []
        ))

        return {
            "items": [{
                "label": self.label,
                "variant": self.variant,
                "description": self.description,
                "actionIdentifier": self.discover_identifier,
                "icon": self.icon,
            }]
        }

    def discover(
        self,
        session: ftrack_api.Session,
        entities: List[ftrack_api.entity.base.Entity],
        event: ftrack_api.event.base.Event,
    ) -> bool:
        """Decide if action is showed to used based on event data.

        Action should override the method to implement logic to show the
        action. The most common logic is based on combination of user roles
        and selected entities.

        Args:
            session (ftrack_api.Session): Session which triggered callback of
                the event.
            entities (List[Any]): Prepared list of entities from event data.
            event (ftrack_api.Event): ftrack event which caused this callback
                is triggered.

        Returns:
            bool: True if action should be returned.

        """
        return False

    def _handle_preactions(
        self, session: ftrack_api.Session, event: ftrack_api.event.base.Event
    ) -> bool:
        """Launch actions before launching this action.

        Concept came from Pype and got deprecated (and used) over time. Should
        be probably removed.

        Note:
            Added warning log that this functionlity is deprecated and will
                be removed in the future.

        Args:
            session (ftrack_api.Session): ftrack session.
            event (ftrack_api.Event): Event which triggered launch of this
                action.

        Returns:
            bool: Preactions were launched or not.

        Deprecated:
            Preactions are marked as deprecated. Server actions should not
                use preactions and local actions use local identifier which
                is hard to handle automatically

        """
        # If preactions are not set
        if len(self.preactions) == 0:
            return True

        if not event.get("data", {}).get("selection"):
            return False

        # If preactions were already started
        if event["data"].get("preactions_launched") is True:
            return True

        self.log.warning((
            "DEPRECATION WARNING: Action \"{}\" is using 'preactions'"
            " which are deprecated and will be removed Q2 2023."
        ).format(self.full_label))

        # Launch preactions
        for preaction in self.preactions:
            self.trigger_action(preaction, event)

        # Relaunch this action
        self.trigger_action(
            self.launch_identifier,
            event,
            additional_event_data={"preactions_launched": True}
        )
        return False

    def launch_wrapper(self, func):
        @functools.wraps(func)
        def wrapper_func(*args, **kwargs):
            self.log.info("{} \"{}\": Launched".format(
                self.handler_type, self.full_label
            ))

            try:
                output = func(*args, **kwargs)
                self.log.info("{} \"{}\": Finished".format(
                    self.handler_type, self.full_label
                ))

            except BaseException as exc:
                self.session.rollback()
                self.session._configure_locations()
                msg = "{} \"{}\": Failed ({})".format(
                    self.handler_type, self.full_label, str(exc))
                self.log.error(msg, exc_info=True)
                output = {
                    "success": False,
                    "message": msg
                }

            return output
        return wrapper_func

    def _launch(
        self, event: ftrack_api.event.base.Event
    ) -> Optional[Dict[str, Any]]:
        entities = self._translate_event(event)
        if not entities:
            return

        preactions_launched = self._handle_preactions(self.session, event)
        if preactions_launched is False:
            return

        interface = self._interface(self.session, entities, event)
        if interface:
            return interface

        response = self.launch(self.session, entities, event)

        return self._handle_result(response)

    def launch(
        self,
        session: ftrack_api.Session,
        entities: List[ftrack_api.entity.base.Entity],
        event: ftrack_api.event.base.Event
    ) -> Optional[Union[bool, Dict[str, Any]]]:
        """Main part of handling event callback.

        Args:
            session (ftrack_api.Session): Session which queried entities.
            entities (List[Any]): Prequeried entities based on event data.
            event (ftrack_api.Event): ftrack event to process.

        Returns:
            Union[bool, Dict[str, Any]]: True or false for success or fail,
                or more complex data structure e.g. to show interface to user.

        """
        raise NotImplementedError()

    def _interface(
        self,
        session: ftrack_api.Session,
        entities: List[ftrack_api.entity.base.Entity],
        event: ftrack_api.event.base.Event
    ) -> Optional[Dict[str, Any]]:
        interface = self.interface(session, entities, event)
        if not interface:
            return

        if isinstance(interface, (tuple, list)):
            return {"items": interface}

        if isinstance(interface, dict):
            if (
                "items" in interface
                or ("success" in interface and "message" in interface)
            ):
                return interface

            raise ValueError((
                "Invalid interface output expected key: \"items\" or keys:"
                " \"success\" and \"message\". Got: \"{}\""
            ).format(str(interface)))

        raise ValueError(
            "Invalid interface output type \"{}\"".format(
                str(type(interface))
            )
        )

    def interface(
        self,
        session: ftrack_api.Session,
        entities: List[ftrack_api.entity.base.Entity],
        event: ftrack_api.event.base.Event
    ) -> Optional[Union[Dict[str, Any], List[Dict[str, Any]]]]:
        """Show an interface to user befor the action is processed.

        This is part of launch callback which gives option to return ftrack
        widgets items. These items are showed to user which can fill/change
        values and submit them.

        Interface must in that case handle if event contains values from user.

        Args:
            session (ftrack_api.Session): Connected ftrack api session.
            entities (List[Any]): Entities on which was action triggered.
            event (ftrack_api.Event): Event which triggered launch callback.

        Returns:
            Union[None, List[Dict[str, Any], Dict[str, Any]]: None if nothing
                should be showed, list of items to show or dictionary with
                'items' key and possibly additional data
                (e.g. submit button label).

        """
        return None

    def _handle_result(self, result: Any) -> Optional[Dict[str, Any]]:
        """Validate the returned result from the action callback."""
        if not result:
            return None

        if isinstance(result, dict):
            if "items" in result:
                if not isinstance(result["items"], list):
                    raise TypeError(
                        "Invalid items type {} expected list".format(
                            str(type(result["items"]))))
                return result

            if "success" not in result and "message" not in result:
                self.log.error((
                    "{} \"{}\" Missing required keys"
                    " \"success\" and \"message\" in callback output. This is"
                    " soft fail."
                ).format(self.handler_type, self.full_label))

            elif "message" in result:
                if "success" not in result:
                    result["success"] = True
                return result

            # Fallback to 'bool' result
            result = result.get("success", True)

        if isinstance(result, bool):
            if result:
                return {
                    "success": True,
                    "message": "{} finished.".format(self.full_label)
                }
            return {
                "success": False,
                "message": "{} failed.".format(self.full_label)
            }

        return result

    @staticmethod
    def roles_check(
        settings_roles: List[str],
        user_roles: List[str],
        default: Optional[bool] = True
    ) -> bool:
        """Compare roles from setting and user's roles.

        Args:
            settings_roles(list): List of role names from settings.
            user_roles(list): User's lowered role names.
            default(bool): If 'settings_roles' is empty list.

        Returns:
            bool: 'True' if user has at least one role from settings or
                default if 'settings_roles' is empty.

        """
        if not settings_roles:
            return default

        user_roles = {
            role_name.lower()
            for role_name in user_roles
        }
        for role_name in settings_roles:
            if role_name.lower() in user_roles:
                return True
        return False

    @classmethod
    def get_user_entity_from_event(
        cls,
        session: ftrack_api.Session,
        event: ftrack_api.event.base.Event
    ) -> Optional[ftrack_api.entity.user.User]:
        """Query user entity from event."""

        not_set = object()

        # Check if user is already stored in event data
        user_entity = event["data"].get("user_entity", not_set)
        if user_entity is not_set:
            # Query user entity from event
            user_info = event.get("source", {}).get("user", {})
            user_id = user_info.get("id")
            username = user_info.get("username")
            if user_id:
                user_entity = session.query(
                    "User where id is {}".format(user_id)
                ).first()
            if not user_entity and username:
                user_entity = session.query(
                    "User where username is {}".format(username)
                ).first()
            event["data"]["user_entity"] = user_entity

        return user_entity

    @classmethod
    def get_user_roles_from_event(
        cls,
        session: ftrack_api.Session,
        event: ftrack_api.event.base.Event,
        lower: Optional[bool] = False
    ) -> List[str]:
        """Get user roles based on data in event.

        Args:
            session (ftrack_api.Session): Prepared ftrack session.
            event (ftrack_api.event.Event): Event which is processed.
            lower (Optional[bool]): Lower the role names. Default 'False'.

        Returns:
            List[str]: List of user roles.

        """
        not_set = object()

        user_roles = event["data"].get("user_roles", not_set)
        if user_roles is not_set:
            user_roles = []
            user_entity = cls.get_user_entity_from_event(session, event)
            for role in user_entity["user_security_roles"]:
                role_name = role["security_role"]["name"]
                if lower:
                    role_name = role_name.lower()
                user_roles.append(role_name)
            event["data"]["user_roles"] = user_roles
        return user_roles

    def get_project_name_from_event_with_entities(
        self,
        session: ftrack_api.Session,
        event: ftrack_api.event.base.Event,
        entities: List[ftrack_api.entity.base.Entity],
    ) -> Optional[str]:
        """Load or query and fill project entity from/to event data.

        Project data are stored by ftrack id because in most cases it is
        easier to access project id than project name.

        Args:
            session (ftrack_api.Session): Current session.
            event (ftrack_api.Event): Processed event by session.
            entities (List[Any]): ftrack entities of selection.

        Returns:
            Optional[str]: Project name from event data.

        """
        # Try to get project entity from event
        project_name = event["data"].get("project_name")
        if not project_name:
            project_entity = self.get_project_from_entity(
                entities[0], session
            )
            project_name = project_entity["full_name"]

            event["data"]["project_name"] = project_name
        return project_name

    def get_ftrack_settings(
        self,
        session: ftrack_api.Session,
        event: ftrack_api.event.base.Event,
        entities: List[ftrack_api.entity.base.Entity],
    ) -> Dict[str, Any]:
        project_name = self.get_project_name_from_event_with_entities(
            session, event, entities
        )
        project_settings = self.get_project_settings_from_event(
            event, project_name
        )
        return project_settings["ftrack"]

    def valid_roles(
        self,
        session: ftrack_api.Session,
        entities: List[ftrack_api.entity.base.Entity],
        event: ftrack_api.event.base.Event,
    ) -> bool:
        """Validate user roles by settings.

        Method requires to have set `settings_key` attribute.
        """
        ftrack_settings = self.get_ftrack_settings(session, event, entities)
        settings = (
            ftrack_settings[self.settings_frack_subkey][self.settings_key]
        )
        if self.settings_enabled_key:
            if not settings.get(self.settings_enabled_key, True):
                return False

        user_role_list = self.get_user_roles_from_event(session, event)
        if not self.roles_check(settings.get("role_list"), user_role_list):
            return False
        return True

class BaseEventHandler(BaseHandler):
    """Event handler listening to topics.

    Output of callback is not handled and handler is not designed for actions.

    By default is listening to "ftrack.update". To change it override
    'register' method of change 'subscription_topic' attribute.
    """
    __ignore_handler_class: bool = True

    subscription_topic: str = "ftrack.update"
    handler_type: str = "Event"

    def register(self):
        """Register to subscription topic."""
        self.session.event_hub.subscribe(
            "topic={}".format(self.subscription_topic),
            self._process,
            priority=self.priority
        )

    def process(self, event: ftrack_api.event.base.Event):
        """Callback triggered on event with matching topic.

        Args:
            event (ftrack_api.Event): ftrack event to process.

        """
        return self.launch(self.session, event)


    def launch(
        self,
        session: ftrack_api.Session,
        event: ftrack_api.event.base.Event
    ):
        """Deprecated method used for backwards compatibility.

        Override 'process' method rather then 'launch'. Method name 'launch'
        is derived from action event handler which does not make sense in terms
        of not action based processing.

        Args:
            session (ftrack_api.Session): ftrack session which triggered
                the event.
            event (ftrack_api.Event): ftrack event to process.

        """
        raise NotImplementedError()

    def _process(self, event: ftrack_api.event.base.Event):
        return self._launch(event)

    def _launch(self, event: ftrack_api.event.base.Event):
        """Callback kept for backwards compatibility.

        Will be removed when default
        """
        self.session.rollback()
        self.session._local_cache.clear()

        try:
            self.process(event)

        except Exception as exc:
            self.log.error(
                "Event \"{}\" Failed: {}".format(
                    self.__class__.__name__, str(exc)
                ),
                exc_info=True
            )
            self.session.rollback()
            self.session._configure_locations()

    def _translate_event(
        self,
        event: ftrack_api.event.base.Event,
        session: Optional[ftrack_api.Session] = None
    ):
        """Receive entity objects based on event.

        Args:
            event (ftrack_api.Event): Event to process.
            session (ftrack_api.Session): Connected ftrack session.

        Returns:
            List[ftrack_api.Entity]: Queried entities based on event data.

        """
        return self._get_entities(
            event,
            session,
            ignore=["socialfeed", "socialnotification", "team"]
        )

class BaseHandler(metaclass=ABCMeta):
    """Base class for handling ftrack events.

    Attributes:
        enabled (bool): Is handler enabled.
        priority (int): Priority of handler processing. The lower value is the
            earlier is handler processed.
        handler_type (str): Has only debugging purposes.

    Args:
        session (ftrack_api.Session): Connected ftrack session.

    """
    _log: Optional[logging.Logger] = None
    _process_id: Optional[str] = None
    # Default priority is 100
    enabled: bool = True
    priority: int = 100
    handler_type: str = "Base"
    _handler_label: Optional[str] = None
    # Mark base classes to be ignored for discovery
    __ignore_handler_class: bool = True

    def __init__(self, session):
        if not isinstance(session, ftrack_api.session.Session):
            raise TypeError(
                "Expected 'ftrack_api.Session' object got '{}'".format(
                    str(type(session))))

        self._session = session

        self.register = self.register_wrapper(self.register)

    @classmethod
    def ignore_handler_class(cls) -> bool:
        """Check if handler class should be ignored.

        Do not touch implementation of this method, set
            '__ignore_handler_class' to 'True' if you want to ignore class.

        """
        cls_name = cls.__name__
        if not cls_name.startswith("_"):
            cls_name = f"_{cls_name}"
        return getattr(cls, f"{cls_name}__ignore_handler_class", False)

    @staticmethod
    def join_filter_values(values: Iterable[str]) -> str:
        return ",".join({'"{}"'.format(value) for value in values})

    @classmethod
    def join_query_keys(cls, keys: Iterable[str]) -> str:
        return cls.join_filter_values(keys)

    @property
    def log(self) -> logging.Logger:
        """Quick access to logger.

        Returns:
            logging.Logger: Logger that can be used for logging of handler.

        """
        if self._log is None:
            # TODO better logging mechanism
            self._log = logging.getLogger(self.__class__.__name__)
            self._log.setLevel(logging.DEBUG)
        return self._log

    @property
    def handler_label(self) -> str:
        if self._handler_label is None:
            self._handler_label = self.__class__.__name__
        return self._handler_label

    @property
    def session(self) -> ftrack_api.Session:
        """Fast access to session.

        Returns:
            session (ftrack_api.Session): Session which is source of events.

        """
        return self._session

    def reset_session(self):
        """Reset session cache."""
        self.session.reset()

    @staticmethod
    def process_identifier() -> str:
        """Helper property to have unified access to process id.

        Todos:
            Use some global approach rather then implementation on
                'BaseEntity'.

        """
        if not BaseHandler._process_id:
            BaseHandler._process_id = str(uuid.uuid4())
        return BaseHandler._process_id

    @abstractmethod
    def register(self):
        """Subscribe to event topics."""
        pass

    def cleanup(self):
        """Cleanup handler.

        This method should end threads, timers, close connections, etc.
        """
        pass

    def register_wrapper(self, func):
        @functools.wraps(func)
        def wrapper_register(*args, **kwargs):
            if not self.enabled:
                return

            try:
                start_time = time.perf_counter()
                func(*args, **kwargs)
                end_time = time.perf_counter()
                run_time = end_time - start_time
                self.log.info((
                    "{} \"{}\" - Registered successfully ({:.4f}sec)"
                ).format(self.handler_type, self.handler_label, run_time))

            except NotImplementedError:
                self.log.error((
                    "{} \"{}\" - Register method is not implemented"
                ).format(self.handler_type, self.handler_label))

            except Exception as exc:
                self.log.error("{} \"{}\" - Registration failed ({})".format(
                    self.handler_type, self.handler_label, str(exc)
                ))
        return wrapper_register

    def _get_entities(self, event, session=None, ignore=None):
        entities = []
        selection = event["data"].get("selection")
        if not selection:
            return entities

        if ignore is None:
            ignore = []
        elif isinstance(ignore, str):
            ignore = [ignore]

        filtered_selection = []
        for entity in selection:
            if entity["entityType"] not in ignore:
                filtered_selection.append(entity)

        if not filtered_selection:
            return entities

        if session is None:
            session = self.session
            session._local_cache.clear()

        for entity in filtered_selection:
            entities.append(session.get(
                self._get_entity_type(entity, session),
                entity.get("entityId")
            ))

        return entities

    def _get_entity_type(self, entity, session=None):
        """Translate entity type so it can be used with API.

        Todos:
            Use object id rather.

        """
        # Get entity type and make sure it is lower cased. Most places except
        # the component tab in the Sidebar will use lower case notation.
        entity_type = entity.get("entityType").replace("_", "").lower()

        if session is None:
            session = self.session

        for schema in session.schemas:
            alias_for = schema.get("alias_for")

            if (
                alias_for
                and isinstance(alias_for, str)
                and alias_for.lower() == entity_type
            ):
                return schema["id"]

        for schema in self.session.schemas:
            if schema["id"].lower() == entity_type:
                return schema["id"]

        raise ValueError(
            "Unable to translate entity type: {0}.".format(entity_type)
        )

    def show_message(
        self,
        event: ftrack_api.event.base.Event,
        message: str,
        success: Optional[bool]=False,
    ):
        """Shows message to user who triggered event.

        Args:
            event (ftrack_api.event.base.Event): Event used for source
                of user id.
            message (str): Message that will be shown to user.
            success (bool): Define type (color) of message. False -> red color.

        """
        if not isinstance(success, bool):
            success = False

        try:
            message = str(message)
        except Exception:
            return

        user_id = event["source"]["user"]["id"]
        target = (
            "applicationId=ftrack.client.web and user.id=\"{}\""
        ).format(user_id)
        self.session.event_hub.publish(
            ftrack_api.event.base.Event(
                topic="ftrack.action.trigger-user-interface",
                data={
                    "type": "message",
                    "success": success,
                    "message": message
                },
                target=target
            ),
            on_error="ignore"
        )

    def show_interface(
        self,
        items: List[Dict[str, Any]],
        title: Optional[str] = "",
        user_id: Optional[str] = None,
        user: Optional[Any] = None,
        event: Optional[ftrack_api.event.base.Event] = None,
        username: Optional[str] = None,
        submit_btn_label: Optional[str] = None,
    ):
        """Shows ftrack widgets interface to user.

        Interface is shown to a user. To identify user one of arguments must be
        passed: 'user_id', 'user', 'event', 'username'.

        Args:
            items (List[Dict[str, Any]]) Interface items (their structure is
                defined by ftrack documentation).
            title (str): Title of shown widget.
            user_id (str): User id.
            user (Any): Object of ftrack user (queried using ftrack api
                session).
            event (ftrack_api.Event): Event which can be used as source for
                user id.
            username (str): Username of user to get it's id. This is slowest
                way how user id is received.
            submit_btn_label (str): Label of submit button in ftrack widget.

        """
        if user_id:
            pass

        elif user:
            user_id = user["id"]

        elif username:
            user = self.session.query(
                "User where username is \"{}\"".format(username)
            ).first()
            if not user:
                raise ValueError((
                    "ftrack user with username \"{}\" was not found!"
                ).format(username))

            user_id = user["id"]

        elif event:
            user_id = event["source"]["user"]["id"]

        if not user_id:
            return

        target = (
            "applicationId=ftrack.client.web and user.id=\"{}\""
        ).format(user_id)

        event_data = {
            "type": "widget",
            "items": items,
            "title": title
        }
        if submit_btn_label:
            event_data["submit_button_label"] = submit_btn_label

        self.session.event_hub.publish(
            ftrack_api.event.base.Event(
                topic="ftrack.action.trigger-user-interface",
                data=event_data,
                target=target
            ),
            on_error="ignore"
        )

    def show_interface_from_dict(
        self,
        messages: Dict[str, Union[str, List[str]]],
        title: Optional[str] = "",
        user_id: Optional[str] = None,
        user: Optional[Any] = None,
        event: Optional[ftrack_api.event.base.Event] = None,
        username: Optional[str] = None,
        submit_btn_label: Optional[str] = None,
    ):
        # TODO Find out how and where is this used
        if not messages:
            self.log.debug("No messages to show! (messages dict is empty)")
            return
        items = []
        splitter = {"type": "label", "value": "---"}
        first = True
        for key, value in messages.items():
            if not first:
                items.append(splitter)
            first = False

            items.append({"type": "label", "value": "<h3>{}</h3>".format(key)})
            if isinstance(value, str):
                value = [value]

            for item in value:
                items.append({"type": "label", "value": f"<p>{item}</p>"})

        self.show_interface(
            items,
            title=title,
            user_id=user_id,
            user=user,
            event=event,
            username=username,
            submit_btn_label=submit_btn_label
        )

    def trigger_action(
        self,
        action_identifier: str,
        event: Optional[ftrack_api.event.base.Event] = None,
        session: Optional[ftrack_api.Session] = None,
        selection: Optional[List[Dict[str, str]]] = None,
        user_data: Optional[Dict[str, Any]] = None,
        topic: Optional[str] = "ftrack.action.launch",
        additional_event_data: Optional[Dict[str, Any]] = None,
        on_error: Optional[str] = "ignore"
    ):
        self.log.debug(
            "Triggering action \"{}\" Begins".format(action_identifier))

        if not session:
            session = self.session

        # Getting selection and user data
        if event:
            if selection is None:
                selection = event.get("data", {}).get("selection")
            if user_data is None:
                user_data = event.get("source", {}).get("user")

        # Without selection and user data skip triggering
        msg = "Can't trigger \"{}\" action without {}."
        if selection is None:
            self.log.error(msg.format(action_identifier, "selection"))
            return

        if user_data is None:
            self.log.error(msg.format(action_identifier, "user data"))
            return

        event_data = {
            "actionIdentifier": action_identifier,
            "selection": selection
        }

        # Add additional data
        if additional_event_data:
            event_data.update(additional_event_data)

        # Create and trigger event
        session.event_hub.publish(
            ftrack_api.event.base.Event(
                topic=topic,
                data=event_data,
                source={"user": user_data}
            ),
            on_error=on_error
        )
        self.log.debug(
            "Action \"{}\" triggered".format(action_identifier))

    def trigger_event(
        self,
        topic: str,
        event_data: Optional[Dict[str, Any]] = None,
        session: Optional[ftrack_api.Session] = None,
        source: Optional[Dict[str, Any]] = None,
        event: Optional[ftrack_api.event.base.Event] = None,
        on_error: Optional[str] = "ignore"
    ):
        if session is None:
            session = self.session

        if not source and event:
            source = event.get("source")

        if event_data is None:
            event_data = {}
        # Create and trigger event
        event = ftrack_api.event.base.Event(
            topic=topic,
            data=event_data,
            source=source
        )
        session.event_hub.publish(event, on_error=on_error)

        self.log.debug((
            "Publishing event: {}"
        ).format(str(event.__dict__)))

    def get_project_from_entity(
        self,
        entity: ftrack_api.entity.base.Entity,
        session: Optional[ftrack_api.Session] = None
    ):
        low_entity_type = entity.entity_type.lower()
        if low_entity_type == "project":
            return entity

        if "project" in entity:
            # reviewsession, task(Task, Shot, Sequence,...)
            return entity["project"]

        if low_entity_type == "filecomponent":
            entity = entity["version"]
            low_entity_type = entity.entity_type.lower()

        if low_entity_type == "assetversion":
            asset = entity["asset"]
            parent = None
            if asset:
                parent = asset["parent"]

            if parent:
                if parent.entity_type.lower() == "project":
                    return parent

                if "project" in parent:
                    return parent["project"]

        project_data = entity["link"][0]

        if session is None:
            session = self.session
        return session.query(
            "Project where id is {}".format(project_data["id"])
        ).one()

    def get_project_entity_from_event(
        self,
        session: ftrack_api.Session,
        event: ftrack_api.event.base.Event,
        project_id: str,
    ):
        """Load or query and fill project entity from/to event data.

        Project data are stored by ftrack id because in most cases it is
        easier to access project id than project name.

        Args:
            session (ftrack_api.Session): Current session.
            event (ftrack_api.Event): Processed event by session.
            project_id (str): ftrack project id.

        Returns:
            Union[str, None]: Project name based on entities or None if project
                cannot be defined.

        """
        if not project_id:
            raise ValueError(
                "Entered `project_id` is not valid. {} ({})".format(
                    str(project_id), str(type(project_id))
                )
            )

        project_id_mapping = event["data"].setdefault(
            "project_entity_by_id", {}
        )
        if project_id in project_id_mapping:
            return project_id_mapping[project_id]

        # Get project entity from task and store to event
        project_entity = session.query((
            "select full_name from Project where id is \"{}\""
        ).format(project_id)).first()
        project_id_mapping[project_id] = project_entity

        return project_entity

    def get_project_name_from_event(
        self,
        session: ftrack_api.Session,
        event: ftrack_api.event.base.Event,
        project_id: str,
    ):
        """Load or query and fill project entity from/to event data.

        Project data are stored by ftrack id because in most cases it is
        easier to access project id than project name.

        Args:
            session (ftrack_api.Session): Current session.
            event (ftrack_api.Event): Processed event by session.
            project_id (str): ftrack project id.

        Returns:
            Union[str, None]: Project name based on entities or None if project
                cannot be defined.

        """
        if not project_id:
            raise ValueError(
                "Entered `project_id` is not valid. {} ({})".format(
                    str(project_id), str(type(project_id))
                )
            )

        project_id_mapping = event["data"].setdefault("project_id_name", {})
        if project_id in project_id_mapping:
            return project_id_mapping[project_id]

        # Get project entity from task and store to event
        project_entity = self.get_project_entity_from_event(
            session, event, project_id
        )
        if project_entity:
            project_name = project_entity["full_name"]
        project_id_mapping[project_id] = project_name
        return project_name

    def get_ayon_project_from_event(
        self,
        event: ftrack_api.event.base.Event,
        project_name: str
    ):
        """Get AYON project from event.

        Args:
            event (ftrack_api.Event): Event which is source of project id.
            project_name (Union[str, None]): Project name.

        Returns:
            Union[dict[str, Any], None]: AYON project.

        """
        ayon_projects = event["data"].setdefault("ayon_projects", {})
        if project_name in ayon_projects:
            return ayon_projects[project_name]

        project = None
        if project_name:
            project = get_project(project_name)
        ayon_projects[project_name] = project
        return project

    def get_project_settings_from_event(
        self,
        event: ftrack_api.event.base.Event,
        project_name: str
    ):
        """Load or fill AYON's project settings from event data.

        Project data are stored by ftrack id because in most cases it is
        easier to access project id than project name.

        Args:
            event (ftrack_api.Event): Processed event by session.
            project_name (str): Project name.

        """
        project_settings_by_name = event["data"].setdefault(
            "project_settings", {}
        )
        if project_name in project_settings_by_name:
            return copy.deepcopy(project_settings_by_name[project_name])

        # NOTE there is no safe way how to get project settings if project
        #   does not exist on AYON server.
        # TODO Should we somehow find out if ftrack is enabled for the
        #   project?
        # TODO how to find out which bundle should be used?
        project = self.get_ayon_project_from_event(event, project_name)
        if not project:
            project_name = None
        project_settings = get_addons_settings(project_name=project_name)
        project_settings_by_name[project_name] = project_settings
        return copy.deepcopy(project_settings)

    @staticmethod
    def get_entity_path(entity: ftrack_api.entity.base.Entity) -> str:
        """Return full hierarchical path to entity."""
        return "/".join(
            [ent["name"] for ent in entity["link"]]
        )

    @classmethod
    def add_traceback_to_job(
        cls,
        job: ftrack_api.entity.job.Job,
        session: ftrack_api.Session,
        exc_info: Tuple,
        description: Optional[str] = None,
        component_name: Optional[str] = None,
        job_status: Optional[str] = None
    ):
        """Add traceback file to a job.

        Args:
            job (JobEntity): Entity of job where file should be able to
                download (Created or queried with passed session).
            session (Session): ftrack session which was used to query/create
                entered job.
            exc_info (tuple): Exception info (e.g. from `sys.exc_info()`).
            description (str): Change job description to describe what
                happened. Job description won't change if not passed.
            component_name (str): Name of component and default name of
                downloaded file. Class name and current date time are used if
                not specified.
            job_status (str): Status of job which will be set. By default is
                set to 'failed'.

        """
        if description:
            job_data = {
                "description": description
            }
            job["data"] = json.dumps(job_data)

        if not job_status:
            job_status = "failed"

        job["status"] = job_status

        # Create temp file where traceback will be stored
        with tempfile.NamedTemporaryFile(
            mode="w", prefix="ayon_ftrack_", suffix=".txt", delete=False
        ) as temp_obj:
            temp_filepath = temp_obj.name

        # Store traceback to file
        result = traceback.format_exception(*exc_info)
        with open(temp_filepath, "w") as temp_file:
            temp_file.write("".join(result))

        # Upload file with traceback to ftrack server and add it to job
        if not component_name:
            component_name = "{}_{}".format(
                cls.__name__,
                datetime.datetime.now().strftime("%y-%m-%d-%H%M")
            )
        cls.add_file_component_to_job(
            job, session, temp_filepath, component_name
        )
        # Delete temp file
        os.remove(temp_filepath)

    @staticmethod
    def add_file_component_to_job(
        job: ftrack_api.entity.job.Job,
        session: ftrack_api.Session,
        filepath: str,
        basename: Optional[str] = None
    ):
        """Add filepath as downloadable component to job.

        Args:
            job (JobEntity): Entity of job where file should be able to
                download (Created or queried with passed session).
            session (Session): ftrack session which was used to query/create
                entered job.
            filepath (str): Path to file which should be added to job.
            basename (str): Defines name of file which will be downloaded on
                user's side. Must be without extension otherwise extension will
                be duplicated in downloaded name. Basename from entered path
                used when not entered.

        """
        # Make sure session's locations are configured
        # - they can be deconfigured e.g. using `rollback` method
        session._configure_locations()

        # Query `ftrack.server` location where component will be stored
        location = session.query(
            "Location where name is \"ftrack.server\""
        ).one()

        # Use filename as basename if not entered (must be without extension)
        if basename is None:
            basename = os.path.splitext(
                os.path.basename(filepath)
            )[0]

        component = session.create_component(
            filepath,
            data={"name": basename},
            location=location
        )
        session.create(
            "JobComponent",
            {
                "component_id": component["id"],
                "job_id": job["id"]
            }
        )
        session.commit()