pipeline

def before_file_open():
    """check lock file when the file changed"""
    # delete the lock file
    _remove_workfile_lock()

def check_lock_on_current_file():

    """Check if there is a user opening the file"""
    if not handle_workfile_locks():
        return
    log.info("Running callback on checking the lock file...")

    # add the lock file when opening the file
    filepath = current_file()
    # Skip if current file is 'untitled'
    if not filepath:
        return

    if is_workfile_locked(filepath):
        # add lockfile dialog
        workfile_dialog = WorkfileLockDialog(filepath)
        if not workfile_dialog.exec_():
            cmds.file(new=True)
            return

    create_workfile_lock(filepath)

@lib.undo_chunk()
def containerise(name,
                 namespace,
                 nodes,
                 context,
                 loader=None,
                 suffix="CON"):
    """Bundle `nodes` into an assembly and imprint it with metadata

    Containerisation enables a tracking of version, author and origin
    for loaded assets.

    Arguments:
        name (str): Name of resulting assembly
        namespace (str): Namespace under which to host container
        nodes (list): Long names of nodes to containerise
        context (dict): Asset information
        loader (str, optional): Name of loader used to produce this container.
        suffix (str, optional): Suffix of container, defaults to `_CON`.

    Returns:
        container (str): Name of container assembly

    """
    container = cmds.sets(nodes, name="%s_%s_%s" % (namespace, name, suffix))

    data = [
        ("schema", "openpype:container-2.0"),
        ("id", AVALON_CONTAINER_ID),
        ("name", name),
        ("namespace", namespace),
        ("loader", loader),
        ("representation", context["representation"]["id"]),
        ("project_name", context["project"]["name"])
    ]
    for key, value in data:
        cmds.addAttr(container, longName=key, dataType="string")
        cmds.setAttr(container + "." + key, str(value), type="string")

    main_container = cmds.ls(AVALON_CONTAINERS, type="objectSet")
    if not main_container:
        main_container = cmds.sets(empty=True, name=AVALON_CONTAINERS)

        # Implement #399: Maya 2019+ hide AVALON_CONTAINERS on creation..
        if cmds.attributeQuery("hiddenInOutliner",
                               node=main_container,
                               exists=True):
            cmds.setAttr(main_container + ".hiddenInOutliner", True)
    else:
        main_container = main_container[0]

    cmds.sets(container, addElement=main_container)

    # Implement #399: Maya 2019+ hide containers in outliner
    if cmds.attributeQuery("hiddenInOutliner",
                           node=container,
                           exists=True):
        cmds.setAttr(container + ".hiddenInOutliner", True)

    return container

def ls():
    """Yields containers from active Maya scene

    This is the host-equivalent of api.ls(), but instead of listing
    assets on disk, it lists assets already loaded in Maya; once loaded
    they are called 'containers'

    Yields:
        dict[str, Any]: container

    """
    container_names = _ls()
    for container in sorted(container_names):
        container_data = parse_container(container)
        if container_data:
            yield container_data

def on_after_save():
    """Check if there is a lockfile after save"""
    check_lock_on_current_file()

def on_before_close():
    """Delete the lock file after user quitting the Maya Scene"""
    log.info("Closing Maya...")
    # delete the lock file
    filepath = current_file()
    if handle_workfile_locks():
        remove_workfile_lock(filepath)

def on_before_save():
    """Run validation for scene's FPS prior to saving"""
    return lib.validate_fps()

def on_new():
    """Set project resolution and fps when create a new file"""
    log.info("Running callback on new..")
    with lib.suspended_refresh():
        lib.set_context_settings()

    _remove_workfile_lock()

def on_open():
    """On scene open let's assume the containers have changed."""

    from ayon_core.tools.utils import SimplePopup

    # Validate FPS after update_task_from_path to
    # ensure it is using correct FPS for the folder
    lib.validate_fps()
    lib.fix_incompatible_containers()

    if any_outdated_containers():
        log.warning("Scene has outdated content.")

        # Find maya main window
        parent = lib.get_main_window()
        if parent is None:
            log.info("Skipping outdated content pop-up "
                     "because Maya window can't be found.")
        else:

            # Show outdated pop-up
            def _on_show_inventory():
                host_tools.show_scene_inventory(parent=parent)

            dialog = SimplePopup(parent=parent)
            dialog.setWindowTitle("Maya scene has outdated content")
            dialog.set_message("There are outdated containers in "
                              "your Maya scene.")
            dialog.on_clicked.connect(_on_show_inventory)
            dialog.show()

    # create lock file for the maya scene
    check_lock_on_current_file()

