# This was developed for a specific filename convention. Can be changed according to your needs

import hou, os, glob, shutil

# Get the caching node, name of the hip file, and full path to the hip file
node = hou.node('..')
hip_name = hou.hipFile.basename()
scene_path = hou.hipFile.path()

# Gather and Retreieve the Output paramter path, then check to see if it exists
dir_path = node.evalParm('sopoutput')
path = os.path.exists(dir_path)    


# This function is designed to save the current scene but save a backup in the versioned folder
def save_scene(scene_path, dir_path):
    # We need to get the last folder so we can save the current versioned scene into it
    splitPath_toSimulation = (dir_path.split('/'))[:-1]
    fullPath_toSimulation = '/'.join(splitPath_toSimulation)

    # Store backup folder and scene location and check to see if it already exists
    backup_folder = fullPath_toSimulation + '/backup'
    backup_scene = backup_folder + '/' + hip_name
    folder_check = os.path.exists(backup_folder)
    
    # If the backup folder exists, save the scene
    if folder_check:
        hou.hipFile.save()
        shutil.copy2(scene_path,backup_scene)
        
    # If the backup folder does not exist, create it then save a new version
    if folder_check == False:
        os.makedirs(backup_folder)
        hou.hipFile.save()
        shutil.copy2(scene_path,backup_scene)
        

# If the path returns True, it will prompt the user to decide whether or not they want to Version Up or Overwrite the simulation version
if path:
    buttons = ('Version Up', 'Overwrite', 'Cancel')
    details = '''If you choose to version up, it will go to the next available version rather than \nthe next number in sequential order. \n\nIf you choose to Overwrite this version, you will need to confirm your choice.'''
    version_option = hou.ui.displayMessage('This version already exists, do you want to Overwrite it or Version up?', buttons=buttons, details=details, default_choice=0, close_choice=-1)
    
    
    # If they choose to Version Up, it will version up the code based on the next available number rather than the next number in sequential order
    if version_option == 0:
        # Gather the version parameter of the node, and retreive the current value
        p_version = node.parm('version')        
        v_version = node.evalParm('version')
        
        # Split the path based on the characters '/v' for versions
        path_toVersions = dir_path.split('/v')[0]
        
        # Concatenate the versions and the basename
        list_versions = glob.glob(os.path.join(path_toVersions, 'v*'))

        # Find the max version in the list of versioned folders and increase it by 1
        max_version = max([int(os.path.splitext(os.path.basename(version))[0][1:]) for version in list_versions])
        new_version = f'v{max_version + 1}'

        new_dir_path = path_toVersions + '/' + new_version
        os.makedirs(new_dir_path)
        
        # Store the new version number and set it to the parameter 
        n_version = int(new_version.split('v')[1])
        p_version.set(n_version)
        print('Versioning up to ' + str(n_version))
        
        backup_folder = new_dir_path + '/backup'
        backup_scene = backup_folder + '/' + hip_name
        os.makedirs(backup_folder)
        hou.hipFile.save()
        shutil.copy2(scene_path, backup_scene)
        
        
    # If the user chooses to overwrite the simulation version, it will prompt them to confirm they want to do this before moving on
    if version_option == 1:
        d_buttons = ('Yes', 'WAIT NO')
        double_option = hou.ui.displayMessage('Are you sure you want to Overwrite this version?', buttons=d_buttons, default_choice=1, close_choice=1)
        
        # Let the user know that you will be overwriting the simulation and then move on to saving the scene
        if double_option == 0:
            print('Overwriting Current Simulation Version')
            
            save_scene(scene_path, dir_path)

                
    if version_option == 2:
        print('Canceled')

# If path doesn't exist, save the scene, store backup and simulate
if path == False:
    save_scene(scene_path, dir_path)

# This was developed for a specific filename convention. Can be modified to meet your needs

import hou, os, glob, re

# We need to grab hip file path, the path to the scenes, and scene name
hip_name = hou.hipFile.path()
scene_name = hip_name.split('/')[-1].split('_')[0]
path_to_scenes = os.path.dirname(hip_name)

# Get all the scene files associated with .hip, store them in a list with their names
get_scenes = glob.glob(os.path.join(path_to_scenes, scene_name + '*_v*.hip'))
scenes = []
for version in get_scenes:
    scenes.append(os.path.basename(version))

