/// <summary>
/// Gets the source assigned to the specified field.
/// </summary>
/// <param name="parameters">Source parameters.</param>
/// <returns></returns>
public async Task <DataResult> GetDataSourceAsync(SourceParameters parameters)
{
DataResult result = new DataResult();
try
{
var fieldDefinitions = await(from fd in base.GetFieldDefinitions(parameters)
from s in fd.FieldListSources
where fd.ItemName == parameters.FieldItemName && fd.FieldType != EFieldType.TableReference && s.ExecutionSource.ExecutionType == EExecutionType.ALex
select new
{
s.ExecutionSource.ExecutionText,
fd.FieldType,
TableItemName = s.TableDefinition.ItemName,
ConnectionName = s.ExecutionSource.TableConfiguration.ConnectionString
}).FirstAsync();
var queryFactory = this.Context.QueryBuilderOptions.ConnectionsPool[fieldDefinitions.ConnectionName];
// Creates the query.
var parser = new ParserFull(queryFactory);
// Parses the select query.
var selectQuery = parser.ParseToQuery(fieldDefinitions.ExecutionText, parameters.AdditionalParameters);
result.Result = await selectQuery.GetAsync();
}
catch (ALexException ex)
{
result = base.GetResultFromException <DataResult>(ex, 3002);
}
return(result);
}
protected override Expression VisitParameter(ParameterExpression node)
{
if (SourceParameters.Contains(node))
{
return(ReplaceNode(node));
}
return(SourceParameters.FirstOrDefault(p => p.Name == node.Name) ?? node);
}
/// <summary>
/// Gets the table source in case the table have a table definiton as source.
/// </summary>
/// <param name="sourceParameters">The source parameters.</param>
/// <param name="dataParameters">The data parameters.</param>
/// <returns></returns>
public async Task <GridResult> GetTableSourceAsync(SourceParameters sourceParameters, DataParameters dataParameters)
{
GridResult result;
try
{
// Gets the aditional statements.
var additionalFilters = await(from fd in base.GetFieldDefinitions(sourceParameters)
from s in fd.FieldListSources
where fd.ItemName == sourceParameters.FieldItemName && fd.FieldType == EFieldType.TableReference && s.ExecutionSource.ExecutionType == EExecutionType.ALex
select s.ExecutionSource.ExecutionText).ToListAsync();
// If not configured it will return an error result.
if (additionalFilters.Count == 0)
{
throw new ALexException("A relationship between '" + sourceParameters.ItemName + "." + sourceParameters.FieldItemName + "' has not been set in the configurations.", 304);
}
if (sourceParameters.AdditionalParameters != null)
{
if (dataParameters.AdditionalParameters == null)
{
dataParameters.AdditionalParameters = sourceParameters.AdditionalParameters;
}
else
{
// Copies the data from source parameters into the data parameters if it's not present.
foreach (KeyValuePair <string, object> key in sourceParameters.AdditionalParameters)
{
if (!dataParameters.AdditionalParameters.ContainsKey(key.Key))
{
dataParameters.AdditionalParameters.Add(key.Key, key.Value);
}
else
{
// If there is a different value it will be overriden.
dataParameters.AdditionalParameters[key.Key] = key.Value;
}
}
}
}
result = await this.GetDataAsync(dataParameters, additionalFilters);
}
catch (ALexException ex)
{
result = base.GetResultFromException <GridResult>(ex, 3003);
}
return(result);
}
public async Task GetSourceTest()
{
Client client = new Client(_apiKey);
var parameters = new SourceParameters
{
Id = 1
};
var result = await client.GetSource(parameters);
Assert.AreNotEqual(null, result);
Assert.AreEqual(result.Name, "Board of Governors of the Federal Reserve System (US)");
}
public override void GetTableReference()
{
var dataParameters = base.GetDataParameters("BasicColumnType", EQueryType.GridView, 10, 1);
var sourceParameters = new SourceParameters()
{
FieldItemName = "RecordsGrid",
ItemName = "MultiSelectSamplesView",
QueryType = EQueryType.EditView,
AdditionalParameters = new System.Collections.Generic.Dictionary <string, object>()
{
{ "MultiSelectSampleId", 1 }
},
};
var result = base.Execute(() => SchemaData.GetTableSourceAsync(sourceParameters, dataParameters).Result, (t) => this.GetResultString(t), this.GetType());
}
/// <summary>
/// Asyncronous method that validate the source parameter
/// </summary>
/// <param name="parameters"></param>
/// <returns>Returns a dictionary populated with the source parameter</returns>
public static List <KeyValuePair <string, string> > verifySingleSource(SourceParameters parameters)
{
var key = "";
var value = "";
if (!String.IsNullOrEmpty(parameters.Text))
{
key = "text";
value = $"{parameters.Text}";
}
if (!String.IsNullOrEmpty(parameters.Url) && Uri.IsWellFormedUriString(parameters.Url, UriKind.Absolute))
{
if (!String.IsNullOrEmpty(value))
{
throw new ArgumentException(ErrorMessages.MultipleSources, ErrorMessages.Url);
}
key = "url";
value = $"{parameters.Url}";
}
if (!String.IsNullOrEmpty(parameters.Html))
{
if (!String.IsNullOrEmpty(value))
{
throw new ArgumentException(ErrorMessages.MultipleSources, ErrorMessages.Html);
}
key = "html";
value = $"{parameters.Html}";
}
if (!String.IsNullOrEmpty(parameters.HtmlFragment))
{
if (!String.IsNullOrEmpty(value))
{
throw new ArgumentException(ErrorMessages.MultipleSources, ErrorMessages.HtmlFragment);
}
key = "html_fragment";
value = $"{parameters.HtmlFragment}";
}
if (String.IsNullOrEmpty(key) || String.IsNullOrEmpty(value))
{
throw new ArgumentException(ErrorMessages.WrongSource);
}
var source = new List <KeyValuePair <string, string> >();
source.Add(new KeyValuePair <string, string>(key, value));
return(source);
}
public override void GetSource()
{
var parameters = new SourceParameters()
{
FieldItemName = "CheckboxSelection",
ItemName = base.ItemName,
QueryType = EQueryType.EditView,
AdditionalParameters = new System.Collections.Generic.Dictionary <string, object>()
{
{ "MultiSelectSampleId", 1 }
},
};
var result = base.Execute(() => SchemaData.GetDataSourceAsync(parameters).Result, (t) => this.GetResultString(t), this.GetType());
Assert.True(result.Result.Count > 0);
Assert.True(result.Result[0].Value != 0);
}
SourceParameters DeduceSourceParameters()
{
var result = new SourceParameters();
switch (_source)
{
case MaskSource.Graphic:
if (_graphic is Image)
{
result.image = (Image)_graphic;
result.sprite = result.image.sprite;
result.spriteBorderMode = ToBorderMode(result.image.type);
result.texture = result.sprite ? result.sprite.texture : null;
}
else if (_graphic is RawImage)
{
var rawImage = (RawImage)_graphic;
result.texture = rawImage.texture as Texture2D;
result.textureUVRect = rawImage.uvRect;
}
break;
case MaskSource.Sprite:
result.sprite = _sprite;
result.spriteBorderMode = _spriteBorderMode;
result.texture = result.sprite ? result.sprite.texture : null; // TODO make SourceParameters immutable and expose specific ctors?
break;
case MaskSource.Texture:
result.texture = _texture;
result.textureUVRect = _textureUVRect;
break;
default:
Debug.LogErrorFormat(this, "Unknown MaskSource: {0}", _source);
break;
}
return(result);
}
/// <summary>
/// Get the NFT data for the NFT
/// </summary>
/// <param name="address">Address of the sender</param>
/// <param name="key">Private key of the sender for encryption</param>
/// <param name="receiver">receiver of the NFT</param>
/// <returns></returns>
public override async Task <IDictionary <string, string> > GetMetadata(string address = "", string key = "", string receiver = "")
{
// create token metadata
var metadata = await GetCommonMetadata();
if (!string.IsNullOrEmpty(DeviceName))
{
metadata.Add("DeviceName", DeviceName);
}
if (!string.IsNullOrEmpty(DetectorName))
{
metadata.Add("DetectorName", DetectorName);
}
if (!string.IsNullOrEmpty(SourceName))
{
metadata.Add("SourceName", SourceName);
}
if (!string.IsNullOrEmpty(PositionerName))
{
metadata.Add("PositionerName", PositionerName);
}
if (!SourceParameters.IsDefault())
{
metadata.Add("SrcPos", JsonConvert.SerializeObject(SourceParameters));
}
if (!DetectorParameters.IsDefault())
{
metadata.Add("DetPar", JsonConvert.SerializeObject(DetectorParameters));
}
if (!PositionerParameters.IsDefault())
{
metadata.Add("PosPar", JsonConvert.SerializeObject(PositionerParameters));
}
return(metadata);
}
public void Should_ThrowException_When_CallVerifySingleSourceWithWrongParameters(SourceParameters parameters, string message, string wrongParameter)
{
//Act & Assert
ArgumentException ex = Assert.Throws <ArgumentException>(() => SourceValidationService.verifySingleSource(parameters));
if (String.IsNullOrEmpty(wrongParameter))
{
Assert.Equal(message, ex.Message);
}
else
{
Assert.Equal($"{message}{Environment.NewLine}Parameter name: {wrongParameter}", ex.Message);
}
}
