public void Approve(string sn, string action, NameValueCollection dataFields)
{
try
{
K2Helper.Approve(sn, action, dataFields);
}
catch (Exception ex)
{
DBManager.RecoreErrorProfile(ex, "WorkListDAL.Approve", DBManager.GetCurrentUserAD());
}
}
public void Delegate(string sn, string targetUser)
{
try
{
K2Helper.Delegate(sn, targetUser);
}
catch (Exception ex)
{
DBManager.RecoreErrorProfile(ex, "WorkListDAL.Delegate", DBManager.GetCurrentUserAD());
}
}
public void Release(string sn)
{
try
{
K2Helper.Release(sn);
}
catch (Exception ex)
{
DBManager.RecoreErrorProfile(ex, "WorkListDAL.Release", DBManager.GetCurrentUserAD());
}
}
public void Sleep(string sn, int second)
{
try
{
K2Helper.Sleep(sn, second);
}
catch (Exception ex)
{
DBManager.RecoreErrorProfile(ex, "WorkListDAL.Sleep", DBManager.GetCurrentUserAD());
}
}
//we can also use static methods
public static string GetActivityStatus(int processInstanceID, string activityName)
{
using (SourceCode.Field.Core.Helper.K2Helper helper = new K2Helper("dlx"))
{
Dictionary <string, object> Data = new Dictionary <string, object>();
Data.Add("Process Instance ID", processInstanceID.ToString());
Data.Add("Activity Name", activityName);
DataTable dt = helper.SmartObjectClient().SmartObjectGetList(Data, "Activity_Instance", "List");
return(dt.Rows[0].Field <string>("Status"));
}
}
//we can also use static methods
public static string GetActivityStatus(int processInstanceID, string activityName)
{
using (SourceCode.Field.Core.Helper.K2Helper helper = new K2Helper("dlx"))
{
Dictionary<string, object> Data = new Dictionary<string, object>();
Data.Add("Process Instance ID", processInstanceID.ToString());
Data.Add("Activity Name", activityName);
DataTable dt = helper.SmartObjectClient().SmartObjectGetList(Data, "Activity_Instance", "List");
return dt.Rows[0].Field<string>("Status");
}
}
/// <summary>
/// ASSUMPTION: IPCs have the same (otherwise unique) folio as their parents
/// - not always the case, but no other way of detecting IPC
/// This uses the parent Process instance ID to get the folio
/// We then get a list of processes with that folio and exclude the parent.
/// </summary>
/// <param name="ParentProcessInstanceID">pid of the parent</param>
/// <returns>-1 if ipc child is not found, otherwise the processinstanceid</returns>
public static int GetIPCProcessInstanceByFolio(string K2Server, int ParentProcessInstanceID, string ProcessFullName)
{
using (K2Helper helper = new K2Helper(K2Server))
{
string processFolder;
string processName;
SplitPathIntoFolderAndName(ProcessFullName, out processFolder, out processName);
Dictionary <string, object> Data = new Dictionary <string, object>();
Data.Add("ProcessInstanceID", ParentProcessInstanceID.ToString());
DataTable dt = helper.SmartObjectClient().SmartObjectGetList(Data, "Process_Instance", "List");
if (dt.Rows.Count == 0)
{
return((int)ReturnCodes.NoProcessInstanceFound);
}
else
{
foreach (DataRow dr in dt.Rows)
{
string folio = dr.Field <string>("Folio");
Data = new Dictionary <string, object>();
Data.Add("Folio", folio); //where for art thou folio?
Data.Add("ProcessName", processName);
Data.Add("Folder", processFolder);
dt = helper.SmartObjectClient().SmartObjectGetList(Data, "Process_Instance", "List");
if (dt.Rows.Count == 0)
{
return((int)ReturnCodes.NoProcessInstanceFound);
}
else
{
foreach (DataRow row in dt.Rows)
{
if (row.Field <int>("ProcessInstanceID") != ParentProcessInstanceID)
{
return(row.Field <int>("ProcessInstanceID"));
}
}
return((int)ReturnCodes.NoProcessInstanceFound);
}
}
return((int)ReturnCodes.NoProcessInstanceFound);
}
}
}
public void CreateTravelObject(Process p, string num)
{
using (SourceCode.Field.Core.Helper.K2Helper helper = new K2Helper("dlx"))
{
Dictionary<string, object> Data = new Dictionary<string, object>();
Data.Add("PersonName", "Adam Castle");
Data.Add("Amount", num);
string TravelRequestsID = helper.SmartObjectClient().SmartObjectCreate(Data, "TravelRequestsID", "TravelRequests");
//Lets create a new data field, so when our process starts it will start with the new travel request ID
CoreDataField df = new CoreDataField();
df.Name = "TravelRequestsID";
df.Value = TravelRequestsID;
p.Activities[0].DataFields.Add(df.Name,df);
}
}
public void CreateTravelObject(Process p, string num)
{
using (SourceCode.Field.Core.Helper.K2Helper helper = new K2Helper("dlx"))
{
Dictionary <string, object> Data = new Dictionary <string, object>();
Data.Add("PersonName", "Adam Castle");
Data.Add("Amount", num);
string TravelRequestsID = helper.SmartObjectClient().SmartObjectCreate(Data, "TravelRequestsID", "TravelRequests");
//Lets create a new data field, so when our process starts it will start with the new travel request ID
CoreDataField df = new CoreDataField();
df.Name = "TravelRequestsID";
df.Value = TravelRequestsID;
p.Activities[0].DataFields.Add(df.Name, df);
}
}
//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);
}
public static string GetProcessDataFieldValue(string K2Server, int processInstanceID, string dataFieldName)
{
//TODO: this currently opens a connection to wf server twice
using (K2Helper helper = new K2Helper(K2Server))
{
Dictionary <string, object> Data = new Dictionary <string, object>();
Data.Add("ProcessInstanceID", processInstanceID);
Data.Add("DataName", dataFieldName);
//////////Data.Add("ProcessName", "Underwriting\\Supplementary\\Setup");
DataTable dt = helper.SmartObjectClient().SmartObjectGetList(Data, "Process_Data", "List", true);
foreach (DataRow dr in dt.Rows)
{
return(dr.Field <string>("DataValue"));
}
throw new Exception(string.Format("Cannot find datafield {0} for PI: {1}", dataFieldName, processInstanceID));
}
}
public static string GetActivityStatus(string K2Server, int processInstanceID, string activityName)
{
using (K2Helper helper = new K2Helper(K2Server))
{
Dictionary <string, object> Data = new Dictionary <string, object>();
Data.Add("ProcessInstanceID", processInstanceID.ToString());
Data.Add("ActivityName", activityName);
DataTable dt = helper.SmartObjectClient().SmartObjectGetList(Data, "Activity_Instance", "List");
DateTime latestTime = DateTime.MinValue;
string lastestAndGreatestStatus = string.Empty;
foreach (DataRow dr in dt.Rows)
{
DateTime currentTime = dr.Field <DateTime>("StartDate");
if (currentTime > latestTime)
{
lastestAndGreatestStatus = dr.Field <string>("Status");
latestTime = currentTime;
}
}
return(lastestAndGreatestStatus); //empty string if not found
}
}
/// <summary>
/// When overridden in a derived class, executes the task.
/// </summary>
/// <returns>
/// true if the task successfully executed; otherwise, false.
/// </returns>
public override bool Execute()
{
EnvironmentSettingsManager environmentManager;
string newProjectFilePath = string.Empty;
bool result = false;
int currentStep = 0;
// below if block added to check for and purge old cache file if it exists
if (BinFileToDelete != string.Empty)
{
if (System.IO.File.Exists(BinFileToDelete))
{
try
{
System.IO.File.Delete(BinFileToDelete);
}
catch (System.IO.IOException e)
{
LogHelper.LogMessage("\n\n*****Environment Cache Could Not Be Deleted*******\n");
LogHelper.LogMessage(e.Message.ToString());
}
}
}
LogHelper.LogMessage("\n\n***** BEGIN *******\n");
try
{
//check if file exists
//delete file
#region 1. Validation
LogHelper.LogStep(++currentStep, "Validating");
ValidateK2Project();
#endregion
#region 2. Gather Environment Information
LogHelper.LogStep(++currentStep, "Preparing Environment");
LogHelper.LogMessage(" -- Getting K2 Environment Manager");
environmentManager =
K2Helper.GetEnvironmentManager(ConnectionString, Environment, UseEnvironmentCache);
#endregion
#region 3. File Preparation
LogHelper.LogStep(++currentStep, "Preparing Project files");
//Edgar
Dictionary <string, string> dictFiles = null;
//check if the user want to compile the project as a whole or artifacts individually
if (CompileProjectArtifactsIndividually)
{
dictFiles = GetNewProjectFiles(ref newProjectFilePath);
LogHelper.LogMessage("\n3.1 Project files created in Temporary folder");
//we next need to create backup of the original file
FileHelper fileHelper = new FileHelper();
fileHelper.CopyFile(newProjectFilePath, newProjectFilePath + ".bak", true);
LogHelper.LogMessage("File has been backed up = " + newProjectFilePath);
foreach (KeyValuePair <string, string> kvp in dictFiles)
{
// currentStep += 1;
string artifactName = kvp.Key;
string newOutputPath = outputPath + @"\" + artifactName;
//we need to replace the original file w/ this one.
fileHelper.ReplaceFile(newProjectFilePath, kvp.Value);
//it will always compile the the project under the original name;
result = BuildCompileAndSaveProject(newProjectFilePath, newOutputPath, environmentManager, currentStep);
currentStep += 1;
}
fileHelper = null;
}
else
{
//default behavior as originally coded
newProjectFilePath = GetNewProjectFile();
LogHelper.LogMessage("\n3.1 Project files created in Temporary folder");
BuildCompileAndSaveProject(newProjectFilePath, outputPath, environmentManager, currentStep);
currentStep += 1;
}
//Edgar//
#endregion
/*
#region 7. Execute Deployment Package
*
*
* // Execute the Deployment Package
* LogHelper.LogMessage("\nExecuting deployment package...");
* results = package.Execute();
*
* // Record success result
* result = results.Successful;
* LogHelper.LogMessage("\nSuccessful = " + result);
*
*
#endregion
*/
result = true;
}
catch (Exception ex)
{
LogHelper.LogMessage(ex.ToString());
throw;
}
finally
{
LogHelper.LogMessage("\n***** END *******\n\n");
}
return(result);
}
/// <summary>
/// When overridden in a derived class, executes the task.
/// </summary>
/// <returns>
/// true if the task successfully executed; otherwise, false.
/// </returns>
public override bool Execute()
{
bool result;
int currentStep = 0;
LogHelper.LogMessage("\n\n***** BEGIN *******\n");
LogHelper.LogSubStepInfo("K2 Server: " + K2Server);
LogHelper.LogSubStepInfo("K2 HostServer Port: " + K2HostServerPort.ToString());
LogHelper.LogSubStepInfo("Service Type Guid: " + ServiceTypeGuid);
LogHelper.LogSubStepInfo("Service Type : " + ServiceTypeSystemName);
LogHelper.LogSubStepInfo("Service Type : " + ServiceTypeDisplayName);
LogHelper.LogSubStepInfo("Service Type : " + ServiceTypeDescription);
LogHelper.LogSubStepInfo("Service Type : " + ServiceTypeAssemblyPath);
LogHelper.LogSubStepInfo("Service Type : " + serviceTypeClassName);
try
{
LogHelper.LogStep(++currentStep, "Validating");
if (!GuidHelper.IsGuid(ServiceTypeGuid))
{
throw new ArgumentException("Invalid Service Type Guid");
}
if (!File.Exists(ServiceTypeAssemblyPath))
{
throw new ArgumentException("Service Type Assembly Path is not valid.");
}
// Create the Guid
Guid svcGuid = new Guid(ServiceTypeGuid);
LogHelper.LogStep(++currentStep, "Getting K2 Service Manager");
LogHelper.LogSubStep("Create K2 Service Manager");
ServiceManagementServer svcMng = new ServiceManagementServer();
using (svcMng.CreateConnection())
{
LogHelper.LogSubStep("Opening Connection to K2 Server");
svcMng.Connection.Open(ConnectionString);
LogHelper.LogSubStepInfo("Connection State: " +
(svcMng.Connection.IsConnected ? "Connected" : "Disconnected"));
LogHelper.LogStep(++currentStep, "Registering Service Type");
LogHelper.LogSubStep("Determining if Service Type already exists");
// Check if this Service Type is already registered
if (String.IsNullOrEmpty(svcMng.GetServiceType(svcGuid)))
{
LogHelper.LogSubStepInfo("Service Type does not exist");
LogHelper.LogSubStep("Getting Service Type Definition");
// NOTE: Registering the Service Type without this Service Type definition
// results in incorrect registration
string svcTypeDefinition =
K2Helper.GetK2ServiceTypeDefinition(
svcGuid, ServiceTypeSystemName, ServiceTypeDisplayName,
ServiceTypeDescription, ServiceTypeAssemblyPath, ServiceTypeClassName);
LogHelper.LogSubStepInfo(svcTypeDefinition);
LogHelper.LogSubStep("Registering new Service Type");
svcMng.RegisterServiceType(svcGuid, svcTypeDefinition);
if (String.IsNullOrEmpty(svcMng.GetServiceType(svcGuid)))
{
throw new Exception("Registration of Service Type Unsuccessful");
}
else
{
LogHelper.LogSubStepInfo("Registration of Service Type was Successful");
}
}
else
{
LogHelper.LogSubStepInfo("Service Type already exists");
LogHelper.LogSubStep("Updating existing Service Type");
svcMng.UpdateServiceType(
svcGuid, ServiceTypeSystemName, ServiceTypeDisplayName,
ServiceTypeDescription, ServiceTypeAssemblyPath, ServiceTypeClassName);
if (String.IsNullOrEmpty(svcMng.GetServiceType(svcGuid)))
{
throw new Exception("Update of Service Type Unsuccessful");
}
else
{
LogHelper.LogSubStepInfo("Update of Service Type was Successful");
}
}
}
result = true;
}
catch
{
throw;
}
finally
{
LogHelper.LogMessage("\n***** END *******\n\n");
}
return(result);
}
/// <summary>
/// When overridden in a derived class, executes the task.
/// </summary>
/// <returns>
/// true if the task successfully executed; otherwise, false.
/// </returns>
public override bool Execute()
{
bool result;
int currentStep = 0;
// clean up some values
char token = '"';
K2Server = K2Helper.StripLeadingAndTailing(K2Server, token);
ServiceInstanceGuid = K2Helper.StripLeadingAndTailing(ServiceInstanceGuid, token);
ServiceInstanceSystemName = K2Helper.StripLeadingAndTailing(ServiceInstanceSystemName, token);
ServiceInstanceDisplayName = K2Helper.StripLeadingAndTailing(ServiceInstanceDisplayName, token);
ServiceInstanceDescription = K2Helper.StripLeadingAndTailing(ServiceInstanceDescription, token);
ConfigKeyNames = K2Helper.StripLeadingAndTailing(configKeyNames, token);
ConfigKeyValues = K2Helper.StripLeadingAndTailing(ConfigKeyValues, token);
ConfigKeysRequired = K2Helper.StripLeadingAndTailing(ConfigKeysRequired, token);
ConfigKeyDelimiter = K2Helper.StripLeadingAndTailing(ConfigKeyDelimiter, token);
LogHelper.LogMessage("\n\n***** BEGIN *******\n");
LogHelper.LogSubStepInfo("K2 Server: " + K2Server);
LogHelper.LogSubStepInfo("K2 HostServer Port: " + K2HostServerPort.ToString());
LogHelper.LogSubStepInfo("Service Instance Guid: " + ServiceInstanceGuid);
LogHelper.LogSubStepInfo("Service Instance : " + ServiceInstanceSystemName);
LogHelper.LogSubStepInfo("Service Instance : " + ServiceInstanceDisplayName);
LogHelper.LogSubStepInfo("Service Instance : " + ServiceInstanceDescription);
LogHelper.LogSubStepInfo("Config Key Names : " + ConfigKeyNames);
LogHelper.LogSubStepInfo("Config Key Values : " + ConfigKeyValues);
LogHelper.LogSubStepInfo("Config Key Reqds : " + ConfigKeysRequired);
LogHelper.LogSubStepInfo("Config Delimiter : " + ConfigKeyDelimiter);
try
{
LogHelper.LogStep(++currentStep, "Validating");
if (!GuidHelper.IsGuid(ServiceTypeGuid))
{
throw new ArgumentException("Invalid Service Type Guid");
}
if (!GuidHelper.IsGuid(ServiceInstanceGuid))
{
throw new ArgumentException("Invalid Service Instance Guid");
}
// Create the Service Type Guid
Guid svcTypeGuid = new Guid(ServiceTypeGuid);
// Create the Service Instance Guid
Guid svcInstanceGuid = new Guid(ServiceInstanceGuid);
LogHelper.LogStep(++currentStep, "Getting K2 Service Manager");
LogHelper.LogSubStep("Create K2 Service Manager");
ServiceManagementServer svcMng = new ServiceManagementServer();
using (svcMng.CreateConnection())
{
LogHelper.LogSubStep("Opening Connection to K2 Server");
svcMng.Connection.Open(ConnectionString);
LogHelper.LogSubStepInfo("Connection State: " +
(svcMng.Connection.IsConnected ? "Connected" : "Disconnected"));
char delim = ',';
if (ConfigKeyDelimiter.Length == 1)
{
delim = ConfigKeyDelimiter.ToCharArray()[0];
}
LogHelper.LogSubStep("Getting Service Instance Configuration");
string svcInstanceConfig = K2Helper.GetK2ServiceInstanceConfig(
ConfigImpersonate, ConfigKeyNames, ConfigKeyValues,
ConfigKeysRequired, delim);
LogHelper.LogSubStepInfo("Service Instance Config = ");
LogHelper.LogSubStepInfo(svcInstanceConfig);
LogHelper.LogStep(++currentStep, "Registering Service Instance");
LogHelper.LogSubStep("Determining if Service Instance already exists");
// Check if this Service Instance is already registered
if (!K2Helper.DetermineIfServiceInstanceExists(svcMng, svcInstanceGuid))
{
LogHelper.LogSubStepInfo("Service Instance does not exist");
LogHelper.LogSubStep("Registering new Service Instance");
svcMng.RegisterServiceInstance(
svcTypeGuid, svcInstanceGuid, ServiceInstanceSystemName,
ServiceInstanceDisplayName, ServiceInstanceDescription, svcInstanceConfig);
if (!K2Helper.DetermineIfServiceInstanceExists(svcMng, svcInstanceGuid))
{
throw new Exception("Registration of Service Instance Unsuccessful");
}
else
{
LogHelper.LogSubStepInfo("Registration of Service Instance was Successful");
}
}
else
{
LogHelper.LogSubStepInfo("Service Instance already exists");
LogHelper.LogSubStep("Updating existing Service Instance");
svcMng.UpdateServiceInstance(
svcTypeGuid, svcInstanceGuid, ServiceInstanceSystemName,
ServiceInstanceDisplayName, ServiceInstanceDescription, svcInstanceConfig);
if (!K2Helper.DetermineIfServiceInstanceExists(svcMng, svcInstanceGuid))
{
throw new Exception("Update of Service Instance Unsuccessful");
}
else
{
LogHelper.LogSubStepInfo("Update of Service Instance was Successful");
}
}
}
result = true;
}
catch (Exception ex)
{
throw ex;
//LogHelper.LogSubStepInfo(string.Format("Got an error:{0}{1}", ex.Message, ex.StackTrace));
//result = false;
}
finally
{
LogHelper.LogMessage("\n***** END *******\n\n");
}
return(result);
}
