CODESYS Forge

using Microsoft.Win32;

using System;

using System.Collections.Generic;

using System.Diagnostics;

using System.Dynamic;

using System.IO;

using System.Linq;

using System.Net;

using System.Reflection;

using System.Text;

using System.Threading.Tasks;

namespace cforge

{

    /// <summary>

    /// Misc helper classes for all kinds of stuff

    /// </summary>

    class Helper

    {

        const String strAssemblyNameIPY = "IronPython.dll";

        const String strAssemblyNameMSScripting = "Microsoft.Scripting.dll";

        #region Registry

        /// <summary>

        /// Function to check if URL Handler for cforge tool is installed

        /// </summary>

        /// <returns>true, if yes. false, if not</returns>

        public static bool CheckRegistryProtocol()

        {

            RegistryKey cforge = Registry.ClassesRoot.OpenSubKey("cforge");

            if (cforge == null)

            {

                return false;

            }

            return true;

        }

        public static void RegisterProtocol()

        {

            try

            {

                String fullpath = GetCFORGEAssemblyPath();

                RegistryKey cforgekey = Registry.ClassesRoot.OpenSubKey("cforge");

                cforgekey = Registry.ClassesRoot.CreateSubKey("cforge", true);

                cforgekey.SetValue("", "URL:cforge Protocol");

                cforgekey.SetValue("URL Protocol", "");

                RegistryKey cforgeshell = cforgekey.CreateSubKey("shell");

                RegistryKey shellopen = cforgeshell.CreateSubKey("open");

                RegistryKey opencommand = shellopen.CreateSubKey("command");

                opencommand.SetValue("", "\"" + fullpath + "\" \"%1\"");

                Console.WriteLine("[INFO] Installed URL Handler for cforge tool. \r\n\tPath is: " + fullpath);

            }

            catch (Exception ex)

            {

                Console.WriteLine("Exception while adding the registry key. Perhaps you are not admin?");

                Console.WriteLine(ex.ToString());

            }

        }

        #endregion

        /// <summary>

        /// Function to retrieve the location of the currenty assembly (cforge.exe).

        /// This should be located in the CODESYS installation subfolder "CFORGE"

        /// </summary>

        /// <returns>full path to cforge.exe</returns>

        private static String GetCFORGEAssemblyPath()

        {

            String path = System.Reflection.Assembly.GetExecutingAssembly().Location;

            return path;

        }

        private static bool IsCODESYSPathInstallation()

        {

            String path = GetCFORGEAssemblyPath();

            if (path.Contains("bin") && (path.Contains("Debug") || path.Contains("Release")))

                return false;

            return true;

        }

        /// <summary>

        /// Function to retrieve the CODESYS AP_ROOT (this is where "Common" etc. folders are)

        /// </summary>

        /// <returns>full path to AP ROOT</returns>

        private static String GetCODESYSRoot()

        {

            if (IsCODESYSPathInstallation())

            {

                // twice up from cforge.exe (if installed in CODESYS)

                String path = GetCFORGEAssemblyPath();

                path = Directory.GetParent(path).FullName;

                return Directory.GetParent(path).FullName;

            }

            // for now return a normal installation path for CODESYS

            return @"C:\Program Files (x86)\3S CODESYS\CODESYS\";

        }

        /// <summary>

        /// Function to retrieve the CFORGE Script path (this is where the IronPython scripts should reside)

        /// </summary>

        /// <returns>full path to CFORGE Scripts</returns>

        private static String GetCFORGEScriptPath()

        {

            if (IsCODESYSPathInstallation())

            {

                // <AP_ROOT>\CFORGE\Scripts

                String path = GetCODESYSRoot();

                return Path.Combine(path, "CFORGE", "Scripts");

            }

            String localscriptpath = System.AppDomain.CurrentDomain.BaseDirectory;

            localscriptpath = Directory.GetParent(localscriptpath).FullName;

            localscriptpath = Directory.GetParent(localscriptpath).FullName;

            localscriptpath = Directory.GetParent(localscriptpath).FullName;

            return Path.Combine(localscriptpath,"Package", "CFORGE", "Scripts");

        }

        private static String GetScriptPluginPath()