# Split the extension off from the names, and store it
split_ext = scenes[-1].split('.')
ext = os.path.splitext(scenes[0])[1]
split = re.split(r'(_v)', split_ext[0])
user = hip_name.split('_')[-1].split('.')[0]

# Store the standard name in a variable
common = split[0] + split[1]

# Store the version number in a variable and increment it by 1, including some padding
versions = [int(file.split('_v')[1].split('.')[0].split('_')[0]) for file in scenes]
max_version = f'{max(versions) + 1:03}'

# Rebuild the name of the file
new_save_name = common + max_version + '_' + user + ext

# Save the file
hou.hipFile.save(file_name=path_to_scenes + '/' + new_save_name)

#------------------------------------------------------------------

import hou
import os

# Set the root context
root = hou.node('/obj/')

# Create the dictionary that will store the key and value pairs for the dark interface
dark_nw_boxes = {
            'ASSETS': (0.281, 0.281, 0.278), 
            'GEO': (0.529, 0.596, 0.415), 
            'LGT': (0.980, 0.898, 0.533), 
            'FX': (0.455, 0.580, 0.917), 
            'RENDER': (0.709, 0.611, 0.882)
            }

light_nw_boxes = {
            'ASSETS': (1, 1, 1), 
            'GEO': (0.486, 0.772, 0.462), 
            'LGT': (1, 0.960, 0.407), 
            'FX': (0.266, 0.549, 0.796), 
            'RENDER': (0.521, 0.376, 0.658)

}

# Set the order by which the network boxes will be generated
nw_order = ['ASSETS', 'GEO', 'LGT', 'FX', 'RENDER']

# The network boxes will start at this position in the network
pos = 16

# Get the Houdini UI Theme (Generally Light or Dark)
def get_houdini_color_scheme(file_path):
    color_scheme = {}

    with open(file_path, 'r') as file:
        current_section = None

        for line in file:
            line = line.strip()

            # Skip empty lines and comments
            if not line or line.startswith('#'):
                continue

            # Identify section
            if line.endswith('";'):
                current_section = line[0:-1]
                if current_section.startswith('colors.scheme'):
                    color_scheme = current_section
                    key, value = color_scheme.split(':=')
                    color_scheme = value.strip()

    return color_scheme

# Get the Houdini home directory and ui file stored in it
hip = hou.homeHoudiniDirectory()
pref = 'ui.pref'
file = os.path.join(hip, pref)
dark = '"Houdini Dark"'

# Store the Houdini UI Theme (Normally Dark or Light)
houdini_color_scheme = get_houdini_color_scheme(file)

# Create Horizontal Network Boxes, set size, comment, positions, and colors
for key in nw_order:
    if (houdini_color_scheme == dark):
        value = dark_nw_boxes[key]
    else:
        value = light_nw_boxes[key]
    nb = root.createNetworkBox(name=key)
    nb.setComment(key)
    nb.setSize([8.0, 4.0])
    nb.setColor(hou.Color(value))
    nb.setPosition([0, pos])

        
    pos -= 5

import hou
import os

# Set the root context
root = hou.node('/obj/')

# Create the dictionary that will store the key and value pairs for the dark interface
dark_nw_boxes = {
            'ASSETS': (0.281, 0.281, 0.278), 
            'GEO': (0.529, 0.596, 0.415), 
            'LGT': (0.980, 0.898, 0.533), 
            'FX': (0.455, 0.580, 0.917), 
            'RENDER': (0.709, 0.611, 0.882)
            }

# Create the dictionary that will store the key and value pairs for the light interface
light_nw_boxes = {
            'ASSETS': (1, 1, 1), 
            'GEO': (0.486, 0.772, 0.462), 
            'LGT': (1, 0.960, 0.407), 
            'FX': (0.266, 0.549, 0.796), 
            'RENDER': (0.521, 0.376, 0.658)

}

# Set the order by which the network boxes will be generated
nw_order = ['ASSETS', 'GEO', 'LGT', 'FX', 'RENDER']

# The network boxes will start at this position in the network
pos = -16

