public ProgramBlock SaveMacro(string options)
 {
     RecordingDisable();
     //
     var program = new ProgramBlock();
     program.Name = "New Macro";
     program.Address = masterControlProgram.GeneratePid();
     program.Type = "Wizard";
     foreach (var migCommand in macroCommands)
     {
         var command = new ProgramCommand();
         command.Domain = migCommand.Domain;
         command.Target = migCommand.NodeId;
         command.CommandString = migCommand.Command;
         command.CommandArguments = "";
         if (!string.IsNullOrEmpty(migCommand.GetOption(0)) && migCommand.GetOption(0) != "null")
         {
             //TODO: should we pass entire command option string? migCmd.OptionsString
             command.CommandArguments = migCommand.GetOption(0) + (options != "" && options != "null" ? "/" + options : "");
         }
         program.Commands.Add(command);
     }
     masterControlProgram.ProgramAdd(program);
     //
     return program;
 }

 public CSharpEngine(ProgramBlock pb) : base(pb) 
 {
     // TODO: SetShadowCopyPath/SetShadowCopyFiles methods are deprecated... 
     // TODO: create own AppDomain for "programDomain" instead of using CurrentDomain
     // TODO: and use AppDomainSetup to set shadow copy for each app domain
     // TODO: !!! verify AppDomain compatibility with mono !!!
     if (!isShadowCopySet)
     {
         isShadowCopySet = true;
         var domain = AppDomain.CurrentDomain;
         domain.SetShadowCopyPath(Path.Combine(domain.BaseDirectory, "programs"));
         domain.SetShadowCopyFiles();
     }
 }

        public void ProcessRequest(MIGClientRequest request, MIGInterfaceCommand migCommand)
        {
            string streamcontent = "";
            ProgramBlock currentProgram;
            ProgramBlock newProgram;
            //
            homegenie.ExecuteAutomationRequest(migCommand);
            if (migCommand.Command.StartsWith("Macro."))
            {
                switch (migCommand.Command)
                {
                    case "Macro.Record":
                        homegenie.ProgramEngine.MacroRecorder.RecordingEnable();
                        break;
                    case "Macro.Save":
                        newProgram = homegenie.ProgramEngine.MacroRecorder.SaveMacro(migCommand.GetOption(1));
                        migCommand.Response = newProgram.Address.ToString();
                        break;
                    case "Macro.Discard":
                        homegenie.ProgramEngine.MacroRecorder.RecordingDisable();
                        break;
                    case "Macro.SetDelay":
                        switch (migCommand.GetOption(0).ToLower())
                        {
                            case "none":
                                homegenie.ProgramEngine.MacroRecorder.DelayType = MacroDelayType.None;
                                break;

                            case "mimic":
                                homegenie.ProgramEngine.MacroRecorder.DelayType = MacroDelayType.Mimic;
                                break;

                            case "fixed":
                                double secs = double.Parse(migCommand.GetOption(1), System.Globalization.CultureInfo.InvariantCulture);
                                homegenie.ProgramEngine.MacroRecorder.DelayType = MacroDelayType.Fixed;
                                homegenie.ProgramEngine.MacroRecorder.DelaySeconds = secs;
                                break;
                        }
                        break;
                    case "Macro.GetDelay":
                        migCommand.Response = "[{ DelayType : '" + homegenie.ProgramEngine.MacroRecorder.DelayType + "', DelayOptions : '" + homegenie.ProgramEngine.MacroRecorder.DelaySeconds + "' }]";
                        break;
                }
            }
            else if (migCommand.Command.StartsWith("Scheduling."))
            {
                switch (migCommand.Command)
                {
                    case "Scheduling.Add":
                    case "Scheduling.Update":
                        var item = homegenie.ProgramEngine.SchedulerService.AddOrUpdate(migCommand.GetOption(0), migCommand.GetOption(1).Replace("|", "/"));
                        item.ProgramId = migCommand.GetOption(2);
                        homegenie.UpdateSchedulerDatabase();
                        break;
                    case "Scheduling.Delete":
                        homegenie.ProgramEngine.SchedulerService.Remove(migCommand.GetOption(0));
                        homegenie.UpdateSchedulerDatabase();
                        break;
                    case "Scheduling.Enable":
                        homegenie.ProgramEngine.SchedulerService.Enable(migCommand.GetOption(0));
                        homegenie.UpdateSchedulerDatabase();
                        break;
                    case "Scheduling.Disable":
                        homegenie.ProgramEngine.SchedulerService.Disable(migCommand.GetOption(0));
                        homegenie.UpdateSchedulerDatabase();
                        break;
                    case "Scheduling.Get":
                        migCommand.Response = JsonConvert.SerializeObject(homegenie.ProgramEngine.SchedulerService.Get(migCommand.GetOption(0)));
                        break;
                    case "Scheduling.List":
                        homegenie.ProgramEngine.SchedulerService.Items.Sort((SchedulerItem s1, SchedulerItem s2) =>
                        {
                            return s1.Name.CompareTo(s2.Name);
                        });
                        migCommand.Response = JsonConvert.SerializeObject(homegenie.ProgramEngine.SchedulerService.Items);
                        break;
                }
            }
            else if (migCommand.Command.StartsWith("Programs."))
            {
                if (migCommand.Command != "Programs.Import")
                {
                    streamcontent = new StreamReader(request.InputStream).ReadToEnd();
                }
                //
                switch (migCommand.Command)
                {
                    case "Programs.Import":
                        string archiveName = "homegenie_program_import.hgx";
                        if (File.Exists(archiveName)) File.Delete(archiveName);
                        //
                        var encoding = (request.Context as HttpListenerContext).Request.ContentEncoding;
                        string boundary = MIG.Gateways.WebServiceUtility.GetBoundary((request.Context as HttpListenerContext).Request.ContentType);
                        MIG.Gateways.WebServiceUtility.SaveFile(encoding, boundary, request.InputStream, archiveName);
                        //
                        var serializer = new XmlSerializer(typeof(ProgramBlock));
                        var reader = new StreamReader(archiveName);
                        newProgram = (ProgramBlock)serializer.Deserialize(reader);
                        reader.Close();
                        //
//.........这里部分代码省略.........

 private void StartProgramEvaluator(ProgramBlock program)
 {
     EvaluateProgramConditionArgs evalArgs = new EvaluateProgramConditionArgs() {
         Program = program,
         Callback = (ProgramBlock p, bool conditionsatisfied) =>
         {
             if (conditionsatisfied && p.IsEnabled)
             {
                 Run(p, null); // that goes async too
             }
         }
     };
     ThreadPool.QueueUserWorkItem(new WaitCallback(EvaluateProgramCondition), evalArgs);
 }

        // TODO: v1.1 !!!IMPORTANT!!! move thread allocation and starting to ProgramEngineBase.cs class
        public void Run(ProgramBlock program, string options)
        {
            if (program.IsRunning)
                return;

            if (program.Engine.ProgramThread != null)
            {
                program.Engine.Stop();
                program.IsRunning = false;
            }

            program.IsRunning = true;
            RaiseProgramModuleEvent(program, Properties.PROGRAM_STATUS, "Running");

            program.TriggerTime = DateTime.UtcNow;

            program.Engine.ProgramThread = new Thread(() =>
            {
                MethodRunResult result = null;
                try
                {
                    result = program.Run(options);
                }
                catch (Exception ex)
                {
                    result = new MethodRunResult();
                    result.Exception = ex;
                }
                //
                if (result != null && result.Exception != null && !result.Exception.GetType().Equals(typeof(System.Reflection.TargetException)))
                {
                    // runtime error occurred, script is being disabled
                    // so user can notice and fix it
                    List<ProgramError> error = new List<ProgramError>() { program.GetFormattedError(result.Exception, false) };
                    program.ScriptErrors = JsonConvert.SerializeObject(error);
                    program.IsEnabled = false;
                    RaiseProgramModuleEvent(program, Properties.RUNTIME_ERROR, "CR: " + result.Exception.Message.Replace('\n', ' ').Replace('\r', ' '));
                }
                program.IsRunning = false;
                program.Engine.ProgramThread = null;
                RaiseProgramModuleEvent(program, Properties.PROGRAM_STATUS, "Idle");
            });
            //
            if (program.ConditionType == ConditionType.Once)
            {
                program.IsEnabled = false;
            }
            //
            try
            {
                program.Engine.ProgramThread.Start();
            }
            catch
            {
                program.Engine.Stop();
                program.IsRunning = false;
                RaiseProgramModuleEvent(program, Properties.PROGRAM_STATUS, "Idle");
            }
            //
            //Thread.Sleep(100);
        }

 public void ProgramAdd(ProgramBlock program)
 {
     automationPrograms.Add(program);
     program.EnabledStateChanged += program_EnabledStateChanged;
     program.Engine.SetHost(homegenie);
     // Initialize state
     RaiseProgramModuleEvent(program, Properties.PROGRAM_STATUS, "Idle");
     if (program.IsEnabled)
     {
         StartProgramEvaluator(program);
     }
 }

//.........这里部分代码省略.........
                    // regenerate encrypted files
                    homegenie.SystemConfiguration.Update();
                    homegenie.UpdateModulesDatabase();
                }
                else if (migCommand.GetOption(0) == "Security.ClearPassword")
                {
                    homegenie.MigService.SetWebServicePassword("");
                    homegenie.SystemConfiguration.HomeGenie.UserPassword = "";
                    // regenerate encrypted files
                    homegenie.SystemConfiguration.Update();
                    homegenie.UpdateModulesDatabase();
                }
                else if (migCommand.GetOption(0) == "Security.HasPassword")
                {
                    migCommand.Response = JsonHelper.GetSimpleResponse((homegenie.SystemConfiguration.HomeGenie.UserPassword != "" ? "1" : "0"));
                }
                else if (migCommand.GetOption(0) == "System.ConfigurationRestore")
                {
                    // file uploaded by user
                    string archivename = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, Utility.GetTmpFolder(), "homegenie_restore_config.zip");
                    Utility.FolderCleanUp(Utility.GetTmpFolder());
                    try
                    {
                        MIG.Gateways.WebServiceUtility.SaveFile(request.InputStream, archivename);
                        Utility.UncompressZip(archivename, Path.Combine(AppDomain.CurrentDomain.BaseDirectory, Utility.GetTmpFolder()));
                        File.Delete(archivename);
                    }
                    catch
                    {
                    }
                }
                else if (migCommand.GetOption(0) == "System.ConfigurationRestoreS1")
                {
                    var serializer = new XmlSerializer(typeof(List<ProgramBlock>));
                    var reader = new StreamReader(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, Utility.GetTmpFolder(), "programs.xml"));
                    var newProgramsData = (List<ProgramBlock>)serializer.Deserialize(reader);
                    reader.Close();
                    var newProgramList = new List<ProgramBlock>();
                    foreach (ProgramBlock program in newProgramsData)
                    {
                        if (program.Address >= ProgramEngine.USER_SPACE_PROGRAMS_START)
                        {
                            ProgramBlock p = new ProgramBlock();
                            p.Address = program.Address;
                            p.Name = program.Name;
                            p.Description = program.Description;
                            newProgramList.Add(p);
                        }
                    }
                    newProgramList.Sort(delegate(ProgramBlock p1, ProgramBlock p2)
                    {
                        string c1 = p1.Address.ToString();
                        string c2 = p2.Address.ToString();
                        return c1.CompareTo(c2);
                    });
                    migCommand.Response = JsonConvert.SerializeObject(newProgramList);
                }
                else if (migCommand.GetOption(0) == "System.ConfigurationRestoreS2")
                {
                    var serializer = new XmlSerializer(typeof(List<Group>));
                    var reader = new StreamReader(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, Utility.GetTmpFolder(), "automationgroups.xml"));
                    var automationGroups = (List<Group>)serializer.Deserialize(reader);
                    reader.Close();
                    //
                    foreach (var automationGroup in automationGroups)
                    {

 private bool ProgramsDiff(ProgramBlock oldProgram, ProgramBlock newProgram)
 {
     bool unchanged = (JsonConvert.SerializeObject(oldProgram.ConditionType) == JsonConvert.SerializeObject(newProgram.ConditionType)) &&
     (JsonConvert.SerializeObject(oldProgram.Conditions) == JsonConvert.SerializeObject(newProgram.Conditions)) &&
     (JsonConvert.SerializeObject(oldProgram.Commands) == JsonConvert.SerializeObject(newProgram.Commands)) &&
     (oldProgram.ScriptCondition == newProgram.ScriptCondition) &&
     (oldProgram.ScriptSource == newProgram.ScriptSource) &&
     (oldProgram.Name == newProgram.Name) &&
     (oldProgram.Description == newProgram.Description) &&
     (oldProgram.Group == newProgram.Group) &&
     (oldProgram.Type == newProgram.Type);
     return !unchanged;
 }

 public List<ProgramError> CompileScript(ProgramBlock program)
 {
     List<ProgramError> errors = new List<ProgramError>();
     switch (program.Type.ToLower())
     {
     case "csharp":
         errors = CompileCsharp(program);
         break;
     case "ruby":
     case "python":
         errors = CompileIronScript(program);
         break;
     case "javascript":
         errors = CompileJavascript(program);
         break;
     case "arduino":
         errors = CompileArduino(program);
         break;
     }
     return errors;
 }

        private List<ProgramError> CompileCsharp(ProgramBlock program)
        {
            List<ProgramError> errors = new List<ProgramError>();

            // check for output directory
            if (!Directory.Exists(Path.GetDirectoryName(program.AssemblyFile)))
            {
                Directory.CreateDirectory(Path.GetDirectoryName(program.AssemblyFile));
            }

            // dispose assembly and interrupt current task (if any)
            program.AppAssembly = null;
            program.IsEnabled = false;

            // DO NOT CHANGE THE FOLLOWING LINES OF CODE
            // it is a lil' trick for mono compatibility
            // since it will be caching the assembly when using the same name
            // and use the old one instead of the new one
            string tmpfile = Path.Combine("programs", Guid.NewGuid().ToString() + ".dll");
            System.CodeDom.Compiler.CompilerResults result = new System.CodeDom.Compiler.CompilerResults(null);
            try
            {
                result = CSharpAppFactory.CompileScript(program.ScriptCondition, program.ScriptSource, tmpfile);
            }
            catch (Exception ex)
            {
                // report errors during post-compilation process
                result.Errors.Add(new System.CodeDom.Compiler.CompilerError(program.Name, 0, 0, "-1", ex.Message));
            }

            if (result.Errors.Count > 0)
            {
                int sourceLines = program.ScriptSource.Split('\n').Length;
                foreach (System.CodeDom.Compiler.CompilerError error in result.Errors)
                {
                    int errorRow = (error.Line - CSharpAppFactory.PROGRAM_CODE_OFFSET);
                    string blockType = "CR";
                    if (errorRow >= sourceLines + CSharpAppFactory.CONDITION_CODE_OFFSET)
                    {
                        errorRow -= (sourceLines + CSharpAppFactory.CONDITION_CODE_OFFSET);
                        blockType = "TC";
                    }
                    if (!error.IsWarning)
                    {
                        errors.Add(new ProgramError() {
                            Line = errorRow,
                            Column = error.Column,
                            ErrorMessage = error.ErrorText,
                            ErrorNumber = error.ErrorNumber,
                            CodeBlock = blockType
                        });
                    }
                    else
                    {
                        var warning = String.Format("{0},{1},{2}: {3}", blockType, errorRow, error.Column, error.ErrorText);
                        RaiseProgramModuleEvent(program, Properties.COMPILER_WARNING, warning);
                    }
                }
            }
            if (errors.Count == 0)
            {
                program.AppAssembly = result.CompiledAssembly;
            }

            return errors;
        }

 public void ProgramAdd(ProgramBlock program)
 {
     program.SetHost(homegenie);
     automationPrograms.Add(program);
     program.EnabledStateChanged += program_EnabledStateChanged;
     //
     // in case of c# script preload assembly from generated .dll
     if (program.Type.ToLower() == "csharp" && !program.AssemblyLoad())
     {
         program.ScriptErrors = "Program update is required.";
     }
     //
     // Initialize state
     RaiseProgramModuleEvent(program, Properties.PROGRAM_STATUS, "Idle");
     if (program.IsEnabled)
     {
         StartProgramEvaluator(program);
     }
 }

 public void ProgramRemove(ProgramBlock program)
 {
     RaiseProgramModuleEvent(program, Properties.ProgramStatus, "Removed");
     program.IsEnabled = false;
     automationPrograms.Remove(program);
     // delete program files
     string file = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "programs");
     // remove csharp assembly
     try
     {
         File.Delete(Path.Combine(file, program.Address + ".dll"));
     }
     catch
     {
     }
     // remove arduino folder files 
     try
     {
         Directory.Delete(Path.Combine(file, "arduino", program.Address.ToString()), true);
     } catch { }
 }

 public void ProgramAdd(ProgramBlock program)
 {
     automationPrograms.Add(program);
     program.EnabledStateChanged += program_EnabledStateChanged;
     program.Engine.SetHost(homegenie);
     RaiseProgramModuleEvent(program, Properties.ProgramStatus, "Added");
     if (isEngineEnabled && program.IsEnabled)
     {
         program.Engine.StartScheduler();
     }
 }

 // TODO: v1.1 !!!IMPORTANT!!! move thread allocation and starting to ProgramEngineBase.cs class
 public void Run(ProgramBlock program, string options)
 {
     program.Engine.StartProgram(options);
 }

 public void ProgramRemove(ProgramBlock program)
 {
     program.IsEnabled = false;
     program.Stop();
     automationPrograms.Remove(program);
 }

        private List<ProgramError> CompileArduino(ProgramBlock program)
        {
            List<ProgramError> errors = new List<ProgramError>();

            // Generate, compile and upload Arduino Sketch
            string sketchFileName = ArduinoAppFactory.GetSketchFile(program.Address.ToString());
            if (!Directory.Exists(Path.GetDirectoryName(sketchFileName)))
            {
                Directory.CreateDirectory(Path.GetDirectoryName(sketchFileName));
            }
            string sketchMakefile = Path.Combine(Path.GetDirectoryName(sketchFileName), "Makefile");

            try
            {
                // .ino source is stored in the ScriptSource property
                File.WriteAllText(sketchFileName, program.ScriptSource);
                // Makefile source is stored in the ScriptCondition property
                File.WriteAllText(sketchMakefile, program.ScriptCondition);
                errors = ArduinoAppFactory.CompileSketch(sketchFileName, sketchMakefile);
            }
            catch (Exception e)
            { 
                errors.Add(new ProgramError() {
                    Line = 0,
                    Column = 0,
                    ErrorMessage = "General failure: is 'arduino-mk' package installed?\n\n" + e.Message,
                    ErrorNumber = "500",
                    CodeBlock = "CR"
                });
            }

            return errors;
        }

 public CSharpEngine(ProgramBlock pb)
     : base(pb)
 {
 }

 public void Run(ProgramBlock program, string options)
 {
     if (program.IsRunning) return;
     //
     if (program.ProgramThread != null)
     {
         program.Stop();
         program.IsRunning = false;
     }
     //
     program.IsRunning = true;
     RaiseProgramModuleEvent(program, "Program.Status", "Running");
     //
     if (program.Type.ToLower() != "wizard")
     {
         if (program.Type.ToLower() == "csharp" && program.AppAssembly == null)
         {
             program.IsRunning = false;
         }
         else
         {
             program.TriggerTime = DateTime.UtcNow;
             program.ProgramThread = new Thread(() =>
             {
                 MethodRunResult result = null;
                 try
                 {
                     result = program.Run(options);
                 } catch (Exception ex) {
                     result = new MethodRunResult();
                     result.Exception = ex;
                 }
                 //
                 if (result != null && result.Exception != null)
                 {
                     // runtime error occurred, script is being disabled
                     // so user can notice and fix it
                     List<ProgramError> error = new List<ProgramError>() { new ProgramError() {
                             CodeBlock = "CR",
                             Column = 0,
                             Line = 0,
                             ErrorNumber = "-1",
                             ErrorMessage = result.Exception.Message
                         }
                     };
                     program.ScriptErrors = JsonConvert.SerializeObject(error);
                     program.IsEnabled = false;
                     RaiseProgramModuleEvent(
                         program,
                         "Runtime.Error",
                         "CR: " + result.Exception.Message.Replace(
                             '\n',
                             ' '
                         )
                     );
                 }
                 program.IsRunning = false;
                 program.ProgramThread = null;
                 RaiseProgramModuleEvent(program, "Program.Status", "Idle");
             });
             //
             try
             {
                 program.ProgramThread.Start();
             }
             catch
             {
                 program.Stop();
                 program.IsRunning = false;
                 RaiseProgramModuleEvent(program, "Program.Status", "Idle");
             }
         }
     }
     else
     {
         program.TriggerTime = DateTime.UtcNow;
         if (program.ConditionType == ConditionType.Once)
         {
             program.IsEnabled = false;
         }
         //
         program.ProgramThread = new Thread(() =>
         {
             try
             {
                 ExecuteWizardScript(program);
             }
             catch (ThreadAbortException)
             {
                 program.IsRunning = false;
             }
             finally
             {
                 program.IsRunning = false;
             }
             RaiseProgramModuleEvent(program, "Program.Status", "Idle");
         });
         //
         program.ProgramThread.Start();
     }
//.........这里部分代码省略.........

//.........这里部分代码省略.........
                {
                    homegenie.MigService.GetGateway("WebServiceGateway").SetOption("Port", migCommand.GetOption(1));
                    homegenie.SystemConfiguration.Update();
                }
                else if (migCommand.GetOption(0) == "HttpService.GetHostHeader")
                {
                    var host = homegenie.MigService.GetGateway("WebServiceGateway").GetOption("Host");
                    request.ResponseData = new ResponseText(host != null ? host.Value : "*");
                }
                else if (migCommand.GetOption(0) == "HttpService.SetHostHeader")
                {
                    homegenie.MigService.GetGateway("WebServiceGateway").SetOption("Host", migCommand.GetOption(1));
                    homegenie.SystemConfiguration.Update();
                }
                else if (migCommand.GetOption(0) == "System.ConfigurationRestore")
                {
                    // file uploaded by user
                    string archivename = Path.Combine(tempFolderPath, "homegenie_restore_config.zip");
                    Utility.FolderCleanUp(Utility.GetTmpFolder());
                    try
                    {
                        MIG.Gateways.WebServiceUtility.SaveFile(request.RequestData, archivename);
                        Utility.UncompressZip(archivename, tempFolderPath);
                        File.Delete(archivename);
                        request.ResponseData = new ResponseStatus(Status.Ok);
                    }
                    catch
                    {
                        request.ResponseData = new ResponseStatus(Status.Error);
                    }
                }
                else if (migCommand.GetOption(0) == "System.ConfigurationRestoreS1")
                {
                    var serializer = new XmlSerializer(typeof(List<ProgramBlock>));
                    var reader = new StreamReader(Path.Combine(tempFolderPath, "programs.xml"));
                    var newProgramsData = (List<ProgramBlock>)serializer.Deserialize(reader);
                    reader.Close();
                    var newProgramList = new List<ProgramBlock>();
                    foreach (ProgramBlock program in newProgramsData)
                    {
                        if (program.Address >= ProgramManager.USER_SPACE_PROGRAMS_START)
                        {
                            ProgramBlock p = new ProgramBlock();
                            p.Address = program.Address;
                            p.Name = program.Name;
                            p.Description = program.Description;
                            newProgramList.Add(p);
                        }
                    }
                    newProgramList.Sort(delegate(ProgramBlock p1, ProgramBlock p2)
                    {
                        string c1 = p1.Address.ToString();
                        string c2 = p2.Address.ToString();
                        return c1.CompareTo(c2);
                    });
                    request.ResponseData = newProgramList;
                }
                else if (migCommand.GetOption(0) == "System.ConfigurationRestoreS2")
                {
                    // Import automation groups
                    var serializer = new XmlSerializer(typeof(List<Group>));
                    var reader = new StreamReader(Path.Combine(tempFolderPath, "automationgroups.xml"));
                    var automationGroups = (List<Group>)serializer.Deserialize(reader);
                    reader.Close();
                    foreach (var automationGroup in automationGroups)
                    {

 public void ProgramAdd(ProgramBlock program)
 {
     program.SetHost(homegenie);
     automationPrograms.Add(program);
     program.EnabledStateChanged += program_EnabledStateChanged;
     //
     // Initialize state
     RaiseProgramModuleEvent(program, "Program.Status", "Idle");
     if (program.IsEnabled)
     {
         StartProgramEvaluator(program);
     }
 }