////////////////////////////////////////////////////////////////////////
// METHOD: Execute
public int Execute(int jobID, int stepID, ref object[] argv, ref IJTXCustomStepFeedback ipFeedback)
{
// Present form to user for choosing the data workspace
// they want to work with for the current job.
JTXSamples.DataWorkspaceSelectorDialog frmDataWSSelector = new JTXSamples.DataWorkspaceSelectorDialog();
frmDataWSSelector.StartPosition = FormStartPosition.CenterParent;
// Populate the list of data workspaces configured for the JTX system
IJTXDatabaseConnectionManager pDBConnManager = new JTXDatabaseConnectionManagerClass();
IJTXDatabaseConnection pDBConnection = pDBConnManager.GetConnection(m_ipDatabase.Alias);
for (int a = 0; a < pDBConnection.DataWorkspaceCount; a++)
{
IJTXWorkspaceConfiguration pDataWorkspace = pDBConnection.get_DataWorkspace(a);
frmDataWSSelector.DWName = pDataWorkspace.Name;
}
// Pass some other information to the form
frmDataWSSelector.JTXDB = m_ipDatabase;
IJTXJobManager pJobManager = m_ipDatabase.JobManager;
IJTXJob2 pJob = pJobManager.GetJob(jobID) as IJTXJob2;
frmDataWSSelector.theJob = pJob;
if (frmDataWSSelector.ShowDialog() == DialogResult.OK)
{
return(1);
}
return(0);
}
////////////////////////////////////////////////////////////////////////
// METHOD: Execute
public int Execute(int jobID, int stepID, ref object[] argv, ref IJTXCustomStepFeedback ipFeedback)
{
// Verify whether the current job has a version or not
// Get the current job
IJTXJobManager pJobManager = m_ipDatabase.JobManager;
IJTXJob2 pJob = pJobManager.GetJob(jobID) as IJTXJob2;
// Check for a data workspace
IJTXDataWorkspaceName pJobDataWorkspace = pJob.ActiveDatabase;
if (pJobDataWorkspace == null)
{
MessageBox.Show("No data workspace selected for job");
return(3);
}
// Check if version exists
if (pJob.VersionExists())
{
MessageBox.Show("Job version has been defined");
return(1);
}
else
{
MessageBox.Show("No version defined for job");
return(2);
}
}
////////////////////////////////////////////////////////////////////////
// METHOD: GetNumberOfJobs
private bool GetNumberOfJobs(IJTXJob2 pParentJob, ref IArray aoiList, out int numJobs)
{
bool AOIFromOverlap = false;
bool AOIFromParent = false;
numJobs = -1;
// Then use defaults
AOIFromOverlap = !string.IsNullOrEmpty(m_AOIOverlapFeatureClassName);
AOIFromParent = m_paramUseParentAOI;
numJobs = m_paramNumberChildJobs;
if (AOIFromOverlap)
{
if (!PopulateAOIListUsingOverlapFeatureClass(pParentJob, ref aoiList))
{
return(false);
}
numJobs = aoiList.Count;
}
else if (AOIFromParent)
{
if (!PopulateAOIListUsingParent(pParentJob, ref aoiList, numJobs))
{
return(false);
}
}
return(true);
}
////////////////////////////////////////////////////////////////////////
// METHOD: Execute
public int Execute(int jobID, int stepID, ref object[] argv, ref IJTXCustomStepFeedback ipFeedback)
{
// Verify whether an AOI has been defined for the current job
try
{
// Get the current job
IJTXJobManager pJobManager = m_ipDatabase.JobManager;
IJTXJob2 pJob = pJobManager.GetJob(jobID) as IJTXJob2;
// Check if AOI exists
if (pJob.AOIExtent != null)
{
// AOI exists
return(1);
}
else
{
// AOI does not exist
return(2);
}
}
catch (Exception ex)
{
throw ex;
}
}
////////////////////////////////////////////////////////////////////////
// METHOD: AssignChildVersion
private bool AssignChildVersion(IJTXJob2 pParentJob, ref IJTXJob pJob)
{
if (m_paramAssignVersionType == AssignVersionType.UseParentJobsVersion)
{
((IJTXJob2)pJob).SetActiveDatabase(pParentJob.ActiveDatabase.DatabaseID);
pJob.ParentVersion = pParentJob.ParentVersion;
pJob.VersionName = pParentJob.VersionName;
}
return(true);
}
////////////////////////////////////////////////////////////////////////
// METHOD: PopulateAOIListUsingParent
private bool PopulateAOIListUsingParent(IJTXJob2 pParentJob, ref IArray aoiList, int numCopies)
{
try
{
aoiList = new ArrayClass();
for (int i = 0; i < numCopies; i++)
{
aoiList.Add(pParentJob.AOIExtent);
}
}
catch (Exception ex)
{
throw new Exception("Unable to create AOIs based on parent job's AOI: " + ex.Message);
}
return(true);
}
/// <summary>
/// Called when a step of this type is executed in the workflow.
/// </summary>
/// <param name="JobID">ID of the job being executed</param>
/// <param name="StepID">ID of the step being executed</param>
/// <param name="argv">Array of arguments passed into the step's execution</param>
/// <param name="ipFeedback">Feedback object to return status messages and files</param>
/// <returns>Return code of execution for workflow path traversal</returns>
public int Execute(int JobID, int stepID, ref object[] argv, ref IJTXCustomStepFeedback ipFeedback)
{
System.Diagnostics.Debug.Assert(m_ipDatabase != null);
if (!ConfigurationCache.IsInitialized)
{
ConfigurationCache.InitializeCache(m_ipDatabase);
}
IJTXJobManager jobMan = m_ipDatabase.JobManager;
IJTXJob2 m_ParentJob = (IJTXJob2)jobMan.GetJob(JobID);
if (!GetInputParams(argv))
{
return(0);
}
return(CreateJobs(m_ParentJob));
}
////////////////////////////////////////////////////////////////////////
// METHOD: SetJobProperties
private IJTXJob SetJobProperties(IJTXJobManager pJobMan, IJTXJob pJob, IJTXJob2 pParentJob)
{
m_ipDatabase.LogMessage(5, 2000, "Before LogJobAction (CreateJobs)");
IJTXActivityType pActType = m_ipDatabase.ConfigurationManager.GetActivityType(Constants.ACTTYPE_COMMENT);
pParentJob.LogJobAction(pActType, null,
String.Format(Properties.Resources.ActTypeMessage, pJob.ID.ToString()));
if (!string.IsNullOrEmpty(m_paramExtendedProperties))
{
m_ipDatabase.LogMessage(5, 2000, "Before Create Extended Properties");
ExtendedPropertyIdentifier childExProps = new ExtendedPropertyIdentifier();
try
{
ParseExtendedPropertiesParam(out childExProps);
}
catch (Exception ex)
{
string msg = string.Format(
"Unable to read parent job's extended property. Job ID: {0} ERROR: {1}",
pParentJob.ID, ex.Message);
m_ipDatabase.LogMessage(3, 1000, msg);
}
try
{
CreateExtendedPropertyRecord(pJob, childExProps);
}
catch (Exception ex)
{
string msg = string.Format(
"Unable to set child job's extended property. Child Job ID: {0} ERROR: {1}",
pJob.ID, ex.Message);
m_ipDatabase.LogMessage(3, 1000, msg);
}
m_ipDatabase.LogMessage(5, 2000, "After Create Extended Properties");
}
// Create dependencies on parent job if configured
m_ipDatabase.LogMessage(5, 2000, "Before Setting Dependencies");
if (m_paramDependNextStep || m_paramDependThisStep)
{
IJTXJobDependencies ipDependencyManager = pJobMan as IJTXJobDependencies;
CreateDependencyOnParentJob(ipDependencyManager, pParentJob, pJob.ID);
}
m_ipDatabase.LogMessage(5, 2000, "After Setting Dependencies");
// Create or assign version if configured
m_ipDatabase.LogMessage(5, 2000, "Before Versioning");
if (m_paramCreateVersionType != CreateVersionType.None)
{
if (pParentJob.ActiveDatabase != null && !String.IsNullOrEmpty(pJob.ParentVersion) &&
(m_paramCreateVersionType != CreateVersionType.UseParentJobsVersion || pParentJob.VersionExists()))
CreateChildVersion(ref pJob);
else
MessageBox.Show("Could not create version. Please ensure parent data workspace and versions are set correctly", Properties.Resources.Warning, MessageBoxButtons.OK, MessageBoxIcon.Warning);
}
else if (m_paramAssignVersionType != AssignVersionType.None)
{
if (pParentJob.ActiveDatabase != null)
AssignChildVersion(pParentJob, ref pJob);
else
MessageBox.Show("Could not assign version. Please ensure parent data workspace is set correctly", Properties.Resources.Warning, MessageBoxButtons.OK, MessageBoxIcon.Warning);
}
m_ipDatabase.LogMessage(5, 2000, "After Versioning");
// Store the job and save the changes
m_ipDatabase.LogMessage(5, 2000, "Before Storing Job");
pJob.Store();
m_ipDatabase.LogMessage(5, 2000, "After Storing Job");
return pJob;
}
////////////////////////////////////////////////////////////////////////
// METHOD: PopulateAOIListUsingParent
private bool PopulateAOIListUsingParent(IJTXJob2 pParentJob, ref IArray aoiList, int numCopies)
{
try
{
aoiList = new ArrayClass();
for (int i = 0; i < numCopies; i++)
{
aoiList.Add(pParentJob.AOIExtent);
}
}
catch (Exception ex)
{
throw new Exception("Unable to create AOIs based on parent job's AOI: " + ex.Message);
}
return true;
}
////////////////////////////////////////////////////////////////////////
// METHOD: PopulateAOIListUsingOverlapFeatureClass
private bool PopulateAOIListUsingOverlapFeatureClass(IJTXJob2 pParentJob, ref IArray aoiList)
{
try
{
// Make sure all the information exists to get the data workspace
if (pParentJob.ActiveDatabase == null)
{
MessageBox.Show("Unable to proceed: Please set the data workspace for this job.");
return false;
}
if (pParentJob.AOIExtent == null)
{
MessageBox.Show("Unable to proceed: Please assign the AOI for this job.");
return false;
}
// Get the feature workspace from the current data workspace
IJTXDatabase2 pJTXDB = (IJTXDatabase2)m_ipDatabase;
string activeDBID = pParentJob.ActiveDatabase.DatabaseID;
IFeatureWorkspace featureWorkspace = (IFeatureWorkspace)pJTXDB.GetDataWorkspace(activeDBID, pParentJob.VersionExists() ? pParentJob.VersionName : "");
if (featureWorkspace == null)
{
MessageBox.Show("Unable to connect to Data Workspace");
return false;
}
IFeatureClass featureClass = null;
try
{
featureClass = featureWorkspace.OpenFeatureClass(m_AOIOverlapFeatureClassName);
}
catch (Exception ex)
{
MessageBox.Show("Unable to connect to feature class to generate AOIs: " +
m_AOIOverlapFeatureClassName + "\n Error: " + ex.ToString());
return false;
}
// Get all features that intersect the parent job's AOI
//
// Note: The parent job's AOI is shrunk very slightly so features that merely adjoin the parent's AOI
// are *not* returned. Only features that have some part of their actual area intersecting the parent's
// AOI are returned.
ISpatialFilter spatialFilter = new SpatialFilterClass();
ITopologicalOperator topOp = (ITopologicalOperator)pParentJob.AOIExtent;
IPolygon slightlySmallerExtent = (IPolygon)topOp.Buffer(-0.0001);
spatialFilter.Geometry = slightlySmallerExtent;
spatialFilter.GeometryField = featureClass.ShapeFieldName;
spatialFilter.SpatialRel = esriSpatialRelEnum.esriSpatialRelIntersects;
IFeatureCursor featureCursor = featureClass.Search(spatialFilter, false);
aoiList = new ArrayClass();
IFeature feature = null;
while ((feature = featureCursor.NextFeature()) != null)
{
aoiList.Add(feature.Shape);
}
// Explicitly release the cursor.
Marshal.ReleaseComObject(featureCursor);
}
catch (Exception ex)
{
throw new Exception("Unable to create AOIs based on feature class: " + m_AOIOverlapFeatureClassName + ". " + ex.ToString());
}
return true;
}
////////////////////////////////////////////////////////////////////////
// METHOD: GetNumberOfJobs
private bool GetNumberOfJobs(IJTXJob2 pParentJob, ref IArray aoiList, out int numJobs)
{
bool AOIFromOverlap = false;
bool AOIFromParent = false;
numJobs = -1;
// Then use defaults
AOIFromOverlap = !string.IsNullOrEmpty(m_AOIOverlapFeatureClassName);
AOIFromParent = m_paramUseParentAOI;
numJobs = m_paramNumberChildJobs;
if (AOIFromOverlap)
{
if (!PopulateAOIListUsingOverlapFeatureClass(pParentJob, ref aoiList))
{
return false;
}
numJobs = aoiList.Count;
}
else if (AOIFromParent)
{
if (!PopulateAOIListUsingParent(pParentJob, ref aoiList, numJobs))
{
return false;
}
}
return true;
}
////////////////////////////////////////////////////////////////////////
// METHOD: CreateJobs
private int CreateJobs(IJTXJob2 pParentJob)
{
try
{
System.Windows.Forms.Cursor.Current = System.Windows.Forms.Cursors.WaitCursor;
bool bAutoCommit = ConfigurationCache.AutoCommitWorkflow;
m_ipDatabase.LogMessage(5, 2000, "CreateJobs");
// Set the job template values
IJTXJobManager2 pJobMan = m_ipDatabase.JobManager as IJTXJobManager2;
IJTXJobDescription pJobDescription = new JTXJobDescriptionClass();
pJobDescription.Description = pParentJob.Description;
pJobDescription.Priority = pParentJob.Priority;
pJobDescription.ParentJobId = pParentJob.ID;
pJobDescription.StartDate = pParentJob.StartDate;
if (m_dueDate != Constants.NullDate)
pJobDescription.DueDate = m_dueDate;
else if (m_duration > 0)
pJobDescription.DueDate = System.DateTime.Now.AddDays(m_duration);
else
pJobDescription.DueDate = pParentJob.DueDate;
if (!String.IsNullOrEmpty(m_paramAssignToGroup))
{
pJobDescription.AssignedType = jtxAssignmentType.jtxAssignmentTypeGroup;
pJobDescription.AssignedTo = m_paramAssignToGroup;
}
else if (!String.IsNullOrEmpty(m_paramAssignToUser))
{
pJobDescription.AssignedType = jtxAssignmentType.jtxAssignmentTypeUser;
pJobDescription.AssignedTo = m_paramAssignToUser;
}
else
{
pJobDescription.AssignedType = jtxAssignmentType.jtxAssignmentTypeUnassigned;
}
pJobDescription.OwnedBy = ConfigurationCache.GetCurrentJTXUser().UserName;
if (pParentJob.ActiveDatabase != null)
pJobDescription.DataWorkspaceID = pParentJob.ActiveDatabase.DatabaseID;
// Set the parent version. This only makes sense if the active workspace has been set
if (pJobDescription.DataWorkspaceID != null)
{
if (m_paramCreateVersionType == CreateVersionType.None
|| m_paramCreateVersionType == CreateVersionType.UseParentJobsVersion)
pJobDescription.ParentVersionName = pParentJob.VersionName; // This has to be set here because setting the job workspace resets the value
else if (m_paramCreateVersionType == CreateVersionType.UseJobTypeDefaultSettings)
{
IJTXJobType pJobType = m_ipDatabase.ConfigurationManager.GetJobType(m_paramJobTypeName);
if (pJobType != null)
pJobDescription.ParentVersionName = pJobType.DefaultParentVersionName;
}
else if (m_paramCreateVersionType == CreateVersionType.UseParentJobsDefaultVersion)
pJobDescription.ParentVersionName = pParentJob.JobType.DefaultParentVersionName;
else if (m_paramCreateVersionType == CreateVersionType.UseParentJobsParentVersion)
pJobDescription.ParentVersionName = pParentJob.ParentVersion;
}
// Determine the number of jobs to make
m_ipDatabase.LogMessage(5, 2000, "Before Determining Number of Jobs");
IArray aoiList = null;
int numJobs;
if (!GetNumberOfJobs(pParentJob, ref aoiList, out numJobs))
return 1;
if (numJobs <= 0)
{
MessageBox.Show(Properties.Resources.ZeroJobCount);
return 0;
}
pJobDescription.AOIList = aoiList;
m_ipDatabase.LogMessage(5, 2000, "After Determining Number of Jobs");
// Create the job objects
m_ipDatabase.LogMessage(5, 2000, "Before CreateJobs");
pJobDescription.JobTypeName = m_paramJobTypeName;
IJTXExecuteInfo pExecInfo;
m_ipJobs = pJobMan.CreateJobsFromDescription(pJobDescription, numJobs, true, out pExecInfo);
m_ipDatabase.LogMessage(5, 2000, "After CreateJobs");
// Populate the job data
for (int i = 0; i < m_ipJobs.Count; ++i)
{
IJTXJob pJob = m_ipJobs.get_Item(i);
SetJobProperties(pJobMan, pJob, pParentJob);
}
return 1;
}
catch (COMException ex)
{
if (ex.ErrorCode == (int)fdoError.FDO_E_SE_INVALID_COLUMN_VALUE)
{
MessageBox.Show(Properties.Resources.InvalidColumn, Properties.Resources.Error, MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
}
else
{
MessageBox.Show(ex.Message);
}
return 0;
}
catch (Exception ex2)
{
MessageBox.Show(ex2.Message, Properties.Resources.Error, MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
return 0;
}
finally
{
System.Windows.Forms.Cursor.Current = System.Windows.Forms.Cursors.Default;
}
}
/// <summary>
/// Called when a step of this type is executed in the workflow.
/// </summary>
/// <param name="JobID">ID of the job being executed</param>
/// <param name="StepID">ID of the step being executed</param>
/// <param name="argv">Array of arguments passed into the step's execution</param>
/// <param name="ipFeedback">Feedback object to return status messages and files</param>
/// <returns>Return code of execution for workflow path traversal</returns>
public int Execute(int jobID, int stepID, ref object[] argv, ref IJTXCustomStepFeedback ipFeedback)
{
if (jobID <= 0)
{
throw (new ArgumentOutOfRangeException("JobID", jobID, "Job ID must be a positive value"));
}
System.Diagnostics.Debug.Assert(m_ipDatabase != null);
IJTXJobManager pJobMan = m_ipDatabase.JobManager;
IJTXJob2 pJob = pJobMan.GetJob(jobID) as IJTXJob2;
// Make sure all the information exists to create this verion
if (pJob.ActiveDatabase == null)
{
System.Windows.Forms.MessageBox.Show("Job does not have a data workspace");
return(-1);
}
if (pJob.ParentVersion == "")
{
System.Windows.Forms.MessageBox.Show("Job does not have a parent version");
return(-1);
}
string strVersionNameOverride;
bool bVNOverride = StepUtilities.GetArgument(ref argv, m_expectedArgs[1], true, out strVersionNameOverride);
if (pJob.VersionName == "" & !bVNOverride)
{
System.Windows.Forms.MessageBox.Show("The job does not have a version name");
return(-1);
}
IVersion pNewVersion;
string strVersionName;
if (bVNOverride)
{
strVersionName = strVersionNameOverride;
}
else
{
strVersionName = pJob.VersionName;
}
int index = strVersionName.IndexOf(".", 0);
if (index >= 0)
{
strVersionName = strVersionName.Substring(index + 1);
}
esriVersionAccess verAccess = esriVersionAccess.esriVersionAccessPrivate;
string strVerScope = "";
if (StepUtilities.GetArgument(ref argv, m_expectedArgs[0], true, out strVerScope))
{
strVerScope = strVerScope.ToLower().Trim();
if (strVerScope == "public")
{
verAccess = esriVersionAccess.esriVersionAccessPublic;
}
else if (strVerScope == "protected")
{
verAccess = esriVersionAccess.esriVersionAccessProtected;
}
}
pJob.VersionName = strVersionName;
pNewVersion = pJob.CreateVersion(verAccess);
if (pNewVersion == null)
{
throw (new System.SystemException("Unable to create version"));
}
IPropertySet pOverrides = new PropertySetClass();
pOverrides.SetProperty("[VERSION]", pNewVersion.VersionName);
IJTXActivityType pActType = m_ipDatabase.ConfigurationManager.GetActivityType(Constants.ACTTYPE_CREATE_VERSION);
if (pActType != null)
{
pJob.LogJobAction(pActType, pOverrides, "");
}
JTXUtilities.SendNotification(Constants.NOTIF_VERSION_CREATED, m_ipDatabase, pJob, pOverrides);
System.Runtime.InteropServices.Marshal.ReleaseComObject(pNewVersion);
return(0);
}
private int addAttachments(int jobID, int stepID, ref object[] argv, ref IJTXCustomStepFeedback ipFeedback)
{
// Get a handle to the job
IJTXJobManager pJobManager = m_ipDatabase.JobManager;
IJTXJob2 pJob = pJobManager.GetJob(jobID) as IJTXJob2;
IJTXJob2 pParentJob = pJobManager.GetJob(pJob.ParentJob) as IJTXJob2;
// Prompt the user to choose whether the attachment should be embedded
// into the database or merely stored as a URL, UNC path, etc.
AttachmentTypeDialog atd = new AttachmentTypeDialog();
// Check to see if this job has a parent. If so, enable the "attach to parent" dialog.
if (pParentJob == null)
{
atd.EnableSelectParent = false;
}
else
{
atd.EnableSelectParent = true;
}
atd.ShowDialog();
if (atd.isNoneSelected())
{
return(0);
}
// Set the file storage type, according to what the user selected.
bool embedAttachment = atd.isEmbeddedSelected();
jtxFileStorageType fileStorageType;
if (embedAttachment)
{
fileStorageType = jtxFileStorageType.jtxStoreInDB;
}
else
{
fileStorageType = jtxFileStorageType.jtxStoreAsLink;
}
// Prompt the user to select the file(s) to be attached.
System.Windows.Forms.OpenFileDialog ofd = new System.Windows.Forms.OpenFileDialog();
ofd.CheckFileExists = true;
ofd.Multiselect = false;
ofd.ShowDialog();
// Add each file that the user selected.
foreach (string filename in ofd.FileNames)
{
if (atd.AttachToCurrent)
{
pJob.AddAttachment(filename, fileStorageType, "");
}
if (atd.AttachToParent)
{
pParentJob.AddAttachment(filename, fileStorageType, "");
}
}
return(1);
}
////////////////////////////////////////////////////////////////////////
// METHOD: CreateDependencyOnParentJob
private void CreateDependencyOnParentJob(IJTXJobDependencies dependencyManager, IJTXJob2 pParentJob, int childJobID)
{
IJTXJobDependency dependency = dependencyManager.CreateDependency(pParentJob.ID);
dependency.DepJobID = childJobID;
dependency.DepOnType = jtxDependencyType.jtxDependencyTypeStatus;
IJTXStatus statusType = null;
if (!m_paramHasStatusType)
{
statusType = m_ipDatabase.ConfigurationManager.GetStatus("Closed");
}
else
{
statusType = m_ipDatabase.ConfigurationManager.GetStatus(m_paramStatusType);
}
dependency.DepOnValue = statusType.ID;
dependency.HeldOnType = jtxDependencyType.jtxDependencyTypeStep;
IJTXWorkflowExecution parentWorkflow = pParentJob as IJTXWorkflowExecution;
int[] currentSteps = parentWorkflow.GetCurrentSteps();
int dependentStep = currentSteps[0];
if (m_paramDependNextStep)
{
IJTXWorkflowConfiguration workflowConf = pParentJob as IJTXWorkflowConfiguration;
try
{
dependentStep = workflowConf.GetAllNextSteps(currentSteps[0])[0];
}
catch (IndexOutOfRangeException)
{
MessageBox.Show(Properties.Resources.NoNextStep, Properties.Resources.Error,
MessageBoxButtons.OK, MessageBoxIcon.Warning);
return;
}
}
dependency.HeldOnValue = dependentStep;
dependency.Store();
IPropertySet props = new PropertySetClass();
props.SetProperty("[DEPENDENCY]", dependency.ID);
JobUtilities.LogJobAction(m_ipDatabase, pParentJob, Constants.ACTTYPE_ADD_DEPENDENCY, "", props);
}
////////////////////////////////////////////////////////////////////////
// METHOD: SetJobProperties
private IJTXJob SetJobProperties(IJTXJobManager pJobMan, IJTXJob pJob, IJTXJob2 pParentJob)
{
m_ipDatabase.LogMessage(5, 2000, "Before LogJobAction (CreateJobs)");
IJTXActivityType pActType = m_ipDatabase.ConfigurationManager.GetActivityType(Constants.ACTTYPE_COMMENT);
pParentJob.LogJobAction(pActType, null,
String.Format(Properties.Resources.ActTypeMessage, pJob.ID.ToString()));
if (!string.IsNullOrEmpty(m_paramExtendedProperties))
{
m_ipDatabase.LogMessage(5, 2000, "Before Create Extended Properties");
ExtendedPropertyIdentifier childExProps = new ExtendedPropertyIdentifier();
try
{
ParseExtendedPropertiesParam(out childExProps);
}
catch (Exception ex)
{
string msg = string.Format(
"Unable to read parent job's extended property. Job ID: {0} ERROR: {1}",
pParentJob.ID, ex.Message);
m_ipDatabase.LogMessage(3, 1000, msg);
}
try
{
CreateExtendedPropertyRecord(pJob, childExProps);
}
catch (Exception ex)
{
string msg = string.Format(
"Unable to set child job's extended property. Child Job ID: {0} ERROR: {1}",
pJob.ID, ex.Message);
m_ipDatabase.LogMessage(3, 1000, msg);
}
m_ipDatabase.LogMessage(5, 2000, "After Create Extended Properties");
}
// Create dependencies on parent job if configured
m_ipDatabase.LogMessage(5, 2000, "Before Setting Dependencies");
if (m_paramDependNextStep || m_paramDependThisStep)
{
IJTXJobDependencies ipDependencyManager = pJobMan as IJTXJobDependencies;
CreateDependencyOnParentJob(ipDependencyManager, pParentJob, pJob.ID);
}
m_ipDatabase.LogMessage(5, 2000, "After Setting Dependencies");
// Create or assign version if configured
m_ipDatabase.LogMessage(5, 2000, "Before Versioning");
if (m_paramCreateVersionType != CreateVersionType.None)
{
if (pParentJob.ActiveDatabase != null && !String.IsNullOrEmpty(pJob.ParentVersion) &&
(m_paramCreateVersionType != CreateVersionType.UseParentJobsVersion || pParentJob.VersionExists()))
{
CreateChildVersion(ref pJob);
}
else
{
MessageBox.Show("Could not create version. Please ensure parent data workspace and versions are set correctly", Properties.Resources.Warning, MessageBoxButtons.OK, MessageBoxIcon.Warning);
}
}
else if (m_paramAssignVersionType != AssignVersionType.None)
{
if (pParentJob.ActiveDatabase != null)
{
AssignChildVersion(pParentJob, ref pJob);
}
else
{
MessageBox.Show("Could not assign version. Please ensure parent data workspace is set correctly", Properties.Resources.Warning, MessageBoxButtons.OK, MessageBoxIcon.Warning);
}
}
m_ipDatabase.LogMessage(5, 2000, "After Versioning");
// Store the job and save the changes
m_ipDatabase.LogMessage(5, 2000, "Before Storing Job");
pJob.Store();
m_ipDatabase.LogMessage(5, 2000, "After Storing Job");
return(pJob);
}
////////////////////////////////////////////////////////////////////////
// METHOD: PopulateAOIListUsingOverlapFeatureClass
private bool PopulateAOIListUsingOverlapFeatureClass(IJTXJob2 pParentJob, ref IArray aoiList)
{
try
{
// Make sure all the information exists to get the data workspace
if (pParentJob.ActiveDatabase == null)
{
MessageBox.Show("Unable to proceed: Please set the data workspace for this job.");
return(false);
}
if (pParentJob.AOIExtent == null)
{
MessageBox.Show("Unable to proceed: Please assign the AOI for this job.");
return(false);
}
// Get the feature workspace from the current data workspace
IJTXDatabase2 pJTXDB = (IJTXDatabase2)m_ipDatabase;
string activeDBID = pParentJob.ActiveDatabase.DatabaseID;
IFeatureWorkspace featureWorkspace = (IFeatureWorkspace)pJTXDB.GetDataWorkspace(activeDBID, pParentJob.VersionExists() ? pParentJob.VersionName : "");
if (featureWorkspace == null)
{
MessageBox.Show("Unable to connect to Data Workspace");
return(false);
}
IFeatureClass featureClass = null;
try
{
featureClass = featureWorkspace.OpenFeatureClass(m_AOIOverlapFeatureClassName);
}
catch (Exception ex)
{
MessageBox.Show("Unable to connect to feature class to generate AOIs: " +
m_AOIOverlapFeatureClassName + "\n Error: " + ex.ToString());
return(false);
}
// Get all features that intersect the parent job's AOI
//
// Note: The parent job's AOI is shrunk very slightly so features that merely adjoin the parent's AOI
// are *not* returned. Only features that have some part of their actual area intersecting the parent's
// AOI are returned.
ISpatialFilter spatialFilter = new SpatialFilterClass();
ITopologicalOperator topOp = (ITopologicalOperator)pParentJob.AOIExtent;
IPolygon slightlySmallerExtent = (IPolygon)topOp.Buffer(-0.0001);
spatialFilter.Geometry = slightlySmallerExtent;
spatialFilter.GeometryField = featureClass.ShapeFieldName;
spatialFilter.SpatialRel = esriSpatialRelEnum.esriSpatialRelIntersects;
IFeatureCursor featureCursor = featureClass.Search(spatialFilter, false);
aoiList = new ArrayClass();
IFeature feature = null;
while ((feature = featureCursor.NextFeature()) != null)
{
aoiList.Add(feature.Shape);
}
// Explicitly release the cursor.
Marshal.ReleaseComObject(featureCursor);
}
catch (Exception ex)
{
throw new Exception("Unable to create AOIs based on feature class: " + m_AOIOverlapFeatureClassName + ". " + ex.ToString());
}
return(true);
}
////////////////////////////////////////////////////////////////////////
// METHOD: CreateDependencyOnParentJob
private void CreateDependencyOnParentJob(IJTXJobDependencies dependencyManager, IJTXJob2 pParentJob, int childJobID)
{
IJTXJobDependency dependency = dependencyManager.CreateDependency(pParentJob.ID);
dependency.DepJobID = childJobID;
dependency.DepOnType = jtxDependencyType.jtxDependencyTypeStatus;
IJTXStatus statusType = null;
if (!m_paramHasStatusType) statusType = m_ipDatabase.ConfigurationManager.GetStatus("Closed");
else statusType = m_ipDatabase.ConfigurationManager.GetStatus(m_paramStatusType);
dependency.DepOnValue = statusType.ID;
dependency.HeldOnType = jtxDependencyType.jtxDependencyTypeStep;
IJTXWorkflowExecution parentWorkflow = pParentJob as IJTXWorkflowExecution;
int[] currentSteps = parentWorkflow.GetCurrentSteps();
int dependentStep = currentSteps[0];
if (m_paramDependNextStep)
{
IJTXWorkflowConfiguration workflowConf = pParentJob as IJTXWorkflowConfiguration;
try
{
dependentStep = workflowConf.GetAllNextSteps(currentSteps[0])[0];
}
catch (IndexOutOfRangeException)
{
MessageBox.Show(Properties.Resources.NoNextStep, Properties.Resources.Error,
MessageBoxButtons.OK, MessageBoxIcon.Warning);
return;
}
}
dependency.HeldOnValue = dependentStep;
dependency.Store();
IPropertySet props = new PropertySetClass();
props.SetProperty("[DEPENDENCY]", dependency.ID);
JobUtilities.LogJobAction(m_ipDatabase, pParentJob, Constants.ACTTYPE_ADD_DEPENDENCY, "", props);
}
////////////////////////////////////////////////////////////////////////
// METHOD: AssignChildVersion
private bool AssignChildVersion(IJTXJob2 pParentJob, ref IJTXJob pJob)
{
if (m_paramAssignVersionType == AssignVersionType.UseParentJobsVersion)
{
((IJTXJob2)pJob).SetActiveDatabase(pParentJob.ActiveDatabase.DatabaseID);
pJob.ParentVersion = pParentJob.ParentVersion;
pJob.VersionName = pParentJob.VersionName;
}
return true;
}
////////////////////////////////////////////////////////////////////////
// METHOD: CreateJobs
private int CreateJobs(IJTXJob2 pParentJob)
{
try
{
System.Windows.Forms.Cursor.Current = System.Windows.Forms.Cursors.WaitCursor;
bool bAutoCommit = ConfigurationCache.AutoCommitWorkflow;
m_ipDatabase.LogMessage(5, 2000, "CreateJobs");
// Set the job template values
IJTXJobManager2 pJobMan = m_ipDatabase.JobManager as IJTXJobManager2;
IJTXJobDescription pJobDescription = new JTXJobDescriptionClass();
pJobDescription.Description = pParentJob.Description;
pJobDescription.Priority = pParentJob.Priority;
pJobDescription.ParentJobId = pParentJob.ID;
pJobDescription.StartDate = pParentJob.StartDate;
if (m_dueDate != Constants.NullDate)
{
pJobDescription.DueDate = m_dueDate;
}
else if (m_duration > 0)
{
pJobDescription.DueDate = System.DateTime.Now.AddDays(m_duration);
}
else
{
pJobDescription.DueDate = pParentJob.DueDate;
}
if (!String.IsNullOrEmpty(m_paramAssignToGroup))
{
pJobDescription.AssignedType = jtxAssignmentType.jtxAssignmentTypeGroup;
pJobDescription.AssignedTo = m_paramAssignToGroup;
}
else if (!String.IsNullOrEmpty(m_paramAssignToUser))
{
pJobDescription.AssignedType = jtxAssignmentType.jtxAssignmentTypeUser;
pJobDescription.AssignedTo = m_paramAssignToUser;
}
else
{
pJobDescription.AssignedType = jtxAssignmentType.jtxAssignmentTypeUnassigned;
}
pJobDescription.OwnedBy = ConfigurationCache.GetCurrentJTXUser().UserName;
if (pParentJob.ActiveDatabase != null)
{
pJobDescription.DataWorkspaceID = pParentJob.ActiveDatabase.DatabaseID;
}
// Set the parent version. This only makes sense if the active workspace has been set
if (pJobDescription.DataWorkspaceID != null)
{
if (m_paramCreateVersionType == CreateVersionType.None ||
m_paramCreateVersionType == CreateVersionType.UseParentJobsVersion)
{
pJobDescription.ParentVersionName = pParentJob.VersionName; // This has to be set here because setting the job workspace resets the value
}
else if (m_paramCreateVersionType == CreateVersionType.UseJobTypeDefaultSettings)
{
IJTXJobType pJobType = m_ipDatabase.ConfigurationManager.GetJobType(m_paramJobTypeName);
if (pJobType != null)
{
pJobDescription.ParentVersionName = pJobType.DefaultParentVersionName;
}
}
else if (m_paramCreateVersionType == CreateVersionType.UseParentJobsDefaultVersion)
{
pJobDescription.ParentVersionName = pParentJob.JobType.DefaultParentVersionName;
}
else if (m_paramCreateVersionType == CreateVersionType.UseParentJobsParentVersion)
{
pJobDescription.ParentVersionName = pParentJob.ParentVersion;
}
}
// Determine the number of jobs to make
m_ipDatabase.LogMessage(5, 2000, "Before Determining Number of Jobs");
IArray aoiList = null;
int numJobs;
if (!GetNumberOfJobs(pParentJob, ref aoiList, out numJobs))
{
return(1);
}
if (numJobs <= 0)
{
MessageBox.Show(Properties.Resources.ZeroJobCount);
return(0);
}
pJobDescription.AOIList = aoiList;
m_ipDatabase.LogMessage(5, 2000, "After Determining Number of Jobs");
// Create the job objects
m_ipDatabase.LogMessage(5, 2000, "Before CreateJobs");
pJobDescription.JobTypeName = m_paramJobTypeName;
IJTXExecuteInfo pExecInfo;
m_ipJobs = pJobMan.CreateJobsFromDescription(pJobDescription, numJobs, true, out pExecInfo);
m_ipDatabase.LogMessage(5, 2000, "After CreateJobs");
// Populate the job data
for (int i = 0; i < m_ipJobs.Count; ++i)
{
IJTXJob pJob = m_ipJobs.get_Item(i);
SetJobProperties(pJobMan, pJob, pParentJob);
}
return(1);
}
catch (COMException ex)
{
if (ex.ErrorCode == (int)fdoError.FDO_E_SE_INVALID_COLUMN_VALUE)
{
MessageBox.Show(Properties.Resources.InvalidColumn, Properties.Resources.Error, MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
}
else
{
MessageBox.Show(ex.Message);
}
return(0);
}
catch (Exception ex2)
{
MessageBox.Show(ex2.Message, Properties.Resources.Error, MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
return(0);
}
finally
{
System.Windows.Forms.Cursor.Current = System.Windows.Forms.Cursors.Default;
}
}