# Get the Houdini UI Theme (Generally Light or Dark)
def get_houdini_color_scheme(file_path):
    color_scheme = {}

    with open(file_path, 'r') as file:
        current_section = None

        for line in file:
            line = line.strip()

            # Skip empty lines and comments
            if not line or line.startswith('#'):
                continue

            # Identify section
            if line.endswith('";'):
                current_section = line[0:-1]
                if current_section.startswith('colors.scheme'):
                    color_scheme = current_section
                    key, value = color_scheme.split(':=')
                    color_scheme = value.strip()

    return color_scheme

# Get the Houdini home directory and ui file stored in it
hip = hou.homeHoudiniDirectory()
pref = 'ui.pref'
file = os.path.join(hip, pref)
dark = '"Houdini Dark"'

# Store the Houdini UI Theme (Normally Dark or Light)
houdini_color_scheme = get_houdini_color_scheme(file)

# Create Vertical Network Boxes, set size, comment, positions, and colors
for key in nw_order:
    
    if (houdini_color_scheme == dark):
        value = dark_nw_boxes[key]
    else:
        value = light_nw_boxes[key]
        
    nb = root.createNetworkBox(name=key)
    nb.setComment(key)
    nb.setSize([4.0, 8.0])
    nb.setColor(hou.Color(value))
    nb.setPosition([pos, 0])

        
    pos += 5

# Synchronize Directories Script v1.2
# Created by John Kesig

# This script is designed to synchronize one directory to another. Then it will generate a robocopy script that will get run and saved in the Windows Task Scheduler
# This was designed to be run while you are in the folder you want to synchronize. For that, I created a command in the right-click context menu to do this. You
# absolutely could change this to choose both source and destination directories. I also wanted this to be as native to the OS as possible so I didn't go with Python for this

Add-Type -AssemblyName System.Windows.Forms

# Gets and stores the starting folder
Function Source($sourceDirectory='')
{
 $rootDirectory = Get-Item .

 return $rootDirectory
}

# Prompts the user to select the destination directory they want to synchronize to
Function Destination($destinationDirectory='')
{
 $folder = New-Object System.Windows.Forms.FolderBrowserDialog
 $folder.Description = 'Choose Destination Folder to Synchronize'

 if($folder.ShowDialog() -eq "Ok")
 {
 $folderpath += $folder.SelectedPath
 }

 return $folderpath
}

# Creates the Synchronization script to be used by the Task Scheduler 
Function CreateSyncScript($syncScriptPath='')
{
 # We have to do a bit of error checking here, because the spaces in file paths will create problems so I implemented an escape character
 $sourceLocation = $source
 $sourceLocation = $sourceLocation -replace ' ', '` '

 $destinationLocation = $destination 
 $destinationLocation = $destinationLocation -replace ' ', '` '

 # Create Log Name
 $logName = '{0} Copy Log' -f $shortname
 $logName = $logName -replace ' ', '` '

 # This is where the powershell script will be stored. Feel free to change this if you want
 $scriptDirectory = 'C:\SyncScripts\'
 $logDirectory = 'C:\SyncScripts\Logs\'
 
 # Test if the Script Directory exists. If it doesn't, it will create it.
 if(!(Test-Path -PathType Container $scriptDirectory))
 {
 New-Item -ItemType Directory -Path $scriptDirectory
 }

 if(!(Test-Path -PathType Container $logDirectory))
 {
 New-Item -ItemType Directory -Path $logDirectory
 }

 # This is the script that will be run by Powershell to synchronize the two locations
 $script = 'robocopy {0} {1} *.* -e /v /tee /log+:{2}{3}.txt' -f $sourceLocation,$destinationLocation,$logDirectory,$logName

 # Test to see if the sync script file already exists. If it doesn't, it will create the file
 $testPath = Test-Path -PathType Leaf -Path $scriptDirectory$sourceShortName.ps1

 if($testPath -ne $true)
 {
 $scriptPath = New-Item -Path $scriptDirectory$sourceShortName.ps1
 Set-Content -Path $scriptPath -Value $script
 }

 return $scriptPath
}

