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