private static void InitializeEnvironmentSettingsManager(out EnvironmentSettingsManager environmentSettingsManager) { environmentSettingsManager = new EnvironmentSettingsManager(false); environmentSettingsManager.ConnectToServer(GetConnectionString()); environmentSettingsManager.InitializeSettingsManager(); }
internal EnvironmentSettingsManager GetEnvironmentSettingsManager() { var environmentSettingsManager = new EnvironmentSettingsManager(false, false); environmentSettingsManager.ConnectToServer(_k2Client.K2Config.HostServerConnectionString); environmentSettingsManager.InitializeSettingsManager(true); return(environmentSettingsManager); }
private static void EditEnvironment(EnvironmentSettingsManager environmentSettingsManager, string EnvironmentName, string EnvironmentDesc, string EnvironmentId, bool IsDefault) { EnvironmentInstance environment = environmentSettingsManager.EnvironmentTemplates.FindEnvironment(EnvironmentId); environment.EnvironmentName = EnvironmentName; environment.EnvironmentDescription = EnvironmentDesc; environment.IsDefaultEnvironment = IsDefault; environment.SaveUpdate(); }
internal virtual EnvironmentSettingsManagerWrapper GetEnvironmentSettingsManagerWrapper(EnvironmentSettingsManager server) { if (server == null) { server = new EnvironmentSettingsManager(false, false); server.ConnectToServer(ConnectionHelper.SmartObjectConnectionStringBuilder.ConnectionString); server.InitializeSettingsManager(true); } return(new EnvironmentSettingsManagerWrapper(server)); }
private void InitaliseEnvironmentForSpecifiedEnvironment(EnvironmentSettingsManager environmentManager, string devString) { Console.WriteLine("\n**************** GetEnvironmentFields({0})*********************", devString); environmentManager.ConnectToServer(ConnectionString); environmentManager.InitializeSettingsManager(); environmentManager.ConnectToServer(ConnectionString); environmentManager.ChangeEnvironment(devString); environmentManager.InitializeSettingsManager(); environmentManager.GetEnvironmentFields(environmentManager.CurrentEnvironment); }
/// <summary> /// Gets the deployment package. /// </summary> /// <param name="project">The K2 project.</param> /// <param name="environmentManager">The K2 environment manager.</param> /// <param name="IsTest">Will Deployment Package be in Test Mode?</param> /// <returns>The Deployment Package</returns> public static DeploymentPackage CreateDeploymentPackage( Project project, EnvironmentSettingsManager environmentManager, string DeploymentLabel, string DeploymentDescription, bool IsTest) { DeploymentPackage package; LogHelper.LogMessage(" -- Creating Deployment Package"); package = project.CreateDeploymentPackage(); // Populate Environment Fields foreach (EnvironmentInstance env in environmentManager.CurrentTemplate.Environments) { DeploymentEnvironment depEnv = package.AddEnvironment(env.EnvironmentName); foreach (EnvironmentField field in env.EnvironmentFields) { depEnv.Properties[field.FieldName] = field.Value; } } LogHelper.LogMessage(" -- Setting Package Info"); package.SelectedEnvironment = environmentManager.CurrentEnvironment.EnvironmentName; package.DeploymentLabelName = string.IsNullOrEmpty(DeploymentLabel) ? DateTime.Now.ToString() : DeploymentLabel; package.DeploymentLabelDescription = DeploymentDescription; package.TestOnly = IsTest; LogHelper.LogMessage(" SelectedEnvironment = " + package.SelectedEnvironment); LogHelper.LogMessage(" DeploymentLabelName = " + package.DeploymentLabelName); LogHelper.LogMessage(" DeploymentLabelDescription = " + package.DeploymentLabelDescription); LogHelper.LogMessage(" TestOnly = " + package.TestOnly); // Get the Default SmartObject Server in the Environment // The prefix "$Field=" is when the value of the SmartObject server is registered in the environment fields collection. // this will do a lookup in the environment with the display name of the field, and use the value. // If you set the value directly, no lookups will be performed. EnvironmentField smartObjectServerField = environmentManager.CurrentEnvironment.GetDefaultField(typeof(SmartObjectField)); LogHelper.LogMessage(" -- Setting SmartObject Server ConnectionString"); package.SmartObjectConnectionString = "$Field=" + smartObjectServerField.DisplayName; LogHelper.LogMessage(" SmartObject Server ConnectionString = " + package.SmartObjectConnectionString); // Get the Default Workflow Management Server in the Environment EnvironmentField workflowServerField = environmentManager.CurrentEnvironment.GetDefaultField(typeof(WorkflowManagementServerField)); LogHelper.LogMessage(" -- Setting Workflow Management ConnectionString"); package.WorkflowManagementConnectionString = "$Field=" + workflowServerField.DisplayName; LogHelper.LogMessage(" Workflow Management ConnectionString = " + package.WorkflowManagementConnectionString); return package; }
/// <summary> /// Gets the deployment package. /// </summary> /// <param name="project">The K2 project.</param> /// <param name="environmentManager">The K2 environment manager.</param> /// <param name="IsTest">Will Deployment Package be in Test Mode?</param> /// <returns>The Deployment Package</returns> public static DeploymentPackage CreateDeploymentPackage( Project project, EnvironmentSettingsManager environmentManager, string DeploymentLabel, string DeploymentDescription, bool IsTest) { DeploymentPackage package; LogHelper.LogMessage(" -- Creating Deployment Package"); package = project.CreateDeploymentPackage(); // Populate Environment Fields foreach (EnvironmentInstance env in environmentManager.CurrentTemplate.Environments) { DeploymentEnvironment depEnv = package.AddEnvironment(env.EnvironmentName); foreach (EnvironmentField field in env.EnvironmentFields) { depEnv.Properties[field.FieldName] = field.Value; } } LogHelper.LogMessage(" -- Setting Package Info"); package.SelectedEnvironment = environmentManager.CurrentEnvironment.EnvironmentName; package.DeploymentLabelName = string.IsNullOrEmpty(DeploymentLabel) ? DateTime.Now.ToString() : DeploymentLabel; package.DeploymentLabelDescription = DeploymentDescription; package.TestOnly = IsTest; LogHelper.LogMessage(" SelectedEnvironment = " + package.SelectedEnvironment); LogHelper.LogMessage(" DeploymentLabelName = " + package.DeploymentLabelName); LogHelper.LogMessage(" DeploymentLabelDescription = " + package.DeploymentLabelDescription); LogHelper.LogMessage(" TestOnly = " + package.TestOnly); // Get the Default SmartObject Server in the Environment // The prefix "$Field=" is when the value of the SmartObject server is registered in the environment fields collection. // this will do a lookup in the environment with the display name of the field, and use the value. // If you set the value directly, no lookups will be performed. EnvironmentField smartObjectServerField = environmentManager.CurrentEnvironment.GetDefaultField(typeof(SmartObjectField)); LogHelper.LogMessage(" -- Setting SmartObject Server ConnectionString"); package.SmartObjectConnectionString = "$Field=" + smartObjectServerField.DisplayName; LogHelper.LogMessage(" SmartObject Server ConnectionString = " + package.SmartObjectConnectionString); // Get the Default Workflow Management Server in the Environment EnvironmentField workflowServerField = environmentManager.CurrentEnvironment.GetDefaultField(typeof(WorkflowManagementServerField)); LogHelper.LogMessage(" -- Setting Workflow Management ConnectionString"); package.WorkflowManagementConnectionString = "$Field=" + workflowServerField.DisplayName; LogHelper.LogMessage(" Workflow Management ConnectionString = " + package.WorkflowManagementConnectionString); return(package); }
/// <summary> /// Gets an EnvironmentSettingsManager for the specified environment. /// </summary> /// <param name="ConnStr">The K2 connection string.</param> /// <param name="EnvName">The targetted K2 environment.</param> /// <param name="UseCache">Use local K2 Environment Cache?</param> /// <returns> /// An EnvironmentSettingsManager object containing settings /// for the specified environment /// </returns> public static EnvironmentSettingsManager GetEnvironmentManager( string ConnStr, string EnvName, bool LocalOnly) { LogHelper.LogMessage(" -- Creating K2 Environment Manager"); LogHelper.LogMessage(" -- Use Local Environment Cache = " + LocalOnly.ToString()); EnvironmentSettingsManager environmentManager = new EnvironmentSettingsManager(false, true); environmentManager.ConnectionString = ConnStr; // Use the Local Environment Cache only. Do not connect to the K2 Server if (LocalOnly) { environmentManager.WorkOffline = true; LogHelper.LogMessage(" -- Loading Environment Cache"); environmentManager.LoadCache(); } // Connect to the K2 Server to retrieve the Environment settings else { LogHelper.LogMessage(" -- Connecting Environment Manager to K2 Server"); environmentManager.ConnectToServer(); LogHelper.LogMessage(" -- Refreshing Environment"); environmentManager.Refresh(); LogHelper.LogMessage(" -- Saving Environment to local cache"); environmentManager.SaveCache(); } LogHelper.LogMessage(" -- Setting the Environment to " + EnvName); if (!string.IsNullOrEmpty(EnvName)) { environmentManager.ChangeEnvironment(EnvName); } LogHelper.LogMessage(" -- Initializing Environment Settings Manager"); environmentManager.InitializeSettingsManager(); LogHelper.LogMessage(" -- Getting the Environment fields"); if (environmentManager.CurrentEnvironment == null) { throw new ArgumentException("Environment does not exist!"); } else { environmentManager.GetEnvironmentFields(environmentManager.CurrentEnvironment); } return(environmentManager); }
public static async Task <int> ExecuteAsync( NewFileOptions fileOptions, IConsole console, IAppEnvironment appEnvironment, InvocationContext context = null) { var settingsManager = new EnvironmentSettingsManager(appEnvironment); EnvironmentSettings environmentSettings = settingsManager.LoadSettings(); if (environmentSettings.WorkspacePath != null && fileOptions.FilePath != null) { console.Error.WriteLine("You must either set a workspace via the environment command or supply a filepath."); return(ReturnCodes.Error); } if (fileOptions.FilePath != null) { environmentSettings.WorkspacePath = fileOptions.FilePath.FullName; } List <ContentTypeConventionsRoot> conventions = await FindAllConventions(appEnvironment); // Select the convention that matches the template name specified ContentTypeConventionsRoot contentTypeConventionsRoot = conventions.FirstOrDefault(x => x.Conventions.Any(y => y.Conventions.Any(z => z.Value == fileOptions.TemplateName))); // Now find the filepath.. Convention convention = contentTypeConventionsRoot?.Conventions.SelectMany(x => x.Conventions).FirstOrDefault(x => x.ContentType.StartsWith(ConventionContentTypes.FilePaths, StringComparison.CurrentCultureIgnoreCase)); if (convention != null) { IVariableDirectoryPath variablePath = convention.Value.ToVariableDirectoryPath(); if (variablePath.TryResolve(environmentSettings.ToKvPs(), out IAbsoluteDirectoryPath evaluatedPath) == VariablePathResolvingStatus.Success) { IAbsoluteFilePath filepath = evaluatedPath.GetChildFileWithName($"post-{DateTime.Now:yyyy-MM-dd-HH-mm-ss}.md"); if (!filepath.ParentDirectoryPath.Exists) { Directory.CreateDirectory(filepath.ParentDirectoryPath.ToString()); } string template = Path.Join(contentTypeConventionsRoot.FilePath.ParentDirectoryPath.ParentDirectoryPath.ToString(), contentTypeConventionsRoot?.Conventions.FirstOrDefault()?.TemplatePath); File.Copy(template, filepath.ToString()); console.Out.WriteLine($"Created: {filepath}"); } } return(ReturnCodes.Ok); }
private void LoadDefaultEnvironmentFields() { bool mutexCreated; MutexSecurity mutexsecurity = new MutexSecurity(); mutexsecurity.AddAccessRule(new MutexAccessRule(new SecurityIdentifier(WellKnownSidType.WorldSid, null), MutexRights.Synchronize | MutexRights.Modify, AccessControlType.Allow)); envMutex = new Mutex(false, "Global\\environmentMutext", out mutexCreated, mutexsecurity); envMutex.WaitOne(); Dictionary <string, string> tempEnv = new Dictionary <string, string>(); EnvironmentSettingsManager environmentManager = new EnvironmentSettingsManager(false, true); environmentManager.ConnectToServer(BaseAPIConnectionString); environmentManager.InitializeSettingsManager(); EnvironmentInstance env = environmentManager.EnvironmentTemplates.DefaultTemplate.DefaultEnvironment; if (!string.IsNullOrEmpty(EnvironmentToUseConfiguration)) { env = environmentManager.EnvironmentTemplates.DefaultTemplate.Environments[EnvironmentToUseConfiguration]; } environmentManager.GetEnvironmentFields(env); foreach (EnvironmentField field in env.EnvironmentFields) { // For some reason, a environment can have 2 environment fields with the same name. Go figure. if (!tempEnv.ContainsKey(field.FieldName)) { tempEnv.Add(field.FieldName, field.Value); } } if (!tempEnv.ContainsKey("SmartForms Runtime")) { foreach (EnvironmentField field in env.EnvironmentFields) { if (field.IsDefaultField && string.Compare(field.FieldTypeId, "EC07ABC1-259D-40CE-9485-04EEB3E5DCF0", true) == 0) { tempEnv.Add("SmartForms Runtime", field.Value); break; } } } environmentFields = tempEnv; envMutex.ReleaseMutex(); }
private static void AddEnvironment(EnvironmentSettingsManager environmentSettingsManager, string EnvironmentName, string EnvironmentDesc, string EnvironmentId, string TemplateName, bool IsDefault) { EnvironmentId = System.Guid.NewGuid().ToString(); // Create a new environment instance with the given values. EnvironmentInstance environment = new EnvironmentInstance(EnvironmentId, EnvironmentName, EnvironmentDesc); environment.IsDefaultEnvironment = IsDefault; InitializeEnvironmentSettingsManager(out environmentSettingsManager); var template = environmentSettingsManager.EnvironmentTemplates.GetItemByName(TemplateName); // Add new environment to the EnvironmentInstanceCollection template.Environments.Add(environment); }
public static DeploymentPackage GetPackage(string environmentServer, string destinationTemplate, string destinationEnvironment, Project project, bool testOnly) { //Create connection string to environment server var envionmentServerConnection = EnvionmentServerConnection(environmentServer); //Retrieve the environments from the server EnvironmentSettingsManager environmentManager = new EnvironmentSettingsManager(true); environmentManager.ConnectToServer(envionmentServerConnection); environmentManager.InitializeSettingsManager(true); environmentManager.Refresh(); //Get the template and environment objects. EnvironmentTemplate template = environmentManager.EnvironmentTemplates[destinationTemplate]; EnvironmentInstance environment = template.Environments[destinationEnvironment]; //Create the package DeploymentPackage package = project.CreateDeploymentPackage(); //Set all of the environment fields to the package DeploymentEnvironment deploymentEnv = package.AddEnvironment(environment.EnvironmentName); foreach (EnvironmentField field in environment.EnvironmentFields) { deploymentEnv.Properties[field.FieldName] = field.Value; } //Set fields on the package package.SelectedEnvironment = destinationEnvironment; package.DeploymentLabelName = DateTime.Now.ToString(CultureInfo.InvariantCulture); package.DeploymentLabelDescription = "Template: " + destinationTemplate + ",Environment: " + destinationEnvironment; package.TestOnly = testOnly; //Get the Default SmartObject Server in the Environment //environment.GetDefaultField(typeof(SmartObjectField)); package.SmartObjectConnectionString = envionmentServerConnection; //Get the Default Workflow Management Server in the Environment //environment.GetDefaultField(typeof(WorkflowManagementServerField)); package.WorkflowManagementConnectionString = envionmentServerConnection; return(package); }
public static Task <int> ExecuteAsync( SetOptions options, IConsole console, IAppEnvironment appEnvironment, InvocationContext context = null) { var settingsManager = new EnvironmentSettingsManager(appEnvironment); EnvironmentSettings settings = settingsManager.LoadSettings() ?? new EnvironmentSettings(); if (options.Username != null) { settings.Username = options.Username.ToLowerInvariant(); } if (options.WorkspacePath != null) { settings.WorkspacePath = options.WorkspacePath.FullName; } if (options.PublishPath != null) { settings.PublishPath = options.PublishPath.FullName; } if (options.Key != null && options.Value != null) { if (settings.Configuration.ContainsKey(options.Key)) { settings.Configuration[options.Key] = options.Value; } else { settings.Configuration.Add(options.Key, options.Value); } } settingsManager.SaveSettings(settings); return(Task.FromResult(ReturnCodes.Ok)); }
public static string GetDefaultHostServerConnectionString() { var builder = new SCConnectionStringBuilder(); builder.Host = Environment.MachineName; builder.Port = 5555; builder.IsPrimaryLogin = true; builder.Integrated = true; var connectionString = builder.ConnectionString; try { using (var environmentSettingsManager = new EnvironmentSettingsManager(false)) { environmentSettingsManager.ConnectionString = connectionString; environmentSettingsManager.InitializeSettingsManager(false); if (environmentSettingsManager.EnvironmentTemplates.Count <= 0) { environmentSettingsManager.ConnectToServer(); environmentSettingsManager.InitializeSettingsManager(true); environmentSettingsManager.Disconnect(); } if (environmentSettingsManager.CurrentEnvironment != null) { var smartObjectfield = (SmartObjectField)environmentSettingsManager.CurrentEnvironment.GetDefaultField(typeof(SmartObjectField)); if (smartObjectfield != null) { return(smartObjectfield.ConnectionString); } } } } catch { } return(connectionString); }
private EnvironmentSettingsManager GetEnvironmentManager() { EnvironmentSettingsManager environmentManager = new EnvironmentSettingsManager(false, false); // This is weird but the only way I could get it to work! environmentManager.ConnectToServer(ConnectionString); environmentManager.InitializeSettingsManager(); environmentManager.ConnectToServer(ConnectionString); if (!string.IsNullOrEmpty(environment)) { environmentManager.ChangeEnvironment(environment); } environmentManager.InitializeSettingsManager(); environmentManager.GetEnvironmentFields(environmentManager.CurrentEnvironment); //////////foreach (EnvironmentInstance env in environmentManager.CurrentTemplate.Environments) //////////{ ////////// InitaliseEnvironmentForSpecifiedEnvironment(environmentManager, env.EnvironmentName); //////////} return(environmentManager); }
private bool BuildCompileAndSaveProject(string projectFilePath,string outputPath,EnvironmentSettingsManager environmentManager, int stepNumber) { Project project; DeploymentPackage package; bool result = false; #region 4. Build LogHelper.LogMessage(String.Format("\n{0}.1 Beginning Build",stepNumber)); LogHelper.LogMessage(" -- Loading project file: " + projectFilePath); project = new Project(); project.Load(projectFilePath); LogHelper.LogMessage(" -- Building Project"); result = K2Helper.CompileK2Project(project); if (!result) throw new Exception("The Project did not Compile successfully.\n"); #endregion #region 5. Deployment Package Creation LogHelper.LogMessage(String.Format("\n{0}.2 Creating the Deployment Package",stepNumber)); package = K2Helper.CreateDeploymentPackage( project, environmentManager, DeployLabel, DeployDescription, testOnly); #endregion #region 6. Save Deployment Package LogHelper.LogMessage(String.Format("\n{0}.3. Saving Deployment Package to '" + OutputPath + "'",stepNumber)); FileHelper fileHelper = new FileHelper(); fileHelper.DeleteDirectory(outputPath); package.Save(outputPath, "K2DeploymentPackage"); LogHelper.LogMessage(" -- Package Saved"); #endregion return result; }
/// <summary> /// Gets an EnvironmentSettingsManager for the specified environment. /// </summary> /// <param name="ConnStr">The K2 connection string.</param> /// <param name="EnvName">The targetted K2 environment.</param> /// <param name="UseCache">Use local K2 Environment Cache?</param> /// <returns> /// An EnvironmentSettingsManager object containing settings /// for the specified environment /// </returns> public static EnvironmentSettingsManager GetEnvironmentManager( string ConnStr, string EnvName, bool LocalOnly) { LogHelper.LogMessage(" -- Creating K2 Environment Manager"); LogHelper.LogMessage(" -- Use Local Environment Cache = " + LocalOnly.ToString()); EnvironmentSettingsManager environmentManager = new EnvironmentSettingsManager(false, true); environmentManager.ConnectionString = ConnStr; // Use the Local Environment Cache only. Do not connect to the K2 Server if (LocalOnly) { environmentManager.WorkOffline = true; LogHelper.LogMessage(" -- Loading Environment Cache"); environmentManager.LoadCache(); } // Connect to the K2 Server to retrieve the Environment settings else { LogHelper.LogMessage(" -- Connecting Environment Manager to K2 Server"); environmentManager.ConnectToServer(); LogHelper.LogMessage(" -- Refreshing Environment"); environmentManager.Refresh(); LogHelper.LogMessage(" -- Saving Environment to local cache"); environmentManager.SaveCache(); } LogHelper.LogMessage(" -- Setting the Environment to " + EnvName); if (!string.IsNullOrEmpty(EnvName)) environmentManager.ChangeEnvironment(EnvName); LogHelper.LogMessage(" -- Initializing Environment Settings Manager"); environmentManager.InitializeSettingsManager(); LogHelper.LogMessage(" -- Getting the Environment fields"); if (environmentManager.CurrentEnvironment == null) { throw new ArgumentException("Environment does not exist!"); } else { environmentManager.GetEnvironmentFields(environmentManager.CurrentEnvironment); } return environmentManager; }
//EDGAR 6/1/2010 #region Edgar additions private bool BuildCompileAndSaveProject(string projectFilePath, string outputPath, EnvironmentSettingsManager environmentManager, int stepNumber) { Project project; DeploymentPackage package; bool result = false; #region 4. Build LogHelper.LogMessage(String.Format("\n{0}.1 Beginning Build", stepNumber)); LogHelper.LogMessage(" -- Loading project file: " + projectFilePath); project = new Project(); project.Load(projectFilePath); LogHelper.LogMessage(" -- Building Project"); result = K2Helper.CompileK2Project(project); if (!result) { throw new Exception("The Project did not Compile successfully.\n"); } #endregion #region 5. Deployment Package Creation LogHelper.LogMessage(String.Format("\n{0}.2 Creating the Deployment Package", stepNumber)); package = K2Helper.CreateDeploymentPackage( project, environmentManager, DeployLabel, DeployDescription, testOnly); #endregion #region 6. Save Deployment Package LogHelper.LogMessage(String.Format("\n{0}.3. Saving Deployment Package to '" + OutputPath + "'", stepNumber)); FileHelper fileHelper = new FileHelper(); fileHelper.DeleteDirectory(outputPath); package.Save(outputPath, "K2DeploymentPackage"); LogHelper.LogMessage(" -- Package Saved"); #endregion return(result); }
private DeploymentPackage GetDeploymentPackage(Project project, EnvironmentSettingsManager environmentManager) { DeploymentPackage package; package = project.CreateDeploymentPackage(); var listEnvirnonments = new List <string>(); // Populate Environment Fields foreach (EnvironmentInstance env in environmentManager.CurrentTemplate.Environments) { listEnvirnonments.Add(env.EnvironmentName); } foreach (var envName in listEnvirnonments) { DeploymentEnvironment depEnv = package.AddEnvironment(envName); Console.WriteLine("\n****************Environment Fields********************* FOR {0}", envName); //////environmentManager.ChangeEnvironment(env.EnvironmentName); InitaliseEnvironmentForSpecifiedEnvironment(environmentManager, envName); foreach (EnvironmentInstance env in environmentManager.CurrentTemplate.Environments) { ////// Console.WriteLine("\n foreach (EnvironmentInstance env in environmentManager.CurrentTemplate.Environments) FOR {0}", env.EnvironmentName); if (env.EnvironmentName.Equals(envName)) { //////Console.WriteLine("\n****env.EnvironmentName.Equals(envName)***** FOR {0} {1}", env.EnvironmentName, envName); foreach (EnvironmentField field in env.EnvironmentFields) { //////Console.WriteLine("\n****************Environment Fields********************* FOR {0}", envName); Console.WriteLine("{0} = {1}", depEnv.Properties[field.FieldName], field.Value); depEnv.Properties[field.FieldName] = field.Value; } } } //////Console.WriteLine("\n**************** InitializeSettingsManager()*********************"); //////environmentManager.InitializeSettingsManager(); //////Console.WriteLine("\n**************** GetEnvironmentFields({0})*********************", environmentManager.CurrentEnvironment.EnvironmentName); //////environmentManager.GetEnvironmentFields(environmentManager.CurrentEnvironment); } package.SelectedEnvironment = environmentManager.CurrentEnvironment.EnvironmentName; package.DeploymentLabelName = DateTime.Now.ToString(); package.DeploymentLabelDescription = string.Empty; package.TestOnly = false; Console.WriteLine("\nEnvironment Info:\n\n"); Console.WriteLine("\nSelectedEnvironment = " + package.SelectedEnvironment); Console.WriteLine("\nDeploymentLabelName = " + package.DeploymentLabelName); Console.WriteLine("\nDeploymentLabelDescription = " + package.DeploymentLabelDescription); Console.WriteLine("\nTestOnly = " + package.TestOnly); // Get the Default SmartObject Server in the Environment // The prefix "$Field=" is when the value of the SmartObject server is registered in the environment fields collection. // this will do a lookup in the environment with the display name of the field, and use the value. // If you set the value directly, no lookups will be performed. EnvironmentField smartObjectServerField = environmentManager.CurrentEnvironment.GetDefaultField(typeof(SmartObjectField)); package.SmartObjectConnectionString = "$Field=" + smartObjectServerField.DisplayName; Console.WriteLine("\npackage.SmartObjectConnectionString = " + package.SmartObjectConnectionString); // Get the Default Workflow Management Server in the Environment EnvironmentField workflowServerField = environmentManager.CurrentEnvironment.GetDefaultField(typeof(WorkflowManagementServerField)); package.WorkflowManagementConnectionString = "$Field=" + workflowServerField.DisplayName; Console.WriteLine("\npackage.WorkflowManagementConnectionString = " + package.WorkflowManagementConnectionString); return(package); }
public EnvironmentSettingsManagerWrapper(EnvironmentSettingsManager environmentSettingsManager) { environmentSettingsManager.ThrowIfNull(nameof(environmentSettingsManager)); _environmentSettingsManager = environmentSettingsManager; }
private void LoadDefaultEnvironmentFields() { bool mutexCreated; MutexSecurity mutexsecurity = new MutexSecurity(); mutexsecurity.AddAccessRule(new MutexAccessRule(new SecurityIdentifier(WellKnownSidType.WorldSid, null), MutexRights.Synchronize | MutexRights.Modify, AccessControlType.Allow)); envMutex = new Mutex(false, "Global\\environmentMutext", out mutexCreated, mutexsecurity); envMutex.WaitOne(); Dictionary<string, string> tempEnv = new Dictionary<string, string>(); EnvironmentSettingsManager environmentManager = new EnvironmentSettingsManager(false, true); environmentManager.ConnectToServer(BaseAPIConnectionString); environmentManager.InitializeSettingsManager(); EnvironmentInstance env = environmentManager.EnvironmentTemplates.DefaultTemplate.DefaultEnvironment; if (!string.IsNullOrEmpty(EnvironmentToUseConfiguration)) { env = environmentManager.EnvironmentTemplates.DefaultTemplate.Environments[EnvironmentToUseConfiguration]; } environmentManager.GetEnvironmentFields(env); foreach (EnvironmentField field in env.EnvironmentFields) { // For some reason, a environment can have 2 environment fields with the same name. Go figure. if (!tempEnv.ContainsKey(field.FieldName)) { tempEnv.Add(field.FieldName, field.Value); } } if (!tempEnv.ContainsKey("SmartForms Runtime")) { foreach (EnvironmentField field in env.EnvironmentFields) { if (field.IsDefaultField && string.Compare(field.FieldTypeId, "EC07ABC1-259D-40CE-9485-04EEB3E5DCF0", true) == 0) { tempEnv.Add("SmartForms Runtime", field.Value); break; } } } environmentFields = tempEnv; envMutex.ReleaseMutex(); }