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();
}