def on_save():
    """Automatically add IDs to new nodes

    Any transform of a mesh, without an existing ID, is given one
    automatically on file save.
    """
    log.info("Running callback on save..")
    # remove lockfile if users jumps over from one scene to another
    _remove_workfile_lock()

    # Generate ids of the current context on nodes in the scene
    nodes = lib.get_id_required_nodes(referenced_nodes=False,
                                      existing_ids=False)
    for node, new_id in lib.generate_ids(nodes):
        lib.set_id(node, new_id, overwrite=False)

    # We are now starting the actual save directly
    global _about_to_save
    _about_to_save = False

def on_task_changed():
    """Wrapped function of app initialize and maya's on task changed"""
    # Run
    menu.update_menu_task_label()

    workdir = os.getenv("AYON_WORKDIR")
    if os.path.exists(workdir):
        log.info("Updating Maya workspace for task change to %s", workdir)
        _set_project()

        # Set Maya fileDialog's start-dir to /scenes
        frule_scene = cmds.workspace(fileRuleEntry="scene")
        cmds.optionVar(stringValue=("browserLocationmayaBinaryscene",
                                    workdir + "/" + frule_scene))

    else:
        log.warning((
            "Can't set project for new context because path does not exist: {}"
        ).format(workdir))

    global _about_to_save
    if not lib.IS_HEADLESS and _about_to_save:
        # Let's prompt the user to update the context settings or not
        lib.prompt_reset_context()

def parse_container(container):
    """Return the container node's full container data.

    Args:
        container (str): A container node name.

    Returns:
        Optional[dict[str, Any]]: The container schema data for this container
         if it meets all the required metadata.

    """
    data = lib.read(container)

    required = ["id", "name", "namespace", "loader", "representation"]
    missing = [key for key in required if key not in data]
    if missing:
        log.warning("Container '%s' is missing required keys: %s",
                    container, missing)
        return

    # Backwards compatibility pre-schemas for containers
    data["schema"] = data.get("schema", "openpype:container-1.0")

    # Append transient data
    data["objectName"] = container

    return data

def workfile_save_before_xgen(event):
    """Manage Xgen external files when switching context.

    Xgen has various external files that needs to be unique and relative to the
    workfile, so we need to copy and potentially overwrite these files when
    switching context.

    Args:
        event (Event) - ayon_core/lib/events.py
    """
    if not cmds.pluginInfo("xgenToolkit", query=True, loaded=True):
        return

    import xgenm

    current_work_dir = os.getenv("AYON_WORKDIR").replace("\\", "/")
    expected_work_dir = event.data["workdir_path"].replace("\\", "/")
    if current_work_dir == expected_work_dir:
        return

    palettes = cmds.ls(type="xgmPalette", long=True)
    if not palettes:
        return

    transfers = []
    overwrites = []
    attribute_changes = {}
    attrs = ["xgFileName", "xgBaseFile"]
    for palette in palettes:
        sanitized_palette = palette.replace("|", "")
        project_path = xgenm.getAttr("xgProjectPath", sanitized_palette)
        _, maya_extension = os.path.splitext(event.data["filename"])

        for attr in attrs:
            node_attr = "{}.{}".format(palette, attr)
            attr_value = cmds.getAttr(node_attr)

            if not attr_value:
                continue

            source = os.path.join(project_path, attr_value)

            attr_value = event.data["filename"].replace(
                maya_extension,
                "__{}{}".format(
                    sanitized_palette.replace(":", "__"),
                    os.path.splitext(attr_value)[1]
                )
            )
            target = os.path.join(expected_work_dir, attr_value)

            transfers.append((source, target))
            attribute_changes[node_attr] = attr_value

        relative_path = xgenm.getAttr(
            "xgDataPath", sanitized_palette
        ).split(os.pathsep)[0]
        absolute_path = relative_path.replace("${PROJECT}", project_path)
        for root, _, files in os.walk(absolute_path):
            for f in files:
                source = os.path.join(root, f).replace("\\", "/")
                target = source.replace(project_path, expected_work_dir + "/")
                transfers.append((source, target))
                if os.path.exists(target):
                    overwrites.append(target)

    # Ask user about overwriting files.
    if overwrites:
        log.warning(
            "WARNING! Potential loss of data.\n\n"
            "Found duplicate Xgen files in new context.\n{}".format(
                "\n".join(overwrites)
            )
        )
        return

    for source, destination in transfers:
        if not os.path.exists(os.path.dirname(destination)):
            os.makedirs(os.path.dirname(destination))
        shutil.copy(source, destination)

    for attribute, value in attribute_changes.items():
        cmds.setAttr(attribute, value, type="string")