docs

Author: John Andrews

docs/Plugins/BasicNodes/Basic-Nodes.md

@@ -1,6 +1,17 @@
 <div class="side-bar">
+    <div class="pages">
+        {% for page in site.pages %}
+        {% endfor %}
+    </div>
     <div class="plugins">
         {% for plugin in site.plugins %}
+            {% if plugin.sub and plugin.sub != current_sub %}
+                <ul>
+            {% elsif !plugin.sub and current_sub %}
+                </ul>
+                {% assign current_sub = '' %}
+            {% endif %}
+
             {% if plugin.plugin %}
                 <li>
                     <a href="/plugins/{{ plugin.plugin | replace: " ", "" }}/nodes/{{ plugin.name | replace: " ", "" }}">{{ plugin.name }}</a>
@@ -14,6 +25,10 @@
                 {% assign current_plugin = plugin.name %}
             {% endif %}
         {% endfor %}
+
+        {% if current_sub  %}
+        </ul>
+        {% endif %}
         {% if current_plugin  %}
         </ul>
         {% endif %}

docs/Plugins/BasicNodes/Function-Node.md

@@ -4,4 +4,31 @@ layout: default
 description: Index file for Basic nodes that provide the basic functionality to FileFlows
 ---
 
-These are basic file processing nodes
+Basic Nodes are core nodes and provide basic functionality to a flow
+
+Including
+* Input File
+  * A basic input file node which is a starting point of a flow
+* Copy File
+  * Copies a file to another location
+* Delete Source Directory
+  * Deletes the source directory of the file being processed.  Include options to only delete if empty
+* Move File
+  * Moves a file to another location
+* File Extension
+  * Logical node that can test if a file has a particular extension
+* File Size
+  * Logical node that cant test if a file is a certain file size
+* Function
+  * A node that lets the user provide their own logic to test.  This is a javascript code block
+* Log
+  * Lets you log a message to the flow log
+* Pattern Match
+  * Logical node that tests the working file and the original file against a regular expression.   Uses a c# regular expression.
+* Pattern Renamer
+  * Logical node that will replace text in the filename with using regular expressions or basic strings.  You can specify multiple patterns to replace. For example 
+![image](https://user-images.githubusercontent.com/958400/143516676-9a41524d-bcef-4430-9745-34c9ebf45ac9.png)
+* Renamer 
+  * Logical node that will rename the file.  Can use variables using the '{' key to use variables from other nodes and also common variables. 
+* Replace Original
+  * Logical node that will replace the original file of the flow with the current working file.  If the current working file has a different extension than the original, the working extension will be used, eg "MyFile.avi" will become "MyFile.mkv"

docs/Plugins/VideoNodes/Video-Encode.md

@@ -5,4 +5,140 @@ description: Node that executes javascript functions
 plugin: Basic Nodes
 ---
 
-This a test function thing
+The function node allows you to use custom javascript code to process within the flow.
+
+It can let you make decision paths based on previous nodes, compute variables for future nodes, log information, and many more features.
+
+## Return codes
+* Return 1+ to specify which output is to be called.   Define the number of outputs using the "Outputs" fields.  This will add more output connections to the node
+* Return 0 to complete the flow successfully.  This will immediately stop the flow and mark it as successful
+* Return -1 to indicate an error and stop the flow.  This will mark the flow as unsuccessful.
+
+## Variables
+It includes the "Variables" object which exposes variables from the flow.  And you can set future variables for the flow in here
+
+```js
+   Varabiles.MyFutureVariable = 'to be used in another flow node';
+
+   // an example of variables from a 'Video Input' node
+   let video = Variables.vi.VideoInfo.VideoStreams[0];
+   // or a safe way to get that incase any of those objects are null
+   let video = Variables.vi?.VideoInfo?.VideoStreams[0];
+   if(!video) return -1; // video was null
+```
+
+
+## Logging
+The "Log" object lets you log messages to the flow log
+```js
+   Logger.ILog('an information log message');
+   Logger.WLog('an warning log message');
+   Logger.ELog('an error log message');
+   Logger.DLog('an debug log message');
+```
+
+## Flow object
+The "Flow" object lets you perform actions on the flow, it exposes helper methods to the code.
+```js
+   // will create a directory if it does not already exist
+   // if it does exist this function simply returns 
+   // its a safe way to ensure a directory exists 
+   Flow.CreateDirectoryIfNotExists(path);
+
+   // return the size in bytes as a number
+   Flow.GetDirectorySize(path); 
+
+   // gest/sets a parameter value with a given key
+   Flow.SetParameter(key, value); 
+   Flow.GetParameter(key); 
+
+   // maps a path to the local processing node
+   Flow.MapPath(path); 
+
+   // moves the working file to the destination file
+   Flow.MoveFile(destination); 
+
+   // this will reset the working file to the original File, 
+   // this lets you effectively reprocess the original file.  
+   // Useful if you want to perform multiple operations on the same file
+   Flow.ResetWorkingFile(); 
+
+   // Sets the current working file to the file passed in
+   // dont delete is a boolean that if true will not delete the current working file
+   // note: if the current working file is the original file, it will NEVER be deleted
+   Flow.SetWorkingFile(filename, dontDelete);
+
+   // returns a new GUID as string
+   Flow.NewGuid();
+
+   // the temporary path, property NOT a function
+   Flow.TempPath
+
+   // Get a toolpath from the toolname, the toolname is case insensitive
+   Flow.GetToolPath(toolname);
+
+   // Execute a process and capture the output
+   // you can use arguments for a string argument list, or argumentList which is an string array and will escape the arguments for you correctly
+   // timeout is optional, number of seconds to wait before killing the process
+   // returns ProcessResults
+   //    Completed:bool; // if the process ran to completion or timedout/was canceled
+   //    ExitCode:number; // the exit code of the process, may be null
+   //    Output:string; // the output, if error output was detected this will contain that output
+   //    StandardOutput: string; // the standard output from the process
+   //    StandardError: string; // the standard error from the process if any
+   Flow.Execute({command:'somecommand.exe', arguments: '-a -b -c', argumentList: ['can', 'use', 'instead of arguments'], timeout: 0, workingDirectory: 'optional'});
+```
+
+
+## Samples
+
+Different outputs based on file size
+```js
+   if(Variables.file.Size > 10_000_000_000) // 10GB
+   	return 1; // output 1
+   if(Variables.file.Size > 2_000_000_000) // 2GB
+   	return 2; // output 2
+
+   let reducedSize = (Variables.file.Size / Variables.file.Orig.Size) * 100;
+   if(reducedSize < 10)
+   	return 0; // its too small, something went wrong
+
+   return 3; // output 3
+```
+
+Example showing using the Flow.Execute
+```js
+    // define the output file, in the temp directory with a guid as the name
+    let output = Flow.TempPath + '/' + Flow.NewGuid() + '.mkv';
+    // get the ffmpeg tool path
+    let ffmpeg = Flow.GetToolPath('ffmpeg');
+    // execute the process and capture the result
+    let process = Flow.Execute({
+    	command: ffmpeg,
+    	argumentList: [
+    		'-i',
+    		Variables.file.FullName,
+    		'-c:v',
+    		'libx265',
+    		'-c:a',
+    		'copy',
+    		output
+    	]
+    });
+    
+    // log the standard output/error if found
+    if(process.standardOutput)
+    	Logger.ILog('Standard output: ' + process.standardOutput);
+    if(process.starndardError)
+    	Logger.ILog('Standard error: ' + process.starndardError);
+    
+    // check the exit code of the process
+    if(process.exitCode !== 0){
+    	Logger.ELog('Failed processing ffmpeg: ' + process.exitCode);
+    	return -1;
+    }
+    
+    // update the working file to the newly created file from ffmpeg
+    Flow.SetWorkingFile(output);
+    return 1;
+```