private InputParameters getInputParameters()
{
InputParameters inputParameters = new InputParameters();
inputParameters.Add("Equation", this.rightEquationFormat.Text);
inputParameters.Add("VariablesCount", this.variablesCount.Text);
inputParameters.Add("IterationCount", this.iterationCount.Text);
inputParameters.Add("Accuracy", this.accuracy.Text);
return(inputParameters);
}
public UseCase(UseCaseTypes type)
: this()
{
Type = type;
Name = type.ToString();
IsCustom = false;
if (type == UseCaseTypes.RetrieveByPk)
{
InputParameters.Add(new DataParameter(DomainInputType.Guid, "Id"));
OutputParameters.Add(new DataParameter(DomainInputType.DomainEntity, "Entity"));
}
else if (type == UseCaseTypes.RetrieveByUn)
{
InputParameters.Add(new DataParameter(DomainInputType.String, "Name"));
OutputParameters.Add(new DataParameter(DomainInputType.DomainEntity, "Entity"));
}
else if (type == UseCaseTypes.Create)
{
InputParameters.Add(new DataParameter(DomainInputType.DomainEntity, "Entity"));
OutputParameters.Add(new DataParameter(DomainInputType.Guid, "Id"));
}
else if (type == UseCaseTypes.Update)
{
InputParameters.Add(new DataParameter(DomainInputType.DomainEntity, "Entity"));
}
else if (type == UseCaseTypes.DeleteByPk)
{
InputParameters.Add(new DataParameter(DomainInputType.Guid, "Id"));
}
else if (type == UseCaseTypes.DeleteByUn)
{
InputParameters.Add(new DataParameter(DomainInputType.String, "Name"));
}
}
public void AddInputParameterAsNeeded(string parameter)
{
if (!InputParameters.Contains(parameter))
{
InputParameters.Add(parameter);
}
}
public void CreateAccountWithInactiveContactOwner()
{
// Define the Contact Owner
var contactOwner = new Entity()
{
Id = Guid.NewGuid(),
LogicalName = SystemUserDefinition.EntityName,
Attributes = { { SystemUserDefinition.Columns.IsDisabled, true } }
};
// Define the Account's Creator
var accountCreator = new Entity()
{
Id = Guid.NewGuid(),
LogicalName = SystemUserDefinition.EntityName,
Attributes = { { SystemUserDefinition.Columns.IsDisabled, false } }
};
// Define the Principal Contact
var principalContact = new Entity()
{
Id = Guid.NewGuid(),
LogicalName = ContactDefinition.EntityName,
Attributes = { { ContactDefinition.Columns.OwnerId, contactOwner.ToEntityReference() }, }
};
// Define Account
var accountEntity = new Entity()
{
Id = Guid.NewGuid(),
LogicalName = AccountDefinition.EntityName,
Attributes =
{
{ AccountDefinition.Columns.OwnerId, accountCreator.ToEntityReference() },
{ AccountDefinition.Columns.PrimaryContactId, principalContact.ToEntityReference() }
}
};
// Create the plugin context
InputParameters.Add(global::Plugins.InputParameters.Target, accountEntity);
Context.PrimaryEntityId = accountEntity.Id;
// Initialise the records so that they can be retrieved from the database
FakedContext.Initialize(new List <Entity> {
accountEntity, accountCreator, principalContact, contactOwner
});
try
{
// Execute the plugin
ExecutePlugin();
// This test should go to catch either it should raise en error
Assert.True(1 == 2);
}
catch (InvalidPluginExecutionException ex)
{
Assert.True(ex.Message == "Le propriétaire du contact principal est désactivé. Veuillez contacter votre administrateur.");
}
}
public RepositoryMethod AddInputParameter(DomainInputType type, string name, DomainInputType dictionaryKeyType, DomainInputType dictionaryValueType)
{
InputParameters.Add(new DataParameter(type, name)
{
DictionaryKeyType = dictionaryKeyType, DictionaryValueType = dictionaryValueType
});
return(this);
}
public RepositoryMethod AddInputParameter(DomainInputType type, string name, DomainInputType enumerableType)
{
InputParameters.Add(new DataParameter(type, name)
{
EnumerableType = enumerableType
});
return(this);
}
public FunctionCallInfo(FunctionCallResult call)
{
QualifiedName = new URI(call.FunctionCall.FunctionName);
foreach (var arg in call.FunctionCall.Arguments)
{
InputParameters.Add(new CallParameter(arg.StorageAreaOrValue));
}
}
public async Task <IActionResult> PreviewDashboardItem([FromBody] PreviewSharedDashboardItem previewDashboard, CancellationToken cancellationToken)
{
var remoteAgent = await _remoteAgents.GetHubReaderRemoteAgent(previewDashboard.HubKey, _operations.RepositoryManager, cancellationToken);
if (previewDashboard.RemoteAgentId != remoteAgent.InstanceId)
{
return(StatusCode(426, remoteAgent));
// throw new Exception("The remote agent did not match the current agent.");
}
var user = await _operations.RepositoryManager.GetUserAsync(User, cancellationToken, false);
var repositoryManager = _operations.RepositoryManager;
//check user can access the hub.
var canAccess = await repositoryManager.CanAccessSharedObjects(user, previewDashboard.HubKey, cancellationToken);
if (!canAccess)
{
throw new Exception($"Can not access shared objects in the hub with the key {previewDashboard.HubKey}.");
}
var dashboard = await repositoryManager.GetDashboard(previewDashboard.HubKey, previewDashboard.DashboardKey, cancellationToken);
var item = dashboard.DexihDashboardItems.SingleOrDefault(c => c.Key == previewDashboard.DashboardItemKey);
if (item == null)
{
throw new Exception($"The dashboard with the key {previewDashboard.DashboardItemKey} could not be found.");
}
var view = await repositoryManager.GetView(dashboard.HubKey, item.ViewKey, cancellationToken);
var itemParameters = new InputParameters();
foreach (var parameter in item.Parameters)
{
itemParameters.Add(parameter.Name, previewDashboard.Parameters.SetParameters(parameter.Value, parameter.Rank), parameter.Rank);
}
switch (view.SourceType)
{
case EDataObjectType.Table:
return(Ok(await _remoteAgents.PreviewTable(previewDashboard.RemoteAgentId,
previewDashboard.HubKey, previewDashboard.DownloadUrl, view.SourceTableKey.Value,
view.SelectQuery, view.GetViewConfig(), view.InputValues, itemParameters, false, false, repositoryManager,
cancellationToken)));
case EDataObjectType.Datalink:
return(Ok(await _remoteAgents.PreviewDatalink(previewDashboard.RemoteAgentId,
previewDashboard.HubKey, previewDashboard.DownloadUrl, view.SourceDatalinkKey.Value, false,
view.SelectQuery, view.GetViewConfig(), view.InputValues, itemParameters, false, repositoryManager,
cancellationToken)));
default:
throw new ArgumentOutOfRangeException();
}
}
public void CreateAccountWithactiveContactOwner()
{
// Define the Contact Owner
var contactOwner = new Entity()
{
Id = Guid.NewGuid(),
LogicalName = SystemUserDefinition.EntityName,
Attributes = { { SystemUserDefinition.Columns.IsDisabled, false } }
};
// Define the Account's Creator
var accountCreator = new Entity()
{
Id = Guid.NewGuid(),
LogicalName = SystemUserDefinition.EntityName,
Attributes = { { SystemUserDefinition.Columns.IsDisabled, false } }
};
// Define the Principal Contact
var principalContact = new Entity()
{
Id = Guid.NewGuid(),
LogicalName = ContactDefinition.EntityName,
Attributes = { { ContactDefinition.Columns.OwnerId, contactOwner.ToEntityReference() } }
};
// Define Account
var accountEnitity = new Entity()
{
Id = Guid.NewGuid(),
LogicalName = AccountDefinition.EntityName,
Attributes =
{
{ AccountDefinition.Columns.OwnerId, accountCreator.ToEntityReference() },
{ AccountDefinition.Columns.PrimaryContactId, principalContact.ToEntityReference() }
}
};
// Create the plugin context
InputParameters.Add(global::Plugins.InputParameters.Target, accountEnitity);
Context.PrimaryEntityId = accountEnitity.Id;
// Initialise the records so that they can be retrieved from the database
FakedContext.Initialize(new List <Entity> {
accountEnitity, accountCreator, principalContact, contactOwner
});
// Execute the plugin
ExecutePlugin();
var newOwnerRef = accountEnitity.GetAttributeValue <EntityReference>(AccountDefinition.Columns.OwnerId);
// Assert that the target contains a new attribute
Assert.True(newOwnerRef.Id == contactOwner.Id);
}
public async Task <IActionResult> DownloadData([FromBody] DownloadSharedData downloadSharedData, CancellationToken cancellationToken)
{
_logger.LogTrace(LoggingEvents.HubUploadFiles, "SharedDataController.DownloadData");
var remoteAgent = await _remoteAgents.GetHubReaderRemoteAgent(downloadSharedData.HubKey, _operations.RepositoryManager, cancellationToken);
if (downloadSharedData.RemoteAgentId != remoteAgent.InstanceId)
{
return(StatusCode(426, remoteAgent));
// throw new Exception("The remote agent did not match the current agent.");
}
// use a dictionary to group the download requests by hub.
var downloadData = new List <DownloadData.DownloadObject>();
foreach (var item in downloadSharedData.SharedItems)
{
var inputParameters = new InputParameters();
foreach (var parameter in item.Parameters)
{
inputParameters.Add(new InputParameter()
{
Name = parameter.Name, Value = item.ParentParameters == null ? parameter.Value : item.ParentParameters.SetParameters(parameter.Value, parameter.Rank), Rank = parameter.Rank
});
}
var downloadObject = new DownloadData.DownloadObject()
{
ObjectKey = item.ObjectKey,
ObjectType = item.ObjectType,
InputColumns = item.InputColumns,
InputParameters = inputParameters,
Query = item.Query
};
downloadData.Add(downloadObject);
}
var repositoryManager = _operations.RepositoryManager;
var responseKey = await _remoteAgents.DownloadData(downloadSharedData.RemoteAgentId, downloadSharedData.HubKey, downloadSharedData.DownloadUrl, downloadSharedData.ClientId, downloadData.ToArray(), downloadSharedData.DownloadFormat, true, downloadSharedData.ZipFiles, repositoryManager, cancellationToken);
return(Ok(responseKey));
}
private void AddInput(CKlaxVariable parameter, bool bIsNewParameter)
{
var newViewmodel = new CEntityVariableViewModel(parameter);
var functionGraph = m_functionGraph;
void Redo()
{
newViewmodel.PropertyChanged += OnParameterPropertyChanged;
functionGraph.InputParameters.Add(parameter);
InputParameters.Add(newViewmodel);
functionGraph.RebuildFunctionNodes();
}
void Undo()
{
newViewmodel.PropertyChanged -= OnParameterPropertyChanged;
InputParameters.Remove(newViewmodel);
functionGraph.InputParameters.Remove(parameter);
functionGraph.RebuildFunctionNodes();
}
newViewmodel.DeleteCommand = new CRelayCommand(arg =>
{
Undo();
UndoRedoUtility.Record(new CRelayUndoItem(Redo, Undo));
});
if (bIsNewParameter)
{
Redo();
}
else
{
newViewmodel.PropertyChanged += OnParameterPropertyChanged;
InputParameters.Add(newViewmodel);
}
if (bIsNewParameter)
{
UndoRedoUtility.Record(new CRelayUndoItem(Undo, Redo));
}
}
public void ProcessData(RepositoryMethod regardingRepositoryMethod)
{
Name = regardingRepositoryMethod.Name;
DisplayName = $"Method {SchemaName}.{RepositoryName}.{regardingRepositoryMethod.Name}";
var repositoryMethod = JsonParserService.ObjectifyWithTypes <RepositoryMethodContent>
(regardingRepositoryMethod.Content);
foreach (var item in repositoryMethod.Parameters
.Where(k => k.Direction == Methods.MethodParameter.ParameterDirection.Input))
{
InputParameters.Add(item);
}
foreach (var item in repositoryMethod.Parameters
.Where(k => k.Direction == Methods.MethodParameter.ParameterDirection.Output))
{
OutputParameters.Add(item);
}
}
private void AddInput(CKlaxVariable parameter, bool bIsNewParameter)
{
var newViewmodel = new CEntityVariableViewModel(parameter);
void Redo()
{
m_interfaceFunction.InputParameters.Add(parameter);
InputParameters.Add(newViewmodel);
}
void Undo()
{
InputParameters.Remove(newViewmodel);
m_interfaceFunction.InputParameters.Remove(parameter);
}
newViewmodel.DeleteCommand = new CRelayCommand(arg =>
{
Undo();
UndoRedoUtility.Record(new CRelayUndoItem(Redo, Undo));
});
if (bIsNewParameter)
{
Redo();
}
else
{
InputParameters.Add(newViewmodel);
}
if (bIsNewParameter)
{
UndoRedoUtility.Record(new CRelayUndoItem(Undo, Redo));
}
}
public RepositoryMethod AddInputParameter(DomainInputType type, string name)
{
InputParameters.Add(new DataParameter(type, name));
return(this);
}
public async Task <IActionResult> PreviewData([FromBody] PreviewData previewData, CancellationToken cancellationToken)
{
var remoteAgent = await _remoteAgents.GetHubReaderRemoteAgent(previewData.HubKey, _operations.RepositoryManager, cancellationToken);
if (previewData.RemoteAgentId != remoteAgent.InstanceId)
{
// this status code is used by the client to attempt to look for a refreshed remote agent.
return(StatusCode(426, remoteAgent));
// throw new Exception("The remote agent did not match the current agent.");
}
var user = await _operations.RepositoryManager.GetUserAsync(User, cancellationToken, false);
var repositoryManager = _operations.RepositoryManager;
//check user can access the hub.
var canAccess = await repositoryManager.CanAccessSharedObjects(user, previewData.HubKey, cancellationToken);
if (!canAccess)
{
throw new Exception($"Can not access shared objects in the hub with the key {previewData.HubKey}.");
}
InputParameters itemParameters;
if (previewData.ParentParameters == null)
{
itemParameters = previewData.Parameters;
}
else
{
itemParameters = new InputParameters();
foreach (var parameter in previewData.Parameters)
{
itemParameters.Add(parameter.Name, previewData.ParentParameters.SetParameters(parameter.Value, parameter.Rank), parameter.Rank);
}
}
string data;
switch (previewData.ObjectType)
{
case EDataObjectType.Table:
data = await _remoteAgents.PreviewTable(previewData.RemoteAgentId, previewData.HubKey, previewData.DownloadUrl, previewData.ObjectKey, previewData.SelectQuery, null, previewData.InputColumns, itemParameters, false, true, repositoryManager, cancellationToken);
break;
case EDataObjectType.Datalink:
data = await _remoteAgents.PreviewDatalink(previewData.RemoteAgentId, previewData.HubKey, previewData.DownloadUrl, previewData.ObjectKey, false, previewData.SelectQuery, null, previewData.InputColumns, itemParameters, true, repositoryManager, cancellationToken);
break;
case EDataObjectType.View:
case EDataObjectType.DashboardItem:
DexihView view;
if (previewData.ObjectType == EDataObjectType.DashboardItem)
{
view = await repositoryManager.GetDashboardItemView(previewData.HubKey, previewData.ObjectKey,
true, cancellationToken);
}
else
{
view = await repositoryManager.GetView(previewData.HubKey, previewData.ObjectKey, cancellationToken);
if (!view.IsShared)
{
throw new Exception($"The view {view.Name} is not shared.");
}
}
var selectQuery = view.SelectQuery ?? new SelectQuery();
// selectQuery.Rows = previewData.SelectQuery.Rows;
switch (view.SourceType)
{
case EDataObjectType.Table:
data = await _remoteAgents.PreviewTable(previewData.RemoteAgentId, previewData.HubKey, previewData.DownloadUrl, view.SourceTableKey.Value, selectQuery, view.GetViewConfig(), previewData.InputColumns, itemParameters, false, false, repositoryManager, cancellationToken);
break;
case EDataObjectType.Datalink:
data = await _remoteAgents.PreviewDatalink(previewData.RemoteAgentId, previewData.HubKey, previewData.DownloadUrl, view.SourceDatalinkKey.Value, false, selectQuery, view.GetViewConfig(), previewData.InputColumns, itemParameters, false, repositoryManager, cancellationToken);
break;
default:
throw new ArgumentOutOfRangeException();
}
break;
default:
throw new ArgumentOutOfRangeException();
}
_logger.LogTrace(LoggingEvents.HubPreviewTable, "SharedDataController.PreviewData: HubKey: {updateBrowserHub}, ObjectKey: {objectKey}", previewData.HubKey, previewData.ObjectKey);
return(Ok(data));
}
public async Task <bool> Run(CancellationToken cancellationToken)
{
try
{
cancellationToken.ThrowIfCancellationRequested();
WriterResult.StartTime = DateTime.Now;
WriterResult.LastUpdateTime = DateTime.Now;
var runStatus = WriterResult.SetRunStatus(ERunStatus.Started, null, null);
if (!runStatus)
{
throw new DatajobRunException($"Failed to set status");
}
if (_transformWriterOptions.TargetAction == TransformWriterOptions.ETargetAction.Truncate)
{
runStatus = WriterResult.SetRunStatus(ERunStatus.Started, "Truncating tables...", null);
var targetTables = new HashSet <DexihTable>();
foreach (var step in Datajob.DexihDatalinkSteps.Where(c => c.IsValid))
{
var datalink = _hub.DexihDatalinks.SingleOrDefault(c => c.IsValid && c.Key == step.DatalinkKey);
if (datalink == null)
{
throw new DatajobRunException($"The datalink in the step {step.Name} with the datalink key {step.DatalinkKey} cound not be found.");
}
foreach (var target in datalink.DexihDatalinkTargets)
{
if (target.TableKey > 0)
{
var table = _hub.GetTableFromKey(target.TableKey);
if (table != null)
{
targetTables.Add(table);
}
}
}
}
// this loops through attempting to truncate tables one by one.
// is repeats when there are failures to accomodate for some table having foriegn keys
var atLeastOneSuccess = true;
var atLeastOneFail = true;
while (atLeastOneSuccess && atLeastOneFail)
{
atLeastOneSuccess = false;
atLeastOneFail = false;
var newTagetTables = new HashSet <DexihTable>();
foreach (var dbTable in targetTables)
{
var dbConnection = _hub.DexihConnections.SingleOrDefault(c => c.Key == dbTable.ConnectionKey);
if (dbConnection == null)
{
throw new DatajobRunException($"The connection for the table {dbTable.Name} with the connection key {dbTable.ConnectionKey} could not be found.");
}
var connection = dbConnection.GetConnection(_transformSettings);
var table = dbTable.GetTable(_hub, connection, _transformSettings);
try
{
await connection.TruncateTable(table, cancellationToken);
atLeastOneSuccess = true;
}
catch
{
atLeastOneFail = true;
newTagetTables.Add(dbTable);
}
}
targetTables = newTagetTables;
}
if (targetTables.Count > 0)
{
var message = $"The job failed as the following tables could not be truncated: {string.Join(", ", targetTables.Select(c => c.Name))}";
WriterResult.SetRunStatus(ERunStatus.Abended, message, null);
return(false);
}
}
var inputParameters = new InputParameters();
foreach (var parameter in Datajob.Parameters)
{
inputParameters.Add(new InputParameter()
{
Name = parameter.Name, Value = parameter.Value, Rank = parameter.Rank
});
}
//start all jobs async
foreach (var step in Datajob.DexihDatalinkSteps.Where(c => c.IsValid))
{
var datalink = _hub.DexihDatalinks.SingleOrDefault(c => c.IsValid && c.Key == step.DatalinkKey);
if (datalink == null)
{
throw new DatajobRunException($"The step {step.Name} contains a datalink with the key {step.DatalinkKey} which can not be found.");
}
foreach (var parameter in step.Parameters)
{
parameter.Value = inputParameters.SetParameters(parameter.Value, parameter.Rank);
}
var transformSettings = new TransformSettings
{
HubVariables = _transformSettings.HubVariables,
RemoteSettings = _transformSettings.RemoteSettings,
InputParameters = step.Parameters.ToArray <InputParameterBase>(),
ClientFactory = _transformSettings.ClientFactory
};
var inputColumns = step.DexihDatalinkStepColumns.Select(c => c.ToInputColumn()).ToArray();
var datalinkRun = new DatalinkRun(transformSettings, _logger, WriterResult.AuditKey, datalink, _hub, inputColumns, _transformWriterOptions, _alertQueue, _alertEmails)
{
DatalinkStepKey = step.Key
};
DatalinkSteps.Add(datalinkRun);
//start datalinks that have no dependencies.
if (step.DexihDatalinkDependencies == null || step.DexihDatalinkDependencies.Count == 0)
{
StartDatalink(datalinkRun);
}
}
WriterResult.SetRunStatus(ERunStatus.Running, null, null);
await WaitUntilFinished();
return(true);
}
catch (OperationCanceledException)
{
Cancel();
await WaitUntilFinished();
WriterResult.SetRunStatus(ERunStatus.Cancelled, "Datajob was cancelled", null);
throw new DatajobRunException($"The datajob {Datajob.Name} was cancelled.");
}
catch (Exception ex)
{
Cancel();
await WaitUntilFinished();
var message = $"The job {Datajob.Name} failed. {ex.Message}";
WriterResult?.SetRunStatus(ERunStatus.Abended, message, ex);
throw new DatajobRunException(message, ex);
}
finally
{
await WriterResult.CompleteDatabaseWrites();
OnFinish?.Invoke(this);
}
}
public void LoadConfiguration(GP.MetaData.GPMetaData serviceInfo, Uri taskEndPoint)
{
if (serviceInfo == null)
{
return;
}
TaskEndPoint = taskEndPoint;
TaskName = Title = serviceInfo.DisplayName;
HelpUrl = serviceInfo.HelpUrl;
if (InputParameters == null)
{
InputParameters = new List <ParameterSupport.ParameterConfig>();
}
else
{
InputParameters.Clear();
}
if (OutputParameters == null)
{
OutputParameters = new List <ParameterSupport.ParameterConfig>();
}
else
{
OutputParameters.Clear();
}
if (LayerOrder == null)
{
LayerOrder = new ObservableCollection <string>();
}
else
{
LayerOrder.Clear();
}
Collection <LayerInformation> resultMapserviceLayerInfos = string.IsNullOrEmpty(serviceInfo.ResultMapServerName) || string.IsNullOrEmpty(serviceInfo.CurrentVersion) ? null : new Collection <LayerInformation>();
#region Get parameter configs
if (serviceInfo.Parameters != null)
{
int layerId = 0;
foreach (ESRI.ArcGIS.Mapping.GP.MetaData.GPParameter param in serviceInfo.Parameters)
{
ParameterConfig config = null;
if (param.DataType == "GPFeatureRecordSetLayer")
{
if (!string.IsNullOrEmpty(serviceInfo.ResultMapServerName) && param.Direction != "esriGPParameterDirectionInput")
{
if (!string.IsNullOrEmpty(serviceInfo.CurrentVersion)) // A resultmapservice can only be accessed at http://.../<resultMapservice>/MapServer/jobs/<jobId> when server version can be determined.
{
resultMapserviceLayerInfos.Add(ToLayerInfo(param, layerId++));
}
else
{
MapServiceLayerParameterConfig layerConfig = new MapServiceLayerParameterConfig
{
Name = param.Name,
LayerName = param.DisplayName,
Type = GPParameterType.MapServiceLayer,
SupportsJobResource = false,
Opacity = 1,
};
OutputParameters.Add(layerConfig);
LayerOrder.Add(layerConfig.Name);
}
}
else
{
#region No result GP mapserver
GP.ParameterSupport.FeatureLayerParameterConfig layerConfig = new ParameterSupport.FeatureLayerParameterConfig()
{
ShownAtRunTime = true
};
layerConfig.Name = param.Name;
layerConfig.Label = layerConfig.DisplayName = string.IsNullOrEmpty(param.DisplayName) ? param.Name : param.DisplayName;
layerConfig.Mode = ParameterSupport.FeatureLayerParameterConfig.InputMode.SketchLayer;
layerConfig.Type = GPParameterType.FeatureLayer;
layerConfig.Required = param.ParameterType == "esriGPParameterTypeRequired";
ESRI.ArcGIS.Mapping.GP.MetaData.GPFeatureRecordSetLayer frs = param.DefaultValue as ESRI.ArcGIS.Mapping.GP.MetaData.GPFeatureRecordSetLayer;
if (frs != null)
{
if (frs.GeometryType == "esriGeometryPolyline")
{
layerConfig.GeometryType = ESRI.ArcGIS.Mapping.Core.GeometryType.Polyline;
layerConfig.HelpText = Resources.Strings.DrawLine;
}
else if (frs.GeometryType == "esriGeometryPolygon")
{
layerConfig.GeometryType = ESRI.ArcGIS.Mapping.Core.GeometryType.Polygon;
layerConfig.HelpText = Resources.Strings.DrawPolygon;
}
else if (frs.GeometryType == "esriGeometryPoint")
{
layerConfig.GeometryType = ESRI.ArcGIS.Mapping.Core.GeometryType.Point;
layerConfig.HelpText = Resources.Strings.DrawPoint;
}
else if (frs.GeometryType == "esriGeometryMultipoint")
{
layerConfig.GeometryType = ESRI.ArcGIS.Mapping.Core.GeometryType.MultiPoint;
layerConfig.HelpText = Resources.Strings.DrawPoint;
}
#region Layer with field info, geometry type and renderer
GraphicsLayer layer = new GraphicsLayer();
if (frs.Fields != null && frs.Fields.Length > 0)
{
Collection <ESRI.ArcGIS.Mapping.Core.FieldInfo> fields = new Collection <ESRI.ArcGIS.Mapping.Core.FieldInfo>();
List <string> doubleFields = new List <string>();
List <string> singleFields = new List <string>();
foreach (MetaData.Field field in frs.Fields)
{
#region Get Single and Double Fields
string type = field.Type;
if (type.StartsWith(GPConfiguration.esriFieldType, StringComparison.Ordinal))
{
type = type.Substring(GPConfiguration.esriFieldType.Length);
ESRI.ArcGIS.Client.Field.FieldType fieldType =
(ESRI.ArcGIS.Client.Field.FieldType)Enum.Parse(typeof(ESRI.ArcGIS.Client.Field.FieldType), type, true);
if (fieldType == ESRI.ArcGIS.Client.Field.FieldType.Double)
{
doubleFields.Add(field.Name);
}
else if (fieldType == Client.Field.FieldType.Single)
{
singleFields.Add(field.Name);
}
}
#endregion
#region Get FieldInfos
if (field.Type == "esriGeometry")
{
continue;
}
fields.Add(new ESRI.ArcGIS.Mapping.Core.FieldInfo()
{
DisplayName = field.Alias,
FieldType = mapFieldType(field.Type),
Name = field.Name,
VisibleInAttributeDisplay = true,
VisibleOnMapTip = true,
});
#endregion
}
ESRI.ArcGIS.Mapping.Core.LayerExtensions.SetFields(layer, fields);
layerConfig.SingleFields = singleFields.ToArray();
layerConfig.DoubleFields = doubleFields.ToArray();
}
ESRI.ArcGIS.Mapping.Core.LayerExtensions.SetGeometryType(layer, layerConfig.GeometryType);
layer.Renderer = FeatureLayerParameterConfig.GetSimpleRenderer(layerConfig.GeometryType);
// Disable pop-ups by default for input layers
if (param.Direction == "esriGPParameterDirectionInput")
{
LayerProperties.SetIsPopupEnabled(layer, false);
}
layerConfig.Layer = layer;
#endregion
}
else
{
layerConfig.GeometryType = ESRI.ArcGIS.Mapping.Core.GeometryType.Unknown;
layerConfig.HelpText = Resources.Strings.UnknownGeometryType;
}
layerConfig.LayerName = layerConfig.Label;
layerConfig.ToolTip = layerConfig.HelpText;
layerConfig.Opacity = 1;
config = layerConfig;
LayerOrder.Add(layerConfig.Name);
#endregion
}
}
else if (param.DataType == "GPRasterDataLayer" || param.DataType == "GPRasterData")
{
if (string.IsNullOrEmpty(serviceInfo.ResultMapServerName) || param.Direction == "esriGPParameterDirectionInput")
{
config = new RasterDataParameterConfig()
{
Name = param.Name,
ShownAtRunTime = true,
FormatToolTip = "e.g. tif, jpg",
Type = param.DataType == "GPRasterDataLayer" ? GPParameterType.RasterDataLayer : GPParameterType.RasterData,
ToolTip = param.DataType == "GPRasterDataLayer" ? Resources.Strings.EnterUrlForRasterDataLayer : Resources.Strings.EnterUrlForRasterData,
HelpText = param.DataType == "GPRasterDataLayer" ? Resources.Strings.EnterUrlForRasterDataLayer : Resources.Strings.EnterUrlForRasterData,
Label = param.DisplayName,
DisplayName = param.DisplayName,
Required = param.ParameterType == "esriGPParameterTypeRequired",
Input = param.Direction == "esriGPParameterDirectionInput"
};
}
else if (string.IsNullOrEmpty(serviceInfo.CurrentVersion))
{
MapServiceLayerParameterConfig layerConfig = new MapServiceLayerParameterConfig
{
Name = param.Name,
LayerName = param.DisplayName,
Type = GPParameterType.MapServiceLayer,
SupportsJobResource = false,
Opacity = 1,
};
OutputParameters.Add(layerConfig);
LayerOrder.Add(layerConfig.Name);
}
else
{
resultMapserviceLayerInfos.Add(ToLayerInfo(param, layerId++));
}
}
else
{
#region other param types
if (param.DataType == "GPMultiValue:GPString")
{
config = new MultiValueStringConfig()
{
ShownAtRunTime = true
}
}
;
else
{
config = new ParameterConfig()
{
ShownAtRunTime = true
}
};
config.Name = param.Name;
config.Label = config.DisplayName = param.DisplayName;
config.Required = param.ParameterType == "esriGPParameterTypeRequired";
string defaultString = param.DefaultValue == null ? null : param.DefaultValue.ToString();
switch (param.DataType)
{
#region
case "GPBoolean":
config.Type = GPParameterType.Boolean;
if (param.DefaultValue != null)
{
config.DefaultValue = new Client.Tasks.GPBoolean(param.Name, (bool)param.DefaultValue);
}
break;
case "GPDouble":
config.Type = GPParameterType.Double;
if (!string.IsNullOrEmpty(defaultString))
{
double val = 0;
if (double.TryParse(defaultString, System.Globalization.NumberStyles.Any, CultureHelper.GetCurrentCulture(), out val))
{
config.DefaultValue = new Client.Tasks.GPDouble(param.Name, val);
}
}
break;
case "GPLong":
config.Type = GPParameterType.Long;
if (!string.IsNullOrEmpty(defaultString))
{
int val = 0;
if (int.TryParse(defaultString, out val))
{
config.DefaultValue = new ESRI.ArcGIS.Client.Tasks.GPLong(param.Name, val);
}
}
break;
case "GPDate":
config.Type = GPParameterType.Date;
if (!string.IsNullOrEmpty(defaultString))
{
long ticks = 0;
if (long.TryParse(defaultString, out ticks))
{
config.DefaultValue = new ESRI.ArcGIS.Client.Tasks.GPDate(param.Name, Epoch.AddMilliseconds(ticks));
}
}
break;
case "GPLinearUnit":
config.Type = GPParameterType.LinearUnit;
if (param.DefaultValue is ESRI.ArcGIS.Mapping.GP.MetaData.GPLinearUnit)
{
ESRI.ArcGIS.Mapping.GP.MetaData.GPLinearUnit value = (param.DefaultValue as ESRI.ArcGIS.Mapping.GP.MetaData.GPLinearUnit);
config.DefaultValue = new ESRI.ArcGIS.Client.Tasks.GPLinearUnit(param.Name,
(ESRI.ArcGIS.Client.Tasks.esriUnits)(Enum.Parse(typeof(ESRI.ArcGIS.Client.Tasks.esriUnits), value.Units, true)),
value.Distance);
}
break;
case "GPString":
config.Type = GPParameterType.String;
config.DefaultValue = new ESRI.ArcGIS.Client.Tasks.GPString(param.Name, defaultString);
if (param.ChoiceList != null && param.ChoiceList.Length > 0)
{
config.ChoiceList = new List <Choice>(param.ChoiceList.Length);
for (int i = 0; i < param.ChoiceList.Length; i++)
{
config.ChoiceList.Add(new Choice()
{
DisplayText = param.ChoiceList[i],
Value =
new ESRI.ArcGIS.Client.Tasks.GPString(param.Name, param.ChoiceList[i])
});
}
}
break;
case "GPMultiValue:GPString":
config.Type = GPParameterType.MultiValueString;
object[] defaultStrings = param.DefaultValue as object[];
// the default value could be an array of strings
if (defaultStrings != null && defaultStrings.Length > 0)
{
List <GPString> list =
(from string s in defaultStrings select new GPString(param.Name, s)).ToList();
config.DefaultValue = new GPMultiValue <GPString>(param.Name, list);
}
if (param.ChoiceList != null && param.ChoiceList.Length > 0)
{
config.ChoiceList = new List <Choice>(param.ChoiceList.Length);
foreach (string t in param.ChoiceList)
{
config.ChoiceList.Add(new Choice
{
DisplayText = t,
Value = new GPString(param.Name, t)
});
}
}
break;
case "GPRecordSet":
config.Type = GPParameterType.RecordSet;
config.ToolTip = config.HelpText = Resources.Strings.EnterUrlForRecordset;
break;
case "GPDataFile":
config.Type = GPParameterType.DataFile;
config.ToolTip = config.HelpText = Resources.Strings.EnterUrlForFile;
break;
default:
break;
#endregion
}
#endregion
}
if (config != null)
{
if (param.Direction == "esriGPParameterDirectionInput")
{
config.Input = true;
InputParameters.Add(config);
}
else
{
config.Input = false;
OutputParameters.Add(config);
}
}
}
}
if (!string.IsNullOrEmpty(serviceInfo.ResultMapServerName) && !string.IsNullOrEmpty(serviceInfo.CurrentVersion))
{
MapServiceLayerParameterConfig layerConfig = new MapServiceLayerParameterConfig
{
Name = serviceInfo.ResultMapServerName,
LayerName = serviceInfo.ResultMapServerName,
Type = GPParameterType.MapServiceLayer,
LayerInfos = resultMapserviceLayerInfos,
SupportsJobResource = true,
Opacity = 1,
};
OutputParameters.Add(layerConfig);
LayerOrder.Add(layerConfig.Name);
}
#endregion
}
/// <summary>
/// Añade un parámetro de entrada al script
/// </summary>
public void AddParameter(string key, object value)
{
InputParameters.Add(key, value);
}