# Creates the Task for the Task Scheduler
Function CreateTask()
{
 # Create everything associated with the Task
 # The Name is the folder you are doing a robocopy from and to
 $name = 'Synchronize {0} to {1}' -f $sourceShortName,$destinationShortName

 # The action is going to be launched by Powershell and it will run the script located in the Script Path above
 $action = New-ScheduledTaskAction -Execute 'PowerShell.exe' -Argument $scriptPath

 # You can designate a time and frequency here
 $trigger = New-ScheduledTaskTrigger -Daily -At '7:00 PM'

 $description = 'Synchronizes {0} to {1}' -f $sourceShortName,$destinationShortName

 # This script used to run when you go into idle, but sometimes people don't have Idle enabled so I removed it
 $settings = New-ScheduledTaskSettingsSet -IdleDuration 00:15:00 -DontStopOnIdleEnd

 $task = New-ScheduledTask -Description $description -Action $action -Trigger $trigger -Settings $settings

 # Register the task to the Task Manager
 Register-ScheduledTask -TaskName $name -InputObject $task

 # Enable and Start the Task
 Enable-ScheduledTask -TaskName $name
 Start-ScheduledTask -TaskName $name
}

# Gather the source folder this script will pull from (It will take from the one you initiated the script in)
$source = Source

# Allow the user to choose where they want the files to be synchronized to 
$destination = Destination

# Only get the names for the directories
$sourceShortName = $source|Split-Path -Leaf
$destinationShortName = $destination|Split-Path -Leaf

# Create the sync script that will be run for Task Scheduler
$syncScript = CreateSyncScript($source,$destination,$sourceShortName)
$scriptPath = $syncScript[1]

# Check to see if the $syncScript variable doesn't come back empty. IF it does then it prompts the user that a script has already been created
# If the script comes back with a path, it will create the task and prompt the user that everything has been completed
if($scriptPath -eq $null)
{
 [System.Windows.Forms.MessageBox]::Show('Your Sync Script has already been created. Check your SyncScripts folder')
} else {
 $task = CreateTask($sourceShortName,$destinationShortName,$scriptPath)
 [System.Windows.Forms.MessageBox]::Show('Your Sync Task has been generated. Please go to Task Scheduler to see your sync job. A log will be generated the next time the task is run')
}

#!/bin/bash

## This script is used to bootstrap a machine and get it configured for Salt. An admin on the domain needs to input their credentials themselves and choose whether or not to install Salt Minion or Salt Master & Minion.
## We relied on Salt to install our Linux NVIDIA drivers but that is something you could do through here, you may end up with a mismatch in driver implementation later down the road though. Be careful.

# Gather user account for the domain
read -p 'Username for domain admin: ' ADUSER
while True
    do
        read -s -p 'Password for domain admin: ' ADPASS
        echo
        read -s -p 'Please re-enter domain admin password: ' ADPASS2
        echo

        if [[ "$ADPASS" = "$ADPASS2"]]; then
            break
        else
            echo "Passwords did not match, please try again"
        fi
done

while true;
do
    read -p 'Installing Salt Master or Minion? [M/m]'
    echo
    read SALT

    case $SALT in
        [M]* ) useMaster=True; break;;
        [m]* ) useMinion=false; break;;
        * ) echo "Please use either 'M' to indicate Master or 'm' to indicate minion"
    esac
done


PROXY= #REPLACE WITH PROXY "PATH:PORT"

# # Install Certificates
scp `# username@machinePath:/path/to/grab/certificate /destination/path/to/install/certificate`
update-ca-trust

# # Add proxy
echo "proxy=" "$PROXY" >> /etc/yum.conf

# # Install Updates
yum check-update
yum -y upgrade

# # Install EPEL Repo
yum -y install epel-release
yum check-update

# # Distable Firewall (This is your choice, for the env we ran we didn't need it)
systemctl stop firewalld
systemctl disable firewalld

# # Disable SELinux (Again this was our choice, you can change this)
sed -i '7s/.*/SELINUX=disabled/' /etc/selinux/config
setenforce 0

# # Setup Salt (We used salt instead of Ansible, you can take this out if you want)
curl --proxy $PROXY -o bootstrap-salt.sh -L https://bootstrap.saltproject.io
chmod 775 ./bootstrap-salt.sh
if [[ $SALT = true]]; then
    while true;
        do
            ./boostrap-salt.sh -M -H $PROXY stable
    done
fi

if [[ $SALT = false]]; then
    while false;
        do
            ./bootstrap-salt.sh -H $PROXY stable
    done
fi

