From 2ef74e33cbceb420ed15c2d18b6965e1b69ef520 Mon Sep 17 00:00:00 2001
From: Jakub Jezek <jakub@pype.club>
Date: Thu, 7 Nov 2019 15:55:43 +0100
Subject: [PATCH] fix(nuke): overwriting create write function

- adding input node to connect to selected node in Create
- fixing prenode to be functional if more node before write need to be added [prep for mask/prerender]
- `preset` data rewrited to be `families`
---
 pype/nuke/lib.py | 67 +++++++++++++++++++++++++++++++++---------------
 1 file changed, 46 insertions(+), 21 deletions(-)

diff --git a/pype/nuke/lib.py b/pype/nuke/lib.py
index b7ae04d929..9030ea43fb 100644
--- a/pype/nuke/lib.py
+++ b/pype/nuke/lib.py
@@ -217,12 +217,13 @@ def add_button_write_to_read(node):
     node.addKnob(k)
 
 
-def create_write_node(name, data, prenodes=None):
+def create_write_node(name, data, input=None, prenodes=None):
     ''' Creating write node which is group node
 
     Arguments:
         name (str): name of node
         data (dict): data to be imprinted
+        input (node): selected node to connect to
         prenodes (list, optional): list of lists, definitions for nodes
                                 to be created before write
 
@@ -234,9 +235,9 @@ def create_write_node(name, data, prenodes=None):
                 ("knobName", "knobValue"),
                 ("knobName", "knobValue")
             ),
-            (   # list inputs
-                "firstPrevNodeName",
-                "secondPrevNodeName"
+            (   # list outputs
+                "firstPostNodeName",
+                "secondPostNodeName"
             )
         )
         ]
@@ -278,27 +279,44 @@ def create_write_node(name, data, prenodes=None):
     })
 
     # adding dataflow template
+    log.debug("nuke_dataflow_writes: `{}`".format(nuke_dataflow_writes))
     {_data.update({k: v})
      for k, v in nuke_dataflow_writes.items()
      if k not in ["_id", "_previous"]}
 
-    # adding dataflow template
+    # adding colorspace template
+    log.debug("nuke_colorspace_writes: `{}`".format(nuke_colorspace_writes))
     {_data.update({k: v})
      for k, v in nuke_colorspace_writes.items()}
 
     _data = avalon.nuke.lib.fix_data_for_node_create(_data)
 
-    log.debug(_data)
+    log.debug("_data: `{}`".format(_data))
 
-    _data["frame_range"] = data.get("frame_range", None)
+    if "frame_range" in data.keys():
+        _data["frame_range"] = data.get("frame_range", None)
+        log.debug("_data[frame_range]: `{}`".format(_data["frame_range"]))
 
     GN = nuke.createNode("Group", "name {}".format(name))
 
     prev_node = None
     with GN:
+        connections = list()
+        if input:
+            # if connected input node was defined
+            connections.append({
+                "node":  input,
+                "inputName": input.name()})
+            prev_node = nuke.createNode(
+                "Input", "name {}".format(input.name()))
+        else:
+            # generic input node connected to nothing
+            prev_node = nuke.createNode(
+                "Input", "name {}".format("rgba"))
+
         # creating pre-write nodes `prenodes`
         if prenodes:
-            for name, klass, properties, set_input_to in prenodes:
+            for name, klass, properties, set_output_to in prenodes:
                 # create node
                 now_node = nuke.createNode(klass, "name {}".format(name))
 
@@ -308,34 +326,41 @@ def create_write_node(name, data, prenodes=None):
                         now_node[k].serValue(str(v))
 
                 # connect to previous node
-                if set_input_to:
-                    if isinstance(set_input_to, (tuple or list)):
-                        for i, node_name in enumerate(set_input_to):
-                            input_node = nuke.toNode(node_name)
+                if set_output_to:
+                    if isinstance(set_output_to, (tuple or list)):
+                        for i, node_name in enumerate(set_output_to):
+                            input_node = nuke.createNode(
+                                "Input", "name {}".format(node_name))
+                            connections.append({
+                                "node":  nuke.toNode(node_name),
+                                "inputName": node_name})
                             now_node.setInput(1, input_node)
-                    elif isinstance(set_input_to, str):
-                        input_node = nuke.toNode(set_input_to)
+                    elif isinstance(set_output_to, str):
+                        input_node = nuke.createNode(
+                            "Input", "name {}".format(node_name))
+                        connections.append({
+                            "node":  nuke.toNode(set_output_to),
+                            "inputName": set_output_to})
                         now_node.setInput(0, input_node)
                 else:
                     now_node.setInput(0, prev_node)
 
                 # swith actual node to previous
                 prev_node = now_node
-        else:
-            prev_node = nuke.createNode("Input", "name rgba")
 
         # creating write node
-        now_node = avalon.nuke.lib.add_write_node("inside_{}".format(name),
-                                                  **_data
-                                                  )
-        write_node = now_node
+        write_node = now_node = avalon.nuke.lib.add_write_node(
+            "inside_{}".format(name),
+            **_data
+            )
+
         # connect to previous node
         now_node.setInput(0, prev_node)
 
         # swith actual node to previous
         prev_node = now_node
 
-        now_node = nuke.createNode("Output", "name write")
+        now_node = nuke.createNode("Output", "name Output1")
 
         # connect to previous node
         now_node.setInput(0, prev_node)