        {

            String path = "";

            bool bIPYFound = false;

            bool bMSScrFound = false;

            String dir = Path.Combine(GetCODESYSRoot(), "PlugIns", "dc937c18-e9f0-434d-85b7-1b8f499e378a");

            foreach (string item in Directory.EnumerateDirectories(dir))

            {

                foreach (string file in Directory.EnumerateFiles(item))

                {

                    if(Path.GetFileName(file) == strAssemblyNameIPY)

                    {

                        bIPYFound = true;

                        path = item;

                    }

                    if (Path.GetFileName(file) == strAssemblyNameMSScripting)

                    {

                        bMSScrFound = true;

                        path = item;

                    }

                }

            }

            if(!bIPYFound || !bMSScrFound || !Directory.Exists(path))

            {

                Console.WriteLine("[ERROR] No scripting plugin in CODESYS found. Do you use original CODESYS at all?");

                return "";

            }

            return path;

        }

        /// <summary>

        /// Function to enumerate all IronPython scripts to exend cforge.exe inside Scripts folder

        /// </summary>

        /// <returns>List of IPY scripts</returns>

        public static List<String> GetAllScripts()

        {

            List<string> liScripts = new List<string>();

            try

            {

                String path = GetCFORGEScriptPath();

                foreach (String file in Directory.EnumerateFiles(path))

                {

                    if (Path.GetExtension(file).ToLowerInvariant() == ".ipy")

                    {

                        String shortfilename = Path.GetFileNameWithoutExtension(file);

                        liScripts.Add(shortfilename);

                    }

                }

            }

            catch(Exception e)

            {

                Console.WriteLine("[EXCEPTION] GetAllScripts: " + e.Message);

            }

            return liScripts;

        }

        #region Scripting

        public static void ExecuteIPyScript(String command, String[] args)

        {

            String scriptfile = Path.Combine(GetCFORGEScriptPath(), command + ".ipy");

            if (!File.Exists(scriptfile))

            {

                Console.WriteLine("[ERROR] Cannot execute script: no such file or directory: " + scriptfile);

                return;

            }

            String strAssemblyDir = GetScriptPluginPath();

            if (String.IsNullOrEmpty(strAssemblyDir))

                return;

            try

            {

                Assembly assemblyIronPython = Assembly.LoadFrom(Path.Combine(strAssemblyDir, strAssemblyNameIPY));

                Assembly assemblyMicrosoftScripting = Assembly.LoadFrom(Path.Combine(strAssemblyDir, strAssemblyNameMSScripting));

                Type tPython = assemblyIronPython.GetExportedTypes().Where(t => t.FullName == "IronPython.Hosting.Python").First();

                Type tScriptEngine = assemblyMicrosoftScripting.GetExportedTypes().Where(t => t.FullName == "Microsoft.Scripting.Hosting.ScriptEngine").First();

                Type tScriptScope = assemblyMicrosoftScripting.GetExportedTypes().Where(t => t.FullName == "Microsoft.Scripting.Hosting.ScriptScope").First();

                Type tScriptRuntime = assemblyMicrosoftScripting.GetExportedTypes().Where(t => t.FullName == "Microsoft.Scripting.Hosting.ScriptRuntime").First();

                MethodInfo miCreateRuntime = tPython.GetMethod("CreateRuntime", new Type[] {  });

                MethodInfo miCreateEngine = tPython.GetMethod("CreateEngine", new Type[] { });

                MethodInfo miExecuteFile = tScriptEngine.GetMethod("ExecuteFile", new Type[] { typeof(String) });

                MethodInfo miGetSysModule = tPython.GetMethod("GetSysModule", new Type[] { tScriptRuntime});

                MethodInfo miSetVariable = tScriptScope.GetMethod("SetVariable", new Type[] { typeof(String), typeof(String[]) });

                var runtime = miCreateRuntime.Invoke(null, null);

                var sysmodule = miGetSysModule.Invoke(runtime, null);

                IDictionary<string, object> arguments = new Dictionary<string, object>();

                arguments["Arguments"] = new [] { args };

                //var IronPythonEngine = miCreateEngine.Invoke(null, new object[] { arguments });

                //var IronPythonEngine = miCreateEngine.Invoke(null, null);

                //miExecuteFile.Invoke(IronPythonEngine, new object[] { scriptfile });

                //var ScriptScore = miGetSysModule.Invoke(IronPythonEngine, null);

                //miSetVariable.Invoke(ScriptScore, new object[] {"argv", args });

                //miExecuteFile.Invoke(IronPythonEngine, new object[] { scriptfile });

            }

            catch (Exception ex)

            {

                Console.WriteLine("[EXCEPTION] Execute IPY Script: " + command + ".ipy! " + ex.Message);

            }

        }

        #endregion

    }

}