workfile_template_builder

class MaxPlaceholderPlugin(PlaceholderPlugin):
    """Base Placeholder Plugin for 3ds Max with one unified cache.

    Creates a locator as placeholder node, which during populate provide
    all of its attributes defined on the locator's transform in
    `placeholder.data` and where `placeholder.scene_identifier` is the
    full path to the node.

    Inherited classes must still implement `populate_placeholder`

    """

    use_selection_as_parent = True
    item_class = PlaceholderItem

    def _create_placeholder_name(self, placeholder_data):
        return self.identifier.replace(".", "_")

    def _collect_scene_placeholders(self):
        nodes_by_identifier = self.builder.get_shared_populate_data(
            "placeholder_nodes"
        )
        if nodes_by_identifier is None:
            # Cache placeholder data to shared data
            nodes = [
                node for node in rt.Objects
                if rt.doesUserPropExist(node, "plugin_identifier")
            ]

            nodes_by_identifier = {}
            for node in nodes:
                identifier = rt.getUserProp(node, "plugin_identifier")
                nodes_by_identifier.setdefault(identifier, []).append(node.name)

            # Set the cache
            self.builder.set_shared_populate_data(
                "placeholder_nodes", nodes_by_identifier
            )

        return nodes_by_identifier

    def create_placeholder(self, placeholder_data):

        parent_object = None
        if self.use_selection_as_parent:
            selection = rt.getCurrentSelection()
            if len(selection) > 1:
                raise ValueError(
                    "More than one node is selected. "
                    "Please select only one to define the parent."
                )
            parent_object = selection[0] if selection else None

        placeholder_data["plugin_identifier"] = self.identifier
        placeholder_name = self._create_placeholder_name(placeholder_data)

        placeholder = rt.Container(name=placeholder_name)
        if parent_object:
            parent_object.children = placeholder
            imprinted_placeholder = parent_object.name
        else:
            imprinted_placeholder = placeholder.name

        self.imprint(imprinted_placeholder, placeholder_data)

    def update_placeholder(self, placeholder_item, placeholder_data):
        node_name = placeholder_item.scene_identifier

        changed_values = {}
        for key, value in placeholder_data.items():
            if value != placeholder_item.data.get(key):
                changed_values[key] = value

        # Delete attributes to ensure we imprint new data with correct type
        target_node = rt.getNodeByName(node_name)
        for key in changed_values.keys():
            placeholder_item.data[key] = value
            if rt.getUserProp(target_node, key) is not None:
                rt.deleteUserProp(target_node, key)

        self.imprint(node_name, changed_values)

    def collect_placeholders(self):
        placeholders = []
        nodes_by_identifier = self._collect_scene_placeholders()
        for node_name in nodes_by_identifier.get(self.identifier, []):
            # TODO do data validations and maybe upgrades if they are invalid
            node = rt.getNodeByName(node_name)
            placeholder_data = read(node)
            # Ensure order is converted to int for proper sorting
            if "order" in placeholder_data:
                placeholder_data["order"] = int(placeholder_data["order"])
            placeholders.append(
                self.item_class(scene_identifier=node_name,
                                data=placeholder_data,
                                plugin=self)
            )

        return placeholders

    def post_placeholder_process(self, placeholder, failed):
        """Cleanup placeholder after load of its corresponding representations.

        Hide placeholder, add them to placeholder set.
        Used only by PlaceholderCreateMixin and PlaceholderLoadMixin

        Args:
            placeholder (PlaceholderItem): Item which was just used to load
                representation.
            failed (bool): Loading of representation failed.
        """
        # Hide placeholder and add them to placeholder set
        node = placeholder.scene_identifier

        # If we just populate the placeholders from current scene, the
        # placeholder set will not be created so account for that.
        placeholder_set = rt.getNodebyName(PLACEHOLDER_SET)
        if placeholder_set:
            placeholder_set = rt.Container(name=PLACEHOLDER_SET)
        placeholder_set.children = node
        node.isHidden = True

    def delete_placeholder(self, placeholder):
        """Remove placeholder if building was successful

        Used only by PlaceholderCreateMixin and PlaceholderLoadMixin.
        """
        node = placeholder.scene_identifier
        node_to_removed = rt.getNodeByName(node)
        if node_to_removed:
            rt.Delete(node_to_removed)

    def imprint(self, node, data):
        """Imprint call for placeholder node"""

        # Complicated data that can't be represented as flat 3dsmax attributes
        # we write to json strings, e.g. multiselection EnumDef
        for key, value in data.items():
            if isinstance(value, (list, tuple, dict)):
                data[key] = "JSON::{}".format(json.dumps(value))

        imprint(node, data)

class MaxTemplateBuilder(AbstractTemplateBuilder):
    """Concrete implementation of AbstractTemplateBuilder for 3dsmax"""
    def import_template(self, path):
        """Import template into current scene.
        Block if a template is already loaded.

        Args:
            path (str): A path to current template (usually given by
            get_template_preset implementation)

        Returns:
            bool: Whether the template was successfully imported or not
        """
        if rt.getNodeByName(PLACEHOLDER_SET):
            raise TemplateAlreadyImported((
                "Build template already loaded\n"
                "Clean scene if needed (File > New Scene)"
            ))

        placeholder_container = rt.Container(name=PLACEHOLDER_SET)
        placeholder_container.isHidden = True

        filepath = Path(path)
        if not filepath.exists():
            return False
        rt.MergeMaxFile(
            filepath.as_posix(),
            rt.Name("deleteOldDups"),
            rt.Name("useMergedMtlDups"),
            quiet=True,
            includeFullGroup=True
        )
        max_objects = rt.getLastMergedNodes()
        if not max_objects:
            return True

        # update imported sets information
        update_content_on_context_change()
        return True