sed -i '16s/.*/master: /' `# ADD SALT MASTER IP ADDRESS TO THE LEFT OF THE /`  /etc/salt/minion
systemctl enable salt-minion.service
systemctl restart salt-minion.service

# Join domain
# You may not be able to log in via your AD credentials on a new machine build
# because this smb.conf file has changed, and uses a different kerberos method
# for instance. Please check it here, and match it in the salt smb_client config.
yum -y install realmd oddjob-mkhomedir oddjob samba-winbind-clients samba-winbind samba-common-tools samba-winbind-krb5-locator
mv /etc/samba/smb.conf /etc/samba/smb.conf.orig
echo "$ADPASS" | realm join --client-software=winbind --user=$ADUSER `#ADD DOMAIN PATH HERE`
sed -i '4s/.*/template homedir= \/home\/%U/' /etc/samba/smb.conf
sed -i '13s/.*/winbind use default domain = yes/' /etc/samba/smb.conf
systemctl restart winbind.service
# test that adding to the domain worked
id $ADUSER

#!/bin/bash
# This is a script based on RHEL distros. For DEB based distros, replace the yum with apt-get

ARGS=$(getopt --options 'bfhd:' --longoptions 'backend,frontend,help,destination:' -- "$@")
eval set --"$ARGS"

backend=false
frontend=false
help=false
destination=false

while true; do
    case "$1" in
        -b|--backend)
            backend="true"
            shift;;
        -f|--frontend)
            frontend="true"
            shift;;
        -h|--help)
            help="true"
            shift;;
        -d|--destination)
            destination="true";
            dvalue="$2";
            shift 2;;
        --)
            break;;
        *)
            echo -e "Error: Unknown option:" "$1"
            exit 1;;
    esac
done

if [ "$help" == true ]
    then 
        echo "$(basename "$0") options available: [-b, --backend] [-f, --frontend] [-d, --destination <directory path>] [-h, --help]"
        exit
fi

if [ "$dvalue" == "" ]
then
    echo "Please input a destination directory"
    echo "$dvalue"
    exit
fi

# Check if sudo is being run on command
if [ "$EUID" -ne 0 ]
    then 
        echo "Error: Please run as root"
        exit
fi

# Check if Docker is installed on the machine
which docker &> /dev/null

if [ $? -ne 0 ]
    then
        echo "Docker is not installed. Installing Docker"
        yum config-manager --add-repo=https://download.docker.com/linux/centos/docker-ce.repo -y
        yum update -y
        yum install docker-ce docker-ce-cli containerd.io -y
        
        # Start Docker and Enable it so it runs automatically when Host is turned on
        systemctl start docker
        systemctl enable docker
        
        # Add current user to the docker list of users
        usermod -aG docker $USER

        echo "Docker has been installed, started and enabled. Your user has been added to Docker"
fi

# Check if Git is installed on the machine
which git &> /dev/null

if [ $? -ne 0 ]
    then
        echo "Git is not installed. Installing Git"
        yum install git -y
fi

# Check if Make is installed on the machine
which make &> /dev/null

if [ $? -ne 0 ]
    then
        echo "Make is not installed. Installing Make"
        yum install make -y
fi

# Clone the Ayon Docker repository
repo_url="https://github.com/ynput/ayon-docker"
if [ "$destination" == "true" ]
    then
        mkdir "$dvalue/ayon"
        git clone "$repo_url" "$dvalue/ayon"
    else
        git clone "$repo_url"
fi
cd "$dvalue/ayon"
docker compose up -d
make setup

# Run the make commands on the developer backend/frontend
if [ "$backend" == true ] && [ "$frontend" == true ]
    then
        make backend && make frontend
    elif [ "$frontend" == true ]
        then
            make frontend
    elif [ "$backend" == true ]
        then
            make backend
fi

# Finishing closing messages
if [ "$backend" == true ] && [ "$frontend" == true ]
    then
        echo -e "\nThe developer backend & frontend have also been setup\n"
elif [ "$backend" == true ]
    then
        echo -e "\nThe Backend has also been setup\n"
elif [ "$frontend" == true ]
    then
        echo -e "\nThe Frontend has also been setup\n"
fi
echo -e "Access your AYON Server here: http://localhost:5000"
echo -e "To access on another workstation, use this machines IP Address + Port number in your browser\n"