/// <summary>
/// Checks if the input string contains database specific invalid characters
/// </summary>
/// <param name="name">string to test for invalid characters</param>
/// <param name="message">If name fails then this variable will contain a description</param>
/// <returns>False if passed. True if failed.</returns>
public bool ContainsInvalidCharacters(string name, out string message)
{
// Validate Input Arguments
if (string.IsNullOrEmpty(name))
{
throw new ArgumentNullException("name", "Name argument cannot be null or empty");
}
// Get array of invalid characters
ISQLSyntax sqlSyntax = (ISQLSyntax)this._workspace;
string invalidCharacters = sqlSyntax.GetInvalidCharacters();
char[] invalidCharacters2 = invalidCharacters.ToCharArray();
// Get index of first occuring invalid character
int index = name.IndexOfAny(invalidCharacters2);
if (index != -1)
{
message = string.Format(
"The text '{0}' contains one or more of the following invalid characters '{1}'",
name,
invalidCharacters);
return(true);
}
// No Errors
message = null;
// Return false (Name does NOT contain any invalid characters)
return(false);
}
private List <WorkspaceInfoViewModel> LoadWorkspaceInfosFromArcMap()
{
var result = new List <WorkspaceInfoViewModel>();
var workspaces = ArcmapUtils.EnumerateAllWorkspaces(Ioc.GetOrCreate <IApplication>());
foreach (IWorkspace workspace in workspaces)
{
WorkspaceInfoViewModel info = new WorkspaceInfoViewModel();
info.Path = workspace.PathName;
info.Name = Path.GetFileNameWithoutExtension(info.Path);
ISQLSyntax sqlSyntax = workspace as ISQLSyntax;
if (sqlSyntax != null)
{
info.StringComparisonCaseSensitive = sqlSyntax.GetStringComparisonCase();
info.IdentifierCaseSensitive = sqlSyntax.GetIdentifierCase();
info.QuotedIdentifierCaseSensitive = sqlSyntax.GetDelimitedIdentifierCase();
info.InvalidCharactersForIdentifiers = sqlSyntax.GetInvalidCharacters();
foreach (var enumName in Enum.GetValues(typeof(esriSQLFunctionName)))
{
string enumValue = sqlSyntax.GetFunctionName((esriSQLFunctionName)enumName);
if (string.IsNullOrEmpty(enumValue))
{
enumValue = NotAvailable;
}
info.SqlFunctions.AddOrReplace(enumName.ToString(), enumValue);
}
info.SqlFunctions.Sort((x, y) => string.Compare(x.Key, y.Key, StringComparison.InvariantCultureIgnoreCase));
foreach (var enumName in Enum.GetValues(typeof(esriSQLSpecialCharacters)))
{
string enumValue = sqlSyntax.GetSpecialCharacter((esriSQLSpecialCharacters)enumName);
if (string.IsNullOrEmpty(enumValue))
{
enumValue = string.Empty;
}
info.SpecialCharacters.AddOrReplace(enumName.ToString(), enumValue);
}
info.SpecialCharacters.Sort((x, y) => string.Compare(x.Key, y.Key, StringComparison.InvariantCultureIgnoreCase));
foreach (string keyword in sqlSyntax.GetKeywords().Enumerate())
{
info.ReservedWords.Add(keyword);
}
info.ReservedWords.Sort(StringComparer.InvariantCultureIgnoreCase);
}
result.Add(info);
}
return(result);
}
public void Execute(ESRI.ArcGIS.esriSystem.IArray paramvalues, ESRI.ArcGIS.esriSystem.ITrackCancel TrackCancel, ESRI.ArcGIS.Geoprocessing.IGPEnvironmentManager envMgr, ESRI.ArcGIS.Geodatabase.IGPMessages message)
{
try
{
IGPUtilities3 execute_Utilities = new GPUtilitiesClass();
if (TrackCancel == null)
{
TrackCancel = new CancelTrackerClass();
}
IGPParameter inputOSMParameter = paramvalues.get_Element(in_osmFeatureClass) as IGPParameter;
IGPValue inputOSMGPValue = execute_Utilities.UnpackGPValue(inputOSMParameter);
IGPParameter tagCollectionParameter = paramvalues.get_Element(in_attributeSelector) as IGPParameter;
IGPMultiValue tagCollectionGPValue = execute_Utilities.UnpackGPValue(tagCollectionParameter) as IGPMultiValue;
if (tagCollectionGPValue == null)
{
message.AddError(120048, string.Format(resourceManager.GetString("GPTools_NullPointerParameterType"), tagCollectionParameter.Name));
return;
}
bool useUpdateCursor = false;
IFeatureClass osmFeatureClass = null;
ITable osmInputTable = null;
IQueryFilter osmQueryFilter = null;
try
{
execute_Utilities.DecodeFeatureLayer(inputOSMGPValue, out osmFeatureClass, out osmQueryFilter);
if (osmFeatureClass != null)
{
if (osmFeatureClass.Extension is IOSMClassExtension)
{
useUpdateCursor = false;
}
else
{
useUpdateCursor = true;
}
}
osmInputTable = osmFeatureClass as ITable;
}
catch { }
try
{
if (osmInputTable == null)
{
execute_Utilities.DecodeTableView(inputOSMGPValue, out osmInputTable, out osmQueryFilter);
}
}
catch { }
if (osmInputTable == null)
{
string errorMessage = String.Format(resourceManager.GetString("GPTools_OSMGPAttributeSelecto_unableopentable"), inputOSMGPValue.GetAsText());
message.AddError(120053, errorMessage);
return;
}
// find the field that holds tag binary/xml field
int osmTagCollectionFieldIndex = osmInputTable.FindField("osmTags");
// if the Field doesn't exist - wasn't found (index = -1) get out
if (osmTagCollectionFieldIndex == -1)
{
message.AddError(120005, resourceManager.GetString("GPTools_OSMGPAttributeSelector_notagfieldfound"));
return;
}
// check if the tag collection includes the keyword "ALL", if does then we'll need to extract all tags
bool extractAll = false;
for (int valueIndex = 0; valueIndex < tagCollectionGPValue.Count; valueIndex++)
{
if (tagCollectionGPValue.get_Value(valueIndex).GetAsText().Equals("ALL"))
{
extractAll = true;
break;
}
}
//if (extractAll)
//{
// if (osmTagKeyCodedValues == null)
// extractAllTags(ref osmTagKeyCodedValues, osmInputTable, osmQueryFilter, osmTagCollectionFieldIndex, false);
// if (osmTagKeyCodedValues == null)
// {
// message.AddAbort(resourceManager.GetString("GPTools_OSMGPAttributeSelector_Unable2RetrieveTags"));
// return;
// }
// // empty the existing gp multivalue object
// tagCollectionGPValue = new GPMultiValueClass();
// // fill the coded domain in gp multivalue object
// for (int valueIndex = 0; valueIndex < osmTagKeyCodedValues.CodeCount; valueIndex++)
// {
// tagCollectionGPValue.AddValue(osmTagKeyCodedValues.get_Value(valueIndex));
// }
//}
// get an overall feature count as that determines the progress indicator
int featureCount = osmInputTable.RowCount(osmQueryFilter);
// set up the progress indicator
IStepProgressor stepProgressor = TrackCancel as IStepProgressor;
if (stepProgressor != null)
{
stepProgressor.MinRange = 0;
stepProgressor.MaxRange = featureCount;
stepProgressor.Position = 0;
stepProgressor.Message = resourceManager.GetString("GPTools_OSMGPAttributeSelector_progressMessage");
stepProgressor.StepValue = 1;
stepProgressor.Show();
}
// let's get all the indices of the desired fields
// if the field already exists get the index and if it doesn't exist create it
Dictionary <string, int> tagsAttributesIndices = new Dictionary <string, int>();
Dictionary <int, int> attributeFieldLength = new Dictionary <int, int>();
IFeatureWorkspaceManage featureWorkspaceManage = ((IDataset)osmInputTable).Workspace as IFeatureWorkspaceManage;
String illegalCharacters = String.Empty;
ISQLSyntax sqlSyntax = ((IDataset)osmInputTable).Workspace as ISQLSyntax;
if (sqlSyntax != null)
{
illegalCharacters = sqlSyntax.GetInvalidCharacters();
}
IFieldsEdit fieldsEdit = osmInputTable.Fields as IFieldsEdit;
using (SchemaLockManager lockMgr = new SchemaLockManager(osmInputTable))
{
try
{
string tagKey = String.Empty;
ESRI.ArcGIS.Geoprocessing.IGeoProcessor2 gp = new ESRI.ArcGIS.Geoprocessing.GeoProcessorClass();
// if we have explicitly defined tags to extract then go through the list of values now
if (extractAll == false)
{
for (int valueIndex = 0; valueIndex < tagCollectionGPValue.Count; valueIndex++)
{
if (TrackCancel.Continue() == false)
{
return;
}
try
{
// Check if the input field already exists.
string nameofTag = tagCollectionGPValue.get_Value(valueIndex).GetAsText();
tagKey = convert2AttributeFieldName(nameofTag, illegalCharacters);
int fieldIndex = osmInputTable.FindField(tagKey);
if (fieldIndex < 0)
{
// generate a new attribute field
IFieldEdit fieldEdit = new FieldClass();
fieldEdit.Name_2 = tagKey;
fieldEdit.AliasName_2 = nameofTag + resourceManager.GetString("GPTools_OSMGPAttributeSelector_aliasaddition");
fieldEdit.Type_2 = esriFieldType.esriFieldTypeString;
fieldEdit.Length_2 = 100;
osmInputTable.AddField(fieldEdit);
message.AddMessage(string.Format(resourceManager.GetString("GPTools_OSMGPAttributeSelector_addField"), tagKey, nameofTag));
// re-generate the attribute index
fieldIndex = osmInputTable.FindField(tagKey);
}
if (fieldIndex > 0)
{
tagsAttributesIndices.Add(nameofTag, fieldIndex);
attributeFieldLength.Add(fieldIndex, osmInputTable.Fields.get_Field(fieldIndex).Length);
}
}
catch (Exception ex)
{
// the key is already there, this might result because from multiple upper and lower-case combinations of the same key
message.AddWarning(ex.Message + " (" + convert2OSMKey(tagKey, illegalCharacters) + ")");
}
}
}
else
{
List <string> listofAllTags = extractAllTags(osmInputTable, osmQueryFilter, osmTagCollectionFieldIndex);
foreach (string nameOfTag in listofAllTags)
{
if (TrackCancel.Continue() == false)
{
return;
}
try
{
// Check if the input field already exists.
tagKey = convert2AttributeFieldName(nameOfTag, illegalCharacters);
int fieldIndex = osmInputTable.FindField(tagKey);
if (fieldIndex < 0)
{
// generate a new attribute field
IFieldEdit fieldEdit = new FieldClass();
fieldEdit.Name_2 = tagKey;
fieldEdit.AliasName_2 = nameOfTag + resourceManager.GetString("GPTools_OSMGPAttributeSelector_aliasaddition");
fieldEdit.Type_2 = esriFieldType.esriFieldTypeString;
fieldEdit.Length_2 = 100;
osmInputTable.AddField(fieldEdit);
message.AddMessage(string.Format(resourceManager.GetString("GPTools_OSMGPAttributeSelector_addField"), tagKey, nameOfTag));
// re-generate the attribute index
fieldIndex = osmInputTable.FindField(tagKey);
}
if (fieldIndex > 0)
{
tagsAttributesIndices.Add(nameOfTag, fieldIndex);
attributeFieldLength.Add(fieldIndex, osmInputTable.Fields.get_Field(fieldIndex).Length);
}
}
catch (Exception ex)
{
// the key is already there, this might result because from multiple upper and lower-case combinations of the same key
message.AddWarning(ex.Message + " (" + convert2OSMKey(tagKey, illegalCharacters) + ")");
}
}
}
}
catch (Exception ex)
{
message.AddWarning(ex.Message);
}
}
try
{
execute_Utilities.DecodeFeatureLayer(inputOSMGPValue, out osmFeatureClass, out osmQueryFilter);
if (osmFeatureClass != null)
{
if (osmFeatureClass.Extension is IOSMClassExtension)
{
useUpdateCursor = false;
}
else
{
useUpdateCursor = true;
}
}
osmInputTable = osmFeatureClass as ITable;
}
catch { }
try
{
if (osmInputTable == null)
{
execute_Utilities.DecodeTableView(inputOSMGPValue, out osmInputTable, out osmQueryFilter);
}
}
catch { }
if (osmInputTable == null)
{
string errorMessage = String.Format(resourceManager.GetString("GPTools_OSMGPAttributeSelecto_unableopentable"), inputOSMGPValue.GetAsText());
message.AddError(120053, errorMessage);
return;
}
using (ComReleaser comReleaser = new ComReleaser())
{
using (SchemaLockManager lockMgr = new SchemaLockManager(osmInputTable))
{
// get an update cursor for all the features to process
ICursor rowCursor = null;
if (useUpdateCursor)
{
rowCursor = osmInputTable.Update(osmQueryFilter, false);
}
else
{
rowCursor = osmInputTable.Search(osmQueryFilter, false);
}
comReleaser.ManageLifetime(rowCursor);
IRow osmRow = null;
Dictionary <string, string> tagKeys = new Dictionary <string, string>();
int progessIndex = 0;
#if DEBUG
message.AddMessage("useUpdateCursor: " + useUpdateCursor.ToString());
#endif
// as long as there are features....
while ((osmRow = rowCursor.NextRow()) != null)
{
// retrieve the tags of the current feature
tag[] storedTags = _osmUtility.retrieveOSMTags(osmRow, osmTagCollectionFieldIndex, ((IDataset)osmInputTable).Workspace);
bool rowChanged = false;
if (storedTags != null)
{
foreach (tag tagItem in storedTags)
{
// Check for matching values so we only change a minimum number of rows
if (tagsAttributesIndices.ContainsKey(tagItem.k))
{
int fieldIndex = tagsAttributesIndices[tagItem.k];
//...then stored the value in the attribute field
// ensure that the content of the tag actually does fit into the field length...otherwise do truncate it
string tagValue = tagItem.v;
int fieldLength = attributeFieldLength[fieldIndex];
if (tagValue.Length > fieldLength)
{
tagValue = tagValue.Substring(0, fieldLength);
}
osmRow.set_Value(fieldIndex, tagValue);
rowChanged = true;
}
else
{
#if DEBUG
//message.AddWarning(tagItem.k);
#endif
}
}
}
storedTags = null;
try
{
if (rowChanged)
{
if (useUpdateCursor)
{
rowCursor.UpdateRow(osmRow);
}
else
{
// update the feature through the cursor
osmRow.Store();
}
}
progessIndex++;
}
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine(ex.Message);
message.AddWarning(ex.Message);
}
if (osmRow != null)
{
Marshal.ReleaseComObject(osmRow);
}
if (stepProgressor != null)
{
// update the progress UI
stepProgressor.Position = progessIndex;
}
// check for user cancellation (every 100 rows)
if ((progessIndex % 100 == 0) && (TrackCancel.Continue() == false))
{
return;
}
}
if (stepProgressor != null)
{
stepProgressor.Hide();
}
}
}
execute_Utilities.ReleaseInternals();
Marshal.ReleaseComObject(execute_Utilities);
}
catch (Exception ex)
{
message.AddError(120054, ex.Message);
}
}
public void UpdateParameters(ESRI.ArcGIS.esriSystem.IArray paramvalues, ESRI.ArcGIS.Geoprocessing.IGPEnvironmentManager pEnvMgr)
{
try
{
IGPUtilities3 gpUtilities3 = new GPUtilitiesClass();
IGPValue inputOSMGPValue = gpUtilities3.UnpackGPValue(paramvalues.get_Element(in_osmFeatureClass));
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;
}
String illegalCharacters = String.Empty;
ISQLSyntax sqlSyntax = ((IDataset)osmInputTable).Workspace as ISQLSyntax;
if (sqlSyntax != null)
{
illegalCharacters = sqlSyntax.GetInvalidCharacters();
}
// find the field that holds tag binary/xml field
int osmTagCollectionFieldIndex = osmInputTable.FindField("osmTags");
// if the Field doesn't exist - wasn't found (index = -1) get out
if (osmTagCollectionFieldIndex == -1)
{
return;
}
if (((IGPParameter)paramvalues.get_Element(in_attributeSelector)).Altered)
{
IGPParameter tagCollectionParameter = paramvalues.get_Element(in_attributeSelector) as IGPParameter;
IGPMultiValue tagCollectionGPValue = gpUtilities3.UnpackGPValue(tagCollectionParameter) as IGPMultiValue;
IGPCodedValueDomain codedTagDomain = tagCollectionParameter.Domain as IGPCodedValueDomain;
for (int attributeValueIndex = 0; attributeValueIndex < tagCollectionGPValue.Count; attributeValueIndex++)
{
string valueString = tagCollectionGPValue.get_Value(attributeValueIndex).GetAsText();
IGPValue testFieldValue = codedTagDomain.FindValue(valueString);
if (testFieldValue == null)
{
codedTagDomain.AddStringCode(valueString, valueString);
}
}
// Get the derived output feature class schema and empty the additional fields. This ensures
// that you don't get dublicate entries.
// Derived output is the third parameter, so use index 2 for get_Element.
IGPParameter3 derivedFeatures = (IGPParameter3)paramvalues.get_Element(out_osmFeatureClass);
IGPFeatureSchema schema = (IGPFeatureSchema)derivedFeatures.Schema;
schema.AdditionalFields = null;
IFieldsEdit fieldsEdit = new FieldsClass();
for (int valueIndex = 0; valueIndex < tagCollectionGPValue.Count; valueIndex++)
{
string tagString = tagCollectionGPValue.get_Value(valueIndex).GetAsText();
if (tagString != "ALL")
{
// Check if the input field already exists.
string cleanedTagKey = convert2AttributeFieldName(tagString, illegalCharacters);
IField tagField = gpUtilities3.FindField(inputOSMGPValue, cleanedTagKey);
if (tagField == null)
{
IFieldEdit fieldEdit = new FieldClass();
fieldEdit.Name_2 = cleanedTagKey;
fieldEdit.AliasName_2 = tagCollectionGPValue.get_Value(valueIndex).GetAsText();
fieldEdit.Type_2 = esriFieldType.esriFieldTypeString;
fieldEdit.Length_2 = 100;
fieldsEdit.AddField(fieldEdit);
}
}
}
// Add the additional field to the derived output.
IFields fields = fieldsEdit as IFields;
schema.AdditionalFields = fields;
}
//if (inputOSMGPValue.IsEmpty() == false)
//{
// if (((IGPParameter)paramvalues.get_Element(in_osmFeatureClass)).HasBeenValidated == false)
// {
// IGPParameter tagCollectionGPParameter = paramvalues.get_Element(in_attributeSelector) as IGPParameter;
// IGPValue tagCollectionGPValue = gpUtilities3.UnpackGPValue(tagCollectionGPParameter);
// IGPCodedValueDomain osmTagKeyCodedValues = new GPCodedValueDomainClass();
// if (((IGPMultiValue)tagCollectionGPValue).Count == 0)
// {
// if (osmTagKeyCodedValues == null)
// extractAllTags(ref osmTagKeyCodedValues, osmInputTable, osmQueryFilter, osmTagCollectionFieldIndex, true);
// if (osmTagKeyCodedValues != null)
// {
// tagsParameter = tagCollectionGPParameter as IGPParameterEdit;
// tagsParameter.Domain = (IGPDomain)osmTagKeyCodedValues;
// }
// }
// else
// {
// // let's take the given values and make then part of the domain -- if they are not already
// // if we don't do this step then we won't pass the internal validation
// IGPCodedValueDomain gpTagDomain = tagCollectionGPParameter.Domain as IGPCodedValueDomain;
// if (gpTagDomain != null)
// {
// if (gpTagDomain.CodeCount == 0)
// {
// // let's add the value existing in the mentioned multi value to the domain
// for (int i = 0; i < ((IGPMultiValue)tagCollectionGPValue).Count; i++)
// {
// string tagStringValue = ((IGPMultiValue)tagCollectionGPValue).get_Value(i).GetAsText();
// gpTagDomain.AddStringCode(tagStringValue, tagStringValue);
// }
// ((IGPParameterEdit)tagCollectionGPParameter).Domain = gpTagDomain as IGPDomain;
// }
// }
// }
// // Get the derived output feature class schema and empty the additional fields. This ensures
// // that you don't get dublicate entries.
// // Derived output is the third parameter, so use index 2 for get_Element.
// IGPParameter3 derivedFeatures = (IGPParameter3)paramvalues.get_Element(out_osmFeatureClass);
// IGPFeatureSchema schema = (IGPFeatureSchema)derivedFeatures.Schema;
// schema.AdditionalFields = null;
// // Area field name is the second parameter, so use index 1 for get_Element.
// IGPMultiValue tagsGPMultiValue = gpUtilities3.UnpackGPValue(paramvalues.get_Element(in_attributeSelector)) as IGPMultiValue;
// IFieldsEdit fieldsEdit = new FieldsClass();
// bool extractALLTags = false;
// // check if the list contains the "ALL" keyword
// for (int valueIndex = 0; valueIndex < tagsGPMultiValue.Count; valueIndex++)
// {
// if (tagsGPMultiValue.get_Value(valueIndex).GetAsText().Equals("ALL"))
// {
// extractALLTags = true;
// }
// }
// if (extractALLTags)
// {
// if (osmTagKeyCodedValues == null)
// {
// extractAllTags(ref osmTagKeyCodedValues, osmInputTable, osmQueryFilter, osmTagCollectionFieldIndex, false);
// }
// if (osmTagKeyCodedValues != null)
// {
// for (int valueIndex = 0; valueIndex < osmTagKeyCodedValues.CodeCount; valueIndex++)
// {
// // Check if the input field already exists.
// string cleanedTagKey = convert2AttributeFieldName(osmTagKeyCodedValues.get_Value(valueIndex).GetAsText(), illegalCharacters);
// IField tagField = gpUtilities3.FindField(inputOSMGPValue, cleanedTagKey);
// if (tagField == null)
// {
// IFieldEdit fieldEdit = new FieldClass();
// fieldEdit.Name_2 = cleanedTagKey;
// fieldEdit.AliasName_2 = osmTagKeyCodedValues.get_Value(valueIndex).GetAsText();
// fieldEdit.Type_2 = esriFieldType.esriFieldTypeString;
// fieldEdit.Length_2 = 100;
// fieldsEdit.AddField(fieldEdit);
// }
// }
// }
// }
// else
// {
// for (int valueIndex = 0; valueIndex < tagsGPMultiValue.Count; valueIndex++)
// {
// // Check if the input field already exists.
// string cleanedTagKey = convert2AttributeFieldName(tagsGPMultiValue.get_Value(valueIndex).GetAsText(), illegalCharacters);
// IField tagField = gpUtilities3.FindField(inputOSMGPValue, cleanedTagKey);
// if (tagField == null)
// {
// IFieldEdit fieldEdit = new FieldClass();
// fieldEdit.Name_2 = cleanedTagKey;
// fieldEdit.AliasName_2 = tagsGPMultiValue.get_Value(valueIndex).GetAsText();
// fieldEdit.Type_2 = esriFieldType.esriFieldTypeString;
// fieldEdit.Length_2 = 100;
// fieldsEdit.AddField(fieldEdit);
// }
// }
// }
// // Add the additional field to the derived output.
// IFields fields = fieldsEdit as IFields;
// schema.AdditionalFields = fields;
// }
//}
}
catch { }
}
public void Execute(ESRI.ArcGIS.esriSystem.IArray paramvalues, ESRI.ArcGIS.esriSystem.ITrackCancel TrackCancel, ESRI.ArcGIS.Geoprocessing.IGPEnvironmentManager envMgr, ESRI.ArcGIS.Geodatabase.IGPMessages message)
{
try
{
IGPUtilities3 execute_Utilities = new GPUtilitiesClass();
OSMUtility osmUtility = new OSMUtility();
if (TrackCancel == null)
{
TrackCancel = new CancelTrackerClass();
}
IGPParameter inputOSMParameter = paramvalues.get_Element(in_osmFeatureClassNumber) as IGPParameter;
IGPValue inputOSMGPValue = execute_Utilities.UnpackGPValue(inputOSMParameter);
IGPParameter tagFieldsParameter = paramvalues.get_Element(in_attributeSelectorNumber) as IGPParameter;
IGPMultiValue tagCollectionGPValue = execute_Utilities.UnpackGPValue(tagFieldsParameter) as IGPMultiValue;
if (tagCollectionGPValue == null)
{
message.AddError(120048, string.Format(resourceManager.GetString("GPTools_NullPointerParameterType"), tagFieldsParameter.Name));
return;
}
IFeatureClass osmFeatureClass = null;
ITable osmInputTable = null;
IQueryFilter osmQueryFilter = null;
try
{
execute_Utilities.DecodeFeatureLayer(inputOSMGPValue, out osmFeatureClass, out osmQueryFilter);
osmInputTable = osmFeatureClass as ITable;
}
catch { }
try
{
if (osmInputTable == null)
{
execute_Utilities.DecodeTableView(inputOSMGPValue, out osmInputTable, out osmQueryFilter);
}
}
catch { }
if (osmInputTable == null)
{
return;
}
// find the field that holds tag binary/xml field
int osmTagCollectionFieldIndex = osmInputTable.FindField("osmTags");
// if the Field doesn't exist - wasn't found (index = -1) get out
if (osmTagCollectionFieldIndex == -1)
{
message.AddError(120005, resourceManager.GetString("GPTools_OSMGPAttributeSelector_notagfieldfound"));
return;
}
// set up the progress indicator
IStepProgressor stepProgressor = TrackCancel as IStepProgressor;
if (stepProgressor != null)
{
int featureCount = osmInputTable.RowCount(osmQueryFilter);
stepProgressor.MinRange = 0;
stepProgressor.MaxRange = featureCount;
stepProgressor.Position = 0;
stepProgressor.Message = resourceManager.GetString("GPTools_OSMGPCombineAttributes_progressMessage");
stepProgressor.StepValue = 1;
stepProgressor.Show();
}
String illegalCharacters = String.Empty;
ISQLSyntax sqlSyntax = ((IDataset)osmInputTable).Workspace as ISQLSyntax;
if (sqlSyntax != null)
{
illegalCharacters = sqlSyntax.GetInvalidCharacters();
}
// establish the list of field indexes only once
Dictionary <string, int> fieldIndexes = new Dictionary <string, int>();
for (int selectedGPValueIndex = 0; selectedGPValueIndex < tagCollectionGPValue.Count; selectedGPValueIndex++)
{
// find the field index
int fieldIndex = osmInputTable.FindField(tagCollectionGPValue.get_Value(selectedGPValueIndex).GetAsText());
if (fieldIndex != -1)
{
string tagKeyName = osmInputTable.Fields.get_Field(fieldIndex).Name;
tagKeyName = OSMToolHelper.convert2OSMKey(tagKeyName, illegalCharacters);
fieldIndexes.Add(tagKeyName, fieldIndex);
}
}
ICursor updateCursor = null;
IRow osmRow = null;
using (ComReleaser comReleaser = new ComReleaser())
{
updateCursor = osmInputTable.Update(osmQueryFilter, false);
comReleaser.ManageLifetime(updateCursor);
osmRow = updateCursor.NextRow();
int progressIndex = 0;
while (osmRow != null)
{
// get the current tag collection from the row
ESRI.ArcGIS.OSM.OSMClassExtension.tag[] osmTags = osmUtility.retrieveOSMTags(osmRow, osmTagCollectionFieldIndex, ((IDataset)osmInputTable).Workspace);
Dictionary <string, string> tagsDictionary = new Dictionary <string, string>();
for (int tagIndex = 0; tagIndex < osmTags.Length; tagIndex++)
{
tagsDictionary.Add(osmTags[tagIndex].k, osmTags[tagIndex].v);
}
// look if the tag needs to be updated or added
bool tagsUpdated = false;
foreach (var fieldItem in fieldIndexes)
{
object fldValue = osmRow.get_Value(fieldItem.Value);
if (fldValue != System.DBNull.Value)
{
if (tagsDictionary.ContainsKey(fieldItem.Key))
{
if (!tagsDictionary[fieldItem.Key].Equals(fldValue))
{
tagsDictionary[fieldItem.Key] = Convert.ToString(fldValue);
tagsUpdated = true;
}
}
else
{
tagsDictionary.Add(fieldItem.Key, Convert.ToString(fldValue));
tagsUpdated = true;
}
}
else
{
if (tagsDictionary.ContainsKey(fieldItem.Key))
{
tagsDictionary.Remove(fieldItem.Key);
tagsUpdated = true;
}
}
}
if (tagsUpdated)
{
List <ESRI.ArcGIS.OSM.OSMClassExtension.tag> updatedTags = new List <ESRI.ArcGIS.OSM.OSMClassExtension.tag>();
foreach (var tagItem in tagsDictionary)
{
ESRI.ArcGIS.OSM.OSMClassExtension.tag newTag = new ESRI.ArcGIS.OSM.OSMClassExtension.tag();
newTag.k = tagItem.Key;
newTag.v = tagItem.Value;
updatedTags.Add(newTag);
}
// insert the tags back into the collection field
if (updatedTags.Count != 0)
{
osmUtility.insertOSMTags(osmTagCollectionFieldIndex, osmRow, updatedTags.ToArray(), ((IDataset)osmInputTable).Workspace);
updateCursor.UpdateRow(osmRow);
}
}
progressIndex++;
if (stepProgressor != null)
{
stepProgressor.Position = progressIndex;
}
if (osmRow != null)
{
Marshal.ReleaseComObject(osmRow);
}
osmRow = updateCursor.NextRow();
}
if (stepProgressor != null)
{
stepProgressor.Hide();
}
}
}
catch (Exception ex)
{
message.AddError(120007, ex.Message);
}
}
