/// <summary>
/// Builds a domain consisting of the IDs of every job in the database that
/// has not already been closed.
/// </summary>
/// <param name="wmxDb">A reference to the active Workflow Manager database</param>
/// <returns>A coded value domain as an IGPDomain</returns>
public static IGPDomain BuildNonClosedJobIdDomain(IJTXDatabase3 wmxDb)
{
IGPCodedValueDomain domain = new GPCodedValueDomainClass();
// Set up a query filter to return only those jobs that are not closed
IQueryFilter queryFilter = new QueryFilterClass();
queryFilter.WhereClause =
ESRI.ArcGIS.JTX.Utilities.Constants.FIELD_STAGE + " <> '" +
((int)jtxJobStage.jtxJobStageClosed).ToString() + "'";
IJTXJobSet nonClosedJobs = wmxDb.JobManager.GetJobsByQuery(queryFilter);
// Iterate through this job list, sorting the IDs
SortedList <int, string> sortedJobIds = new SortedList <int, string>();
for (int i = 0; i < nonClosedJobs.Count; i++)
{
IJTXJob3 job = nonClosedJobs.get_Item(i) as IJTXJob3;
sortedJobIds[job.ID] = null;
}
// Build a GP domain from the sorted job IDs.
foreach (int id in sortedJobIds.Keys)
{
IGPValue tempGpVal = new GPLongClass();
tempGpVal.SetAsText(id.ToString());
domain.AddCode(tempGpVal, id.ToString());
}
return(domain as IGPDomain);
}
/// <summary>
/// Builds a domain of the priority strings in the system
/// </summary>
/// <param name="wmxDb">A reference to the active Workflow Manager database</param>
/// <returns>A coded value domain as an IGPDomain</returns>
public static IGPDomain BuildPriorityDomain(IJTXDatabase3 wmxDb)
{
IGPCodedValueDomain domain = new GPCodedValueDomainClass();
// Sort the types first
IJTXPrioritySet allValues = wmxDb.ConfigurationManager.Priorities;
SortedList <int, string> sortedValues = new SortedList <int, string>();
for (int i = 0; i < allValues.Count; i++)
{
IJTXPriority temp = allValues.get_Item(i);
sortedValues.Add(temp.Value, temp.Name);
}
// Since the highest priority elements are those with the largest number,
// reverse the order of the list so that these priorities show up first
IEnumerable <string> valueList = sortedValues.Values.Reverse();
// Add the sorted types to the domain
foreach (string value in valueList)
{
IGPValue tempGpVal = new GPStringClass();
tempGpVal.SetAsText(value);
domain.AddCode(tempGpVal, value);
}
return(domain as IGPDomain);
}
/// <summary>
/// Helper function to set up a GP tool parameter so that the workflow manager
/// database can be chosen.
/// </summary>
/// <returns>A parameter for selecting the target WMX DB</returns>
protected IGPParameter3 BuildWmxDbParameter()
{
IGPParameterEdit paramEdit = null;
IGPCodedValueDomain cvDomain = new GPCodedValueDomainClass();
// When we first build out the parameter list, ensure that we indicate
// what the current Workflow Manager database is
m_wmxDbAlias = string.Empty;
IsWorkflowManagerDatabaseSet();
// Parameter allowing specification of the Workflow Manager database
IGPString strVal = new GPStringClass();
strVal.Value = m_wmxDbAlias;
paramEdit = BuildParameter(
esriGPParameterDirection.esriGPParameterDirectionInput,
esriGPParameterType.esriGPParameterTypeOptional,
Properties.Resources.DESC_COM_WMX_DATABASE,
C_PARAM_WMX_DATABASE_ALIAS,
(strVal as IGPValue).DataType,
strVal as IGPValue);
IJTXDatabaseConnectionManager connMgr = new JTXDatabaseConnectionManagerClass();
foreach (string alias in connMgr.DatabaseNames)
{
cvDomain.AddStringCode(alias, alias);
}
paramEdit.Domain = cvDomain as IGPDomain;
return(paramEdit as IGPParameter3);
}
/// <summary>
/// Builds a domain consisting of the Workflow Manager privileges
/// </summary>
/// <returns>A coded value domain of strings</returns>
private IGPDomain BuildPrivilegesDomain()
{
IGPCodedValueDomain domain = new GPCodedValueDomainClass();
// Sort the types first
SortedList <string, string> sortedValues = new SortedList <string, string>();
IJTXPrivilegeSet privileges = this.WmxDatabase.ConfigurationManager.Privileges;
for (int i = 0; i < privileges.Count; i++)
{
IJTXPrivilege2 priv = privileges.get_Item(i) as IJTXPrivilege2;
sortedValues.Add(priv.Name, null);
}
// Add the "all privileges" option to the list
sortedValues.Add(C_OPT_ALL_PRIVILEGES, null);
// Add the sorted types to the domain
foreach (string value in sortedValues.Keys)
{
IGPValue tempGpVal = new GPStringClass();
tempGpVal.SetAsText(value);
domain.AddCode(tempGpVal, value);
}
return(domain as IGPDomain);
}
/// <summary>
/// Builds a domain consisting of all the usernames in the system
/// </summary>
/// <param name="wmxDb">A reference to the active Workflow Manager database</param>
/// <param name="extraValues">An array of string values to be added to the list</param>
/// <returns>A coded value domain as an IGPDomain</returns>
public static IGPDomain BuildUsersDomain(IJTXDatabase3 wmxDb, string[] extraValues)
{
IGPCodedValueDomain domain = new GPCodedValueDomainClass();
// Sort the types first
IJTXUserSet allValues = wmxDb.ConfigurationManager.Users;
SortedList <string, string> sortedValues = new SortedList <string, string>();
for (int i = 0; i < allValues.Count; i++)
{
sortedValues.Add(allValues.get_Item(i).UserName, null);
}
// Add the extra values, if any
if (extraValues != null)
{
foreach (string s in extraValues)
{
sortedValues.Add(s, null);
}
}
// Add the sorted types to the domain
foreach (string value in sortedValues.Keys)
{
IGPValue tempGpVal = new GPStringClass();
tempGpVal.SetAsText(value);
domain.AddCode(tempGpVal, value);
}
return(domain as IGPDomain);
}
/// <summary>
/// Creates the a coded value domain an assigns it to the parameter.
/// </summary>
/// <param name="source">The source.</param>
/// <param name="name">
/// The name is the language-independent name for the parameter (not localized) and must not contain
/// spaces and must be unique within a function.
/// </param>
/// <param name="displayName">
/// The display name is the localized name (as it appears in the dialog) and is contained in
/// resource string.
/// </param>
/// <param name="parameterType">Type of the parameter.</param>
/// <param name="parameterDirection">The parameter direction.</param>
/// <param name="values">The values (strings) for the domain.</param>
/// <param name="names">The names (strings) for the domain.</param>
/// <param name="dataType">Type of the data.</param>
/// <returns>
/// Returns a <see cref="IGPParameterEdit3" /> representing the parameter.
/// </returns>
/// <exception cref="System.ArgumentNullException">
/// values
/// or
/// names
/// </exception>
/// <exception cref="System.ArgumentOutOfRangeException">
/// values;The values and names arrays must contain the same number of
/// elements.
/// </exception>
public static IGPParameterEdit3 CreateParameter(this IGPFunction source, string name, string displayName, esriGPParameterType parameterType, esriGPParameterDirection parameterDirection, object[] values, object[] names, IGPDataType dataType)
{
if (values == null)
{
throw new ArgumentNullException("values");
}
if (names == null)
{
throw new ArgumentNullException("names");
}
if (values.Length != names.Length)
{
throw new ArgumentOutOfRangeException("values", "The values and names arrays must contain the same number of elements.");
}
IGPCodedValueDomain codedValueDomain = new GPCodedValueDomainClass();
for (int i = 0; i < values.Length; i++)
{
codedValueDomain.AddStringCode(values[i].ToString(), names[i].ToString());
}
var parameter = source.CreateParameter(name, displayName, parameterType, parameterDirection, dataType);
parameter.Domain = codedValueDomain as IGPDomain;
return(parameter);
}
/// <summary>
/// Gets the coded value domain using fields from the specified <paramref name="table" />
/// </summary>
/// <param name="table">The table.</param>
/// <returns>
/// Returns a <see cref="IGPDomain" /> representing the coded value domain.
/// </returns>
protected IGPDomain GetFields(IObjectClass table)
{
IGPCodedValueDomain codedValueDomain = new GPCodedValueDomainClass();
foreach (var o in table.Fields.AsEnumerable())
{
codedValueDomain.AddStringCode(o.Name, o.Name);
}
return((IGPDomain)codedValueDomain);
}
/// <summary>
/// Gets the coded value domain.
/// </summary>
/// <param name="names">The names.</param>
/// <param name="values">The values.</param>
/// <returns>
/// Returns a <see cref="IGPDomain" /> representing the coded value domain.
/// </returns>
protected IGPDomain CreateDomain(string[] names, string[] values)
{
IGPCodedValueDomain codedValueDomain = new GPCodedValueDomainClass();
for (int i = 0; i < values.Length; i++)
{
codedValueDomain.AddStringCode(values[i], names[i]);
}
return((IGPDomain)codedValueDomain);
}
/// <summary>
/// Set up a coded value domain with the supported geometric operations for area
/// evaluators
/// </summary>
/// <returns></returns>
private IGPDomain BuildChangeConditionsDomain()
{
IGPCodedValueDomain domain = new GPCodedValueDomainClass();
foreach (string s in m_optChangeConditions.Keys)
{
domain.AddStringCode(s, s);
}
return(domain as IGPDomain);
}
/// <summary>
/// Gets the components from the registry that satisfy the predicate and selector.
/// </summary>
/// <typeparam name="TValue">The type of the value.</typeparam>
/// <param name="components">The components.</param>
/// <returns>
/// Returns a <see cref="IGPDomain" /> representing the coded value domain.
/// </returns>
protected IGPDomain CreateDomain <TValue>(IEnumerable <GPAutoValue <TValue> > components)
{
IGPCodedValueDomain codedValueDomain = new GPCodedValueDomainClass();
foreach (var o in components)
{
codedValueDomain.AddCode(o, o.Name);
}
return((IGPDomain)codedValueDomain);
}
/// <summary>
/// Set up a coded value domain with the supported geometric operations for area
/// evaluators
/// </summary>
/// <returns></returns>
private IGPDomain BuildGeometricOperationsDomain()
{
IGPCodedValueDomain geomOpDomain = new GPCodedValueDomainClass();
foreach (string s in m_geometricOperations.Keys)
{
geomOpDomain.AddStringCode(s, s);
}
return(geomOpDomain as IGPDomain);
}
/// <summary>
/// Creates the variant domain by instantiating the objects from the <see cref="IUID" /> an placing them into a
/// <see cref="IGPString" /> value for the domain.
/// </summary>
/// <typeparam name="TValue">The type of the value.</typeparam>
/// <param name="uids">The uids that will be created.</param>
/// <returns>
/// Returns a <see cref="IGPDomain" /> representing the coded value domain.
/// </returns>
protected IGPDomain CreateDomain <TValue>(IEnumerable <IUID> uids)
{
IGPCodedValueDomain codedValueDomain = new GPCodedValueDomainClass();
foreach (var uid in uids)
{
GPAutoValue <TValue> value = new GPAutoValue <TValue>(uid);
codedValueDomain.AddCode(value, value.Name);
}
return((IGPDomain)codedValueDomain);
}
/// <summary>
/// Gets the components from the registry that satisfy the predicate and selector.
/// </summary>
/// <typeparam name="TValue">The type of the value.</typeparam>
/// <param name="components">The components.</param>
/// <param name="predicate">The predicate.</param>
/// <returns>
/// Returns a <see cref="IGPDomain" /> representing the coded value domain.
/// </returns>
protected IGPDomain CreateDomain <TValue>(IEnumerable <GPAutoValue <TValue> > components, Func <TValue, bool> predicate)
{
IGPCodedValueDomain codedValueDomain = new GPCodedValueDomainClass();
foreach (var o in components)
{
if (o.Value != null && predicate(o.Value))
{
codedValueDomain.AddCode(o, o.Name);
}
}
return((IGPDomain)codedValueDomain);
}
/// <summary>
/// Builds a domain consisting of the IDs for every job in the database.
/// </summary>
/// <param name="wmxDb">A reference to the active Workflow Manager database</param>
/// <returns>A coded value domain as an IGPDomain</returns>
public static IGPDomain BuildJobIdDomain(IJTXDatabase3 wmxDb)
{
IGPCodedValueDomain domain = new GPCodedValueDomainClass();
int[] allJobs = wmxDb.JobManager.GetAllJobIDs();
System.Array.Sort(allJobs);
foreach (int job in allJobs)
{
IGPValue tempGpVal = new GPLongClass();
tempGpVal.SetAsText(job.ToString());
domain.AddCode(tempGpVal, job.ToString());
}
return(domain as IGPDomain);
}
/// <summary>
/// Builds a domain of the version names for a workspace
/// </summary>
/// <param name="wmxDb">A reference to the active Workflow Manager database</param>
/// <param name="workspaceName">The human-readable name of the workspace whose versions to look up</param>
/// <param name="extraValues">An array of string values to be added to the list</param>
/// <returns>A coded value domain of strings</returns>
public static IGPDomain BuildVersionsDomain(IJTXDatabase3 wmxDb, string workspaceName, string[] extraValues)
{
IGPCodedValueDomain domain = new GPCodedValueDomainClass();
try
{
// Get all of the public versions connected to this workspace
string workspaceId = Common.WmauHelperFunctions.LookupWorkspaceId(wmxDb, workspaceName);
IWorkspace workspace = wmxDb.GetDataWorkspace(workspaceId, null);
IVersionedWorkspace3 versionedWorkspace = workspace as IVersionedWorkspace3;
IEnumVersionInfo allValues = versionedWorkspace.Versions;
// Sort the types first
SortedList <string, string> sortedValues = new SortedList <string, string>();
IVersionInfo version;
while ((version = allValues.Next()) != null)
{
sortedValues.Add(version.VersionName, null);
}
// Add the extra values, if any
if (extraValues != null)
{
foreach (string s in extraValues)
{
sortedValues.Add(s, null);
}
}
// Add the sorted types to the domain
foreach (string value in sortedValues.Keys)
{
IGPValue tempGpVal = new GPStringClass();
tempGpVal.SetAsText(value);
domain.AddCode(tempGpVal, value);
}
}
catch (System.Runtime.InteropServices.COMException comEx)
{
// If we run into an exception, send word up the chain
throw new WmauException(WmauErrorCodes.C_VERSION_LOOKUP_ERROR, comEx);
}
return(domain as IGPDomain);
}
/// <summary>
/// Gets the coded value domain that contains all of the subtypes for the table.
/// </summary>
/// <param name="table">The table.</param>
/// <returns>
/// Returns a <see cref="IGPDomain" /> representing the coded value domain.
/// </returns>
protected IGPDomain GetSubtypes(IObjectClass table)
{
// Create a domain of all the subtypes.
IGPCodedValueDomain codedValueDomain = new GPCodedValueDomainClass();
codedValueDomain.AddStringCode("-1", "All");
ISubtypes subtypes = (ISubtypes)table;
if (subtypes.HasSubtype)
{
foreach (var o in subtypes.Subtypes.AsEnumerable())
{
codedValueDomain.AddStringCode(o.Key.ToString(CultureInfo.InvariantCulture), o.Value);
}
}
return(codedValueDomain as IGPDomain);
}
/// <summary>
/// Builds a domain consisting of the available job queries in the system.
/// </summary>
/// <param name="wmxDb">A reference to the active Workflow Manager database</param>
/// <returns>A coded value domain as an IGPDomain</returns>
public static IGPDomain BuildJobQueryDomain(IJTXDatabase3 wmxDb)
{
IGPCodedValueDomain domain = new GPCodedValueDomainClass();
IJTXConfiguration3 configMgr = wmxDb.ConfigurationManager as IJTXConfiguration3;
IJTXJobQueryContainer publicQueriesContainer = configMgr.GetPublicQueryContainer();
// Sort the queries first
SortedList <string, string> sortedValues = new SortedList <string, string>();
WmauGpDomainBuilder.AddQueriesFromContainer(publicQueriesContainer, string.Empty, sortedValues);
// Add the sorted types to the domain
foreach (string value in sortedValues.Keys)
{
domain.AddStringCode(value, value);
}
return(domain as IGPDomain);
}
/// <summary>
/// Pre validates the given set of values.
/// </summary>
/// <param name="parameters">The parameters.</param>
/// <param name="environmentManager">Provides access to all the current environments and settings of the current client.</param>
/// <param name="utilities">
/// The utilities object that provides access to the properties and methods of a geoprocessing
/// objects.
/// </param>
protected override void UpdateParameters(Dictionary <string, IGPParameter> parameters, IGPEnvironmentManager environmentManager, IGPUtilities2 utilities)
{
// Retrieve the input parameter value.
IGPValue table = utilities.UnpackGPValue(parameters["in_table"]);
if (!table.IsEmpty())
{
// Create the domain based on the fields on the table.
IObjectClass oclass = utilities.OpenTable(table);
if (oclass != null)
{
IFields fields = oclass.Fields;
if (fields != null)
{
IGPCodedValueDomain codedValueDomain = new GPCodedValueDomainClass();
foreach (var o in fields.AsEnumerable())
{
codedValueDomain.AddStringCode(o.Name, o.Name);
}
IGPParameterEdit3 derivedFields = (IGPParameterEdit3)parameters["in_field"];
derivedFields.Domain = (IGPDomain)codedValueDomain;
}
IGPValue field = utilities.UnpackGPValue(parameters["in_field"]);
if (!field.IsEmpty())
{
int index = oclass.FindField(field.GetAsText());
IGPCodedValueDomain codedValueDomain = new GPCodedValueDomainClass();
foreach (var o in oclass.GetFieldModelNames(oclass.Fields.Field[index]))
{
codedValueDomain.AddStringCode(o, o);
}
IGPParameterEdit3 derivedParameter = (IGPParameterEdit3)parameters["in_field_model_names"];
derivedParameter.Domain = (IGPDomain)codedValueDomain;
}
}
}
}
/// <summary>
/// Builds a domain containing the names of all the map documents embedded
/// in the database
/// </summary>
/// <param name="wmxDb">A reference to the active Workflow Manager database</param>
/// <returns>A coded value domain as an IGPDomain</returns>
public static IGPDomain BuildMapDocumentDomain(IJTXDatabase3 wmxDb)
{
IGPCodedValueDomain mxdNames = new GPCodedValueDomainClass();
SortedList <string, string> mapDocumentNames = new SortedList <string, string>();
IJTXConfiguration3 configMgr = wmxDb.ConfigurationManager as IJTXConfiguration3;
IJTXMapSet maps = configMgr.JTXMaps;
for (int i = 0; i < maps.Count; i++)
{
IJTXMap map = maps.get_Item(i);
mapDocumentNames.Add(map.Name, null);
}
foreach (string mapDocName in mapDocumentNames.Keys)
{
mxdNames.AddStringCode(mapDocName, mapDocName);
}
return(mxdNames as IGPDomain);
}
/// <summary>
/// Builds a domain containing the names of all the task assistant
/// workbooks embedded in the database
/// </summary>
/// <param name="wmxDb">A reference to the active Workflow Manager database</param>
/// <returns>A coded value domain as an IGPDomain</returns>
public static IGPDomain BuildTamWorkbookDomain(IJTXDatabase3 wmxDb)
{
IGPCodedValueDomain tamNames = new GPCodedValueDomainClass();
SortedList <string, string> sortedTamNames = new SortedList <string, string>();
IJTXConfiguration3 configMgr = wmxDb.ConfigurationManager as IJTXConfiguration3;
IJTXTaskAssistantWorkflowRecordSet tamWorkbooks = configMgr.TaskAssistantWorkflowRecords;
for (int i = 0; i < tamWorkbooks.Count; i++)
{
IJTXTaskAssistantWorkflowRecord tamWorkbook = tamWorkbooks.get_Item(i);
sortedTamNames.Add(tamWorkbook.Alias, null);
}
foreach (string tamName in sortedTamNames.Keys)
{
tamNames.AddStringCode(tamName, tamName);
}
return(tamNames as IGPDomain);
}
/// <summary>
/// Builds a domain of the data workspace names in the system
/// </summary>
/// <param name="wmxDb">A reference to the active Workflow Manager database</param>
/// <param name="extraValues">An array of string values to be added to the list</param>
/// <returns>A coded value domain as an IGPDomain</returns>
public static IGPDomain BuildWorkspaceDomain(IJTXDatabase3 wmxDb, string[] extraValues)
{
IGPCodedValueDomain domain = new GPCodedValueDomainClass();
SortedList <string, string> sortedValues = new SortedList <string, string>();
// Workflow Manager intentionally caches the data workspaces in the system. To ensure
// that we have the most current list of data workspaces, invalidate this cache
// before attempting to retrieve the list from the system.
wmxDb.InvalidateDataWorkspaceNames();
// Sort the types first
IJTXDataWorkspaceNameSet allValues = wmxDb.GetDataWorkspaceNames(null);
for (int i = 0; i < allValues.Count; i++)
{
IJTXDataWorkspaceName ws = allValues.get_Item(i);
sortedValues.Add(ws.Name, null);
}
// Add the extra values, if any
if (extraValues != null)
{
foreach (string s in extraValues)
{
sortedValues.Add(s, null);
}
}
// Add the sorted types to the domain
foreach (string value in sortedValues.Keys)
{
IGPValue tempGpVal = new GPStringClass();
tempGpVal.SetAsText(value);
domain.AddCode(tempGpVal, value);
}
return(domain as IGPDomain);
}
/// <summary>
/// Pre validates the given set of values.
/// </summary>
/// <param name="parameters">The parameters.</param>
/// <param name="environmentManager">Provides access to all the current environments and settings of the current client.</param>
/// <param name="utilities">
/// The utilities object that provides access to the properties and methods of a geoprocessing
/// objects.
/// </param>
protected override void UpdateParameters(Dictionary <string, IGPParameter> parameters, IGPEnvironmentManager environmentManager, IGPUtilities2 utilities)
{
// Retrieve the input parameter value.
IGPValue value = utilities.UnpackGPValue(parameters["in_table"]);
if (!value.IsEmpty())
{
// Create the domain based on the fields on the table.
IObjectClass table = utilities.OpenTable(value);
if (table != null)
{
IGPCodedValueDomain codedValueDomain = new GPCodedValueDomainClass();
foreach (var modelName in table.GetClassModelNames())
{
codedValueDomain.AddStringCode(modelName, modelName);
}
IGPParameterEdit3 derivedFields = (IGPParameterEdit3)parameters["in_class_model_names"];
derivedFields.Domain = (IGPDomain)codedValueDomain;
}
}
}
/// <summary>
/// Pre validates the given set of values.
/// </summary>
/// <param name="parameters">The parameters.</param>
/// <param name="environmentManager">Provides access to all the current environments and settings of the current client.</param>
/// <param name="utilities">
/// The utilities object that provides access to the properties and methods of a geoprocessing
/// objects.
/// </param>
protected override void UpdateParameters(Dictionary<string, IGPParameter> parameters, IGPEnvironmentManager environmentManager, IGPUtilities2 utilities)
{
// Retrieve the input parameter value.
IGPValue value = utilities.UnpackGPValue(parameters["in_table"]);
if (!value.IsEmpty())
{
// Create the domain based on the fields on the table.
IDETable table = value as IDETable;
if (table != null)
{
IFields fields = table.Fields;
if (fields != null)
{
IGPCodedValueDomain codedValueDomain = new GPCodedValueDomainClass();
foreach (var field in fields.AsEnumerable())
codedValueDomain.AddStringCode(field.Name, field.Name);
IGPParameterEdit3 derivedFields = (IGPParameterEdit3) parameters["in_fields"];
derivedFields.Domain = (IGPDomain) codedValueDomain;
}
}
}
}
/// <summary>
/// Builds a domain from the names of the job types in the system
/// </summary>
/// <param name="wmxDb">A reference to the active Workflow Manager database</param>
/// <returns>A coded value domain as an IGPDomain</returns>
public static IGPDomain BuildJobTypeDomain(IJTXDatabase3 wmxDb)
{
IGPCodedValueDomain domain = new GPCodedValueDomainClass();
// Sort the types first
IJTXJobTypeSet allValues = wmxDb.ConfigurationManager.JobTypes;
SortedList <string, string> sortedValues = new SortedList <string, string>();
for (int i = 0; i < allValues.Count; i++)
{
sortedValues.Add(allValues.get_Item(i).Name, null);
}
// Add the sorted types to the domain
foreach (string value in sortedValues.Keys)
{
IGPValue tempGpVal = new GPStringClass();
tempGpVal.SetAsText(value);
domain.AddCode(tempGpVal, value);
}
return(domain as IGPDomain);
}
/// <summary>
/// Set up a coded value domain containing the names of all the spatial notifications
/// (a.k.a. "change rules") currently in the database.
/// </summary>
/// <param name="wmxDb">A reference to the active Workflow Manager database</param>
/// <returns>A coded value domain as an IGPDomain</returns>
public static IGPDomain BuildChangeRulesDomain(IJTXDatabase3 wmxDb)
{
IGPCodedValueDomain domain = new GPCodedValueDomainClass();
SortedList <string, string> sortedValues = new SortedList <string, string>();
IJTXChangeRuleSet allChangeRules = wmxDb.SpatialNotificationManager.ChangeRules;
// Sort the types first
for (int i = 0; i < allChangeRules.Count; i++)
{
IJTXChangeRule tempRule = allChangeRules.get_Item(i);
sortedValues.Add(tempRule.Name, null);
}
// Add the sorted types to the domain
foreach (string value in sortedValues.Keys)
{
IGPValue tempGpVal = new GPStringClass();
tempGpVal.SetAsText(value);
domain.AddCode(tempGpVal, value);
}
return(domain as IGPDomain);
}
public void UpdateParameters(ESRI.ArcGIS.esriSystem.IArray paramvalues, ESRI.ArcGIS.Geoprocessing.IGPEnvironmentManager pEnvMgr)
{
try
{
IGPUtilities3 gpUtilities3 = new GPUtilitiesClass();
IGPParameter inputOSMParameter = paramvalues.get_Element(in_osmFeatureClassNumber) as IGPParameter;
IGPValue inputOSMGPValue = gpUtilities3.UnpackGPValue(inputOSMParameter);
if (inputOSMGPValue.IsEmpty() == false)
{
if (inputOSMParameter.Altered == true)
{
IGPParameter attributeCollectionParameter = paramvalues.get_Element(in_attributeSelectorNumber) as IGPParameter;
IGPValue attributeCollectionGPValue = gpUtilities3.UnpackGPValue(attributeCollectionParameter);
if (inputOSMParameter.HasBeenValidated == false && ((IGPMultiValue)attributeCollectionGPValue).Count == 0)
{
IFeatureClass osmFeatureClass = null;
ITable osmInputTable = null;
IQueryFilter osmQueryFilter = null;
try
{
gpUtilities3.DecodeFeatureLayer(inputOSMGPValue, out osmFeatureClass, out osmQueryFilter);
osmInputTable = osmFeatureClass as ITable;
}
catch { }
try
{
if (osmInputTable == null)
{
gpUtilities3.DecodeTableView(inputOSMGPValue, out osmInputTable, out osmQueryFilter);
}
}
catch { }
if (osmInputTable == null)
{
return;
}
using (ComReleaser comReleaser = new ComReleaser())
{
ICursor osmCursor = osmInputTable.Search(osmQueryFilter, true);
comReleaser.ManageLifetime(osmCursor);
IRow osmRow = osmCursor.NextRow();
List<string> potentialOSMFields = new List<string>();
if (osmRow != null)
{
IFields osmFields = osmRow.Fields;
for (int fieldIndex = 0; fieldIndex < osmFields.FieldCount; fieldIndex++)
{
if (osmFields.get_Field(fieldIndex).Name.Substring(0, 4).Equals("osm_"))
{
potentialOSMFields.Add(osmFields.get_Field(fieldIndex).Name);
}
}
}
if (potentialOSMFields.Count == 0)
{
return;
}
IGPCodedValueDomain osmTagKeyCodedValues = new GPCodedValueDomainClass();
foreach (string tagOSMField in potentialOSMFields)
{
osmTagKeyCodedValues.AddStringCode(tagOSMField, tagOSMField);
}
((IGPParameterEdit)attributeCollectionParameter).Domain = (IGPDomain)osmTagKeyCodedValues;
}
}
}
}
}
catch { }
}
public void UpdateParameters(ESRI.ArcGIS.esriSystem.IArray paramvalues, ESRI.ArcGIS.Geoprocessing.IGPEnvironmentManager pEnvMgr)
{
try
{
IGPUtilities3 gpUtilities3 = new GPUtilitiesClass();
IGPParameter inputOSMParameter = paramvalues.get_Element(in_osmFeatureClassNumber) as IGPParameter;
IGPValue inputOSMGPValue = gpUtilities3.UnpackGPValue(inputOSMParameter);
if (inputOSMGPValue.IsEmpty() == false)
{
if (inputOSMParameter.Altered == true)
{
IGPParameter attributeCollectionParameter = paramvalues.get_Element(in_attributeSelectorNumber) as IGPParameter;
IGPValue attributeCollectionGPValue = gpUtilities3.UnpackGPValue(attributeCollectionParameter);
if (inputOSMParameter.HasBeenValidated == false && ((IGPMultiValue)attributeCollectionGPValue).Count == 0)
{
IFeatureClass osmFeatureClass = null;
ITable osmInputTable = null;
IQueryFilter osmQueryFilter = null;
try
{
gpUtilities3.DecodeFeatureLayer(inputOSMGPValue, out osmFeatureClass, out osmQueryFilter);
osmInputTable = osmFeatureClass as ITable;
}
catch { }
try
{
if (osmInputTable == null)
{
gpUtilities3.DecodeTableView(inputOSMGPValue, out osmInputTable, out osmQueryFilter);
}
}
catch { }
if (osmInputTable == null)
{
return;
}
using (ComReleaser comReleaser = new ComReleaser())
{
ICursor osmCursor = osmInputTable.Search(osmQueryFilter, true);
comReleaser.ManageLifetime(osmCursor);
IRow osmRow = osmCursor.NextRow();
List <string> potentialOSMFields = new List <string>();
if (osmRow != null)
{
IFields osmFields = osmRow.Fields;
for (int fieldIndex = 0; fieldIndex < osmFields.FieldCount; fieldIndex++)
{
if (osmFields.get_Field(fieldIndex).Name.Substring(0, 4).Equals("osm_"))
{
potentialOSMFields.Add(osmFields.get_Field(fieldIndex).Name);
}
}
}
if (potentialOSMFields.Count == 0)
{
return;
}
IGPCodedValueDomain osmTagKeyCodedValues = new GPCodedValueDomainClass();
foreach (string tagOSMField in potentialOSMFields)
{
osmTagKeyCodedValues.AddStringCode(tagOSMField, tagOSMField);
}
((IGPParameterEdit)attributeCollectionParameter).Domain = (IGPDomain)osmTagKeyCodedValues;
}
}
}
}
}
catch { }
}
/// <summary>
/// Pre validates the given set of values.
/// This is where you populate derived parameters based on input, among other things.
/// </summary>
/// <param name="paramValues"></param>
/// <param name="pEnvMgr"></param>
public override void UpdateParameters(IArray paramValues, IGPEnvironmentManager pEnvMgr)
{
try
{
UpdateParametersCommon(paramValues, pEnvMgr);
}
catch (WmxDefaultDbNotSetException)
{
// If the default DB wasn't set, stop executing
return;
}
catch (NullReferenceException)
{
// If one of the parameters was null, stop executing
return;
}
// Get the parameters as a map for easier access
WmauParameterMap paramMap = new WmauParameterMap(paramValues);
IGPParameter3 jobTypeParam = paramMap.GetParam(C_PARAM_JOB_TYPE);
IGPParameterEdit3 jobTypeParamEdit = paramMap.GetParamEdit(C_PARAM_JOB_TYPE);
IGPParameter3 dataWorkspace = paramMap.GetParam(C_PARAM_DATA_WORKSPACE);
IGPParameterEdit3 dataWorkspaceEdit = paramMap.GetParamEdit(C_PARAM_DATA_WORKSPACE);
IGPParameter3 parentVersion = paramMap.GetParam(C_PARAM_PARENT_VERSION);
IGPParameterEdit3 parentVersionEdit = paramMap.GetParamEdit(C_PARAM_PARENT_VERSION);
// Set the domains for any parameters that need them
if (jobTypeParam.Domain == null)
{
jobTypeParamEdit.Domain = Common.WmauGpDomainBuilder.BuildJobTypeDomain(this.WmxDatabase);
}
if (dataWorkspace.Domain == null)
{
dataWorkspaceEdit.Domain = Common.WmauGpDomainBuilder.BuildWorkspaceDomain(
this.WmxDatabase,
new string[] { C_OPT_NONE });
}
// Only update the domain for the parent version field if it hasn't yet been
// populated, or if the value of the data workspace parameter has changed
string newDataWorkspace = dataWorkspace.Value.GetAsText();
if (parentVersion.Domain == null ||
!m_dataWorkspaceName.Equals(newDataWorkspace))
{
IGPDomain versionDomain = null;
string newJobType = jobTypeParam.Value.GetAsText();
IJTXJobType3 jobType = this.WmxDatabase.ConfigurationManager.GetJobType(newJobType) as IJTXJobType3;
if (newDataWorkspace.Equals(C_OPT_NONE) ||
newDataWorkspace.Equals(string.Empty))
{
// Case 1: the only acceptable option for the parent version is "none".
IGPCodedValueDomain cvDomain = new GPCodedValueDomainClass();
cvDomain.AddStringCode(C_OPT_NONE, C_OPT_NONE);
versionDomain = cvDomain as IGPDomain;
}
else
{
// Case 2: we need to retrieve the version list for an existing
// data workspace
try
{
versionDomain = Common.WmauGpDomainBuilder.BuildVersionsDomain(
this.WmxDatabase, newDataWorkspace, new string[] { C_OPT_NONE });
}
catch (WmauException)
{
// Use the "null" as an error value; we'll check for this later
versionDomain = null;
}
}
parentVersionEdit.Domain = versionDomain;
}
}
/// <summary>
/// Builds a domain consisting of the names of the system groups to which a
/// user can assign a job.
/// </summary>
/// <param name="wmxDb">A reference to the active Workflow Manager database</param>
/// <param name="username">The name of the user to be tested</param>
/// <param name="extraValues">An array of string values to be added to the list</param>
/// <returns>A coded value domain as an IGPDomain</returns>
public static IGPDomain BuildAssignableGroupsDomain(IJTXDatabase3 wmxDb, string username, string[] extraValues)
{
IGPCodedValueDomain domain = new GPCodedValueDomainClass();
string[] eligibleGroups = null;
// Only proceed if the user exists in the Workflow Manager database
IJTXUser3 user = wmxDb.ConfigurationManager.GetUser(username) as IJTXUser3;
if (user == null)
{
return(domain as IGPDomain);
}
// The groups to which this user can assign jobs are based on several
// different permissions. Check these permissions, in order from least
// restrictive to most restrictive.
if (user.HasNamedPrivilege(ESRI.ArcGIS.JTX.Utilities.Constants.PRIV_ASSIGN_ANY_JOB))
{
int numGroups = wmxDb.ConfigurationManager.UserGroups.Count;
eligibleGroups = new string[numGroups];
for (int i = 0; i < numGroups; i++)
{
eligibleGroups[i] = wmxDb.ConfigurationManager.UserGroups.get_Item(i).Name;
}
}
else if (user.HasNamedPrivilege(ESRI.ArcGIS.JTX.Utilities.Constants.PRIV_GROUP_JOB_ASSIGN))
{
eligibleGroups = new string[user.Groups.Count];
for (int i = 0; i < user.Groups.Count; i++)
{
eligibleGroups[i] = user.Groups.get_Item(i).Name;
}
}
else
{
eligibleGroups = new string[0];
}
// Sort the types first
SortedList <string, string> sortedValues = new SortedList <string, string>();
for (int i = 0; i < eligibleGroups.Length; i++)
{
sortedValues.Add(eligibleGroups[i], null);
}
// Add the extra values, if any
if (extraValues != null)
{
foreach (string s in extraValues)
{
sortedValues.Add(s, null);
}
}
// Add the sorted types to the domain
foreach (string value in sortedValues.Keys)
{
IGPValue tempGpVal = new GPStringClass();
tempGpVal.SetAsText(value);
domain.AddCode(tempGpVal, value);
}
return(domain as IGPDomain);
}
/// <summary>
/// Builds a domain containing the usernames of the users to whom a
/// user can assign jobs.
/// </summary>
/// <param name="wmxDb">A reference to the active Workflow Manager database</param>
/// <param name="username">The name of the user to be tested</param>
/// <param name="extraValues">An array of string values to be added to the list</param>
/// <returns>A coded value domain of strings</returns>
public static IGPDomain BuildAssignableUsersDomain(IJTXDatabase3 wmxDb, string username, string[] extraValues)
{
IGPCodedValueDomain domain = null;
// Only proceed if the user exists in the Workflow Manager database
IJTXUser3 user = wmxDb.ConfigurationManager.GetUser(username) as IJTXUser3;
if (user == null)
{
return(domain as IGPDomain);
}
// Case 1: If the user can assign the job to anyone, then
// just use the "all users" list
if (user.HasNamedPrivilege(ESRI.ArcGIS.JTX.Utilities.Constants.PRIV_ASSIGN_ANY_JOB))
{
domain = Common.WmauGpDomainBuilder.BuildUsersDomain(wmxDb, extraValues) as IGPCodedValueDomain;
}
else
{
domain = new GPCodedValueDomainClass();
string[] eligibleUsers = null;
// Case 2: The user can assign jobs to anyone within any of their groups
if (user.HasNamedPrivilege(ESRI.ArcGIS.JTX.Utilities.Constants.PRIV_GROUP_JOB_ASSIGN))
{
HashSet <string> usernames = new HashSet <string>();
IJTXUserGroupSet groups = user.Groups;
for (int i = 0; i < groups.Count; i++)
{
IJTXUserGroup group = groups.get_Item(i);
for (int j = 0; j < group.Users.Count; j++)
{
usernames.Add(group.Users.get_Item(j).UserName);
}
}
eligibleUsers = usernames.ToArray();
}
// Case 3: The user can assign jobs to themselves
else if (user.HasNamedPrivilege(ESRI.ArcGIS.JTX.Utilities.Constants.PRIV_INDIVIDUAL_JOB_ASSIGN))
{
eligibleUsers = new string[] { username };
}
// Case 4: The user can't assign jobs to anyone
else
{
eligibleUsers = new string[0];
}
// Sort the types first
SortedList <string, string> sortedValues = new SortedList <string, string>();
for (int i = 0; i < eligibleUsers.Length; i++)
{
sortedValues.Add(eligibleUsers[i], null);
}
// Add the extra values, if any
if (extraValues != null)
{
foreach (string s in extraValues)
{
sortedValues.Add(s, null);
}
}
// Add the sorted types to the domain
foreach (string value in sortedValues.Keys)
{
IGPValue tempGpVal = new GPStringClass();
tempGpVal.SetAsText(value);
domain.AddCode(tempGpVal, value);
}
}
return(domain as IGPDomain);
}
