public ISecurableObject GetSecurableObject(WxeFunction function)
{
ArgumentUtility.CheckNotNullAndType("function", function, _functionType);
WxeParameterDeclaration parameterDeclaration = GetParameterDeclaration(function.VariablesContainer.ParameterDeclarations);
var tuple = GetActualParameterTypeAndValue(parameterDeclaration.Type, function.Variables[parameterDeclaration.Name]);
var actualParameterType = tuple.Item1;
var parameterValue = tuple.Item2;
if (parameterValue == null)
{
throw new WxeException(string.Format(
"The parameter '{1}' specified by the {0} applied to WxeFunction '{2}' is null.",
_attribute.GetType().Name, parameterDeclaration.Name, _functionType.FullName));
}
ISecurableObject securableObject = parameterValue as ISecurableObject;
if (securableObject == null)
{
throw new WxeException(string.Format(
"The parameter '{1}' specified by the {0} applied to WxeFunction '{2}' does not implement interface '{3}'.",
_attribute.GetType().Name, parameterDeclaration.Name, _functionType.FullName, typeof(ISecurableObject).FullName));
}
if (SecurableClass != null)
{
CheckParameterDeclarationMatchesSecurableClass(actualParameterType, parameterDeclaration.Name);
}
return(securableObject);
}
/// <summary> Initalizes parameters by name. </summary>
/// <param name="parameters">
/// The list of parameter. Must contain an entry for each required parameter. Must not be <see langword="null"/>.
/// </param>
public void InitializeParameters(NameValueCollection parameters)
{
ArgumentUtility.CheckNotNull("parameters", parameters);
CheckParametersNotInitialized();
for (int i = 0; i < _parameterDeclarations.Length; ++i)
{
WxeParameterDeclaration paramDeclaration = _parameterDeclarations[i];
string strval = parameters[paramDeclaration.Name];
if (strval != null)
{
try
{
_variables[paramDeclaration.Name] =
s_typeConversionProvider.Convert(null, CultureInfo.InvariantCulture, typeof(string), paramDeclaration.Type, strval);
}
catch (Exception e)
{
throw new ApplicationException("Parameter " + paramDeclaration.Name + ": " + e.Message, e);
}
}
else if (paramDeclaration.Required)
{
throw new ApplicationException("Parameter '" + paramDeclaration.Name + "' is missing.");
}
}
_parametersInitialized = true; // since parameterString may not contain variable references, initialization is done right away
}
public void DeserializeObjectID()
{
var objectID = GetObjectID();
var parameterDeclaration = new WxeParameterDeclaration("name", true, WxeParameterDirection.In, typeof(ObjectID));
var function = new TestFunction(parameterDeclaration, null);
function.VariablesContainer.InitializeParameters(new NameValueCollection {
{ "name", objectID.ToString() }
});
Assert.That(function.Variables["name"], Is.EqualTo(objectID));
}
public virtual void SetUp()
{
_requiredObjectInParameter = new WxeParameterDeclaration(c_param, true, WxeParameterDirection.In, typeof(object));
_requiredStringInParameter = new WxeParameterDeclaration(c_param, true, WxeParameterDirection.In, typeof(string));
_requiredInt32InParameter = new WxeParameterDeclaration(c_param, true, WxeParameterDirection.In, typeof(Int32));
_requiredNaInt32InParameter = new WxeParameterDeclaration(c_param, true, WxeParameterDirection.In, typeof(Int32?));
_requiredOutParameter = new WxeParameterDeclaration(c_param, true, WxeParameterDirection.Out, typeof(string));
_stringInParameter = new WxeParameterDeclaration(c_param, false, WxeParameterDirection.In, typeof(string));
_int32InParameter = new WxeParameterDeclaration(c_param, false, WxeParameterDirection.In, typeof(Int32));
_callerParameters = new NameObjectCollection();
}
public void SerializeObjectID()
{
var objectID = GetObjectID();
var parameterDeclaration = new WxeParameterDeclaration("name", true, WxeParameterDirection.In, typeof(ObjectID));
var function = new TestFunction(parameterDeclaration, objectID);
function.VariablesContainer.EnsureParametersInitialized(null);
var queryString = function.VariablesContainer.SerializeParametersForQueryString();
Assert.That(queryString, Is.EqualTo(new NameValueCollection {
{ "name", objectID.ToString() }
}));
}
public void SerializeAndDeserializeObjectID()
{
var objectID = GetObjectID();
var parameterDeclaration = new WxeParameterDeclaration("name", true, WxeParameterDirection.In, typeof(ObjectID));
var function = new TestFunction(parameterDeclaration, objectID);
function.VariablesContainer.EnsureParametersInitialized(null);
var queryString = function.VariablesContainer.SerializeParametersForQueryString();
Assert.That(queryString.Count, Is.EqualTo(1));
var deserializedfunction = new TestFunction(parameterDeclaration, null);
deserializedfunction.VariablesContainer.InitializeParameters(queryString);
Assert.That(function.Variables["name"], Is.EqualTo(objectID));
}
public void DeserializeIDomainObjectHandle()
{
var objectID = GetObjectID();
var parameterDeclaration = new WxeParameterDeclaration(
"name",
true,
WxeParameterDirection.In,
typeof(IDomainObjectHandle <SampleObject>));
var function = new TestFunction(parameterDeclaration, null);
function.VariablesContainer.InitializeParameters(new NameValueCollection {
{ "name", objectID.ToString() }
});
Assert.That(function.Variables["name"], Is.InstanceOf <IDomainObjectHandle <SampleObject> > ());
Assert.That(((IDomainObjectHandle <SampleObject>)function.Variables["name"]).ObjectID, Is.EqualTo(objectID));
}
public void SerializeAndDeserializeIDomainObjectHandle()
{
var objectID = GetObjectID();
var domainObjectHandle = objectID.GetHandle <SampleObject>();
var parameterDeclaration = new WxeParameterDeclaration(
"name",
true,
WxeParameterDirection.In,
typeof(IDomainObjectHandle <SampleObject>));
var function = new TestFunction(parameterDeclaration, domainObjectHandle);
function.VariablesContainer.EnsureParametersInitialized(null);
var queryString = function.VariablesContainer.SerializeParametersForQueryString();
Assert.That(queryString.Count, Is.EqualTo(1));
var deserializedfunction = new TestFunction(parameterDeclaration, null);
deserializedfunction.VariablesContainer.InitializeParameters(queryString);
Assert.That(function.Variables["name"], Is.InstanceOf <IDomainObjectHandle <SampleObject> >());
Assert.That(function.Variables["name"], Is.EqualTo(domainObjectHandle));
}
/// <summary>
/// Converts a list of parameter values into a <see cref="NameValueCollection"/>.
/// </summary>
/// <param name="parameterDeclarations">
/// The <see cref="WxeParameterDeclaration"/> list used for serializing the <paramref name="parameterValues"/>.
/// Must not be <see langword="null"/> or contain items that are <see langword="null"/>.
/// </param>
/// <param name="parameterValues">
/// The list parameter values. Must not be <see langword="null"/>.
/// </param>
/// <returns>
/// A <see cref="NameValueCollection"/> containing the serialized <paramref name="parameterValues"/>.
/// The names of the parameters are used as keys.
/// </returns>
public static NameValueCollection SerializeParametersForQueryString(WxeParameterDeclaration[] parameterDeclarations, object[] parameterValues)
{
ArgumentUtility.CheckNotNullOrItemsNull("parameterDeclarations", parameterDeclarations);
ArgumentUtility.CheckNotNull("parameterValues", parameterValues);
NameValueCollection serializedParameters = new NameValueCollection();
for (int i = 0; i < parameterDeclarations.Length; i++)
{
WxeParameterDeclaration parameterDeclaration = parameterDeclarations[i];
object parameterValue = null;
if (i < parameterValues.Length)
{
parameterValue = parameterValues[i];
}
string serializedValue = parameterDeclaration.Converter.ConvertToString(parameterValue, null);
if (serializedValue != null)
{
serializedParameters.Add(parameterDeclaration.Name, serializedValue);
}
}
return(serializedParameters);
}
public Type GetTypeOfSecurableObject()
{
WxeParameterDeclaration[] parameterDeclarations = WxeVariablesContainer.GetParameterDeclarations(_functionType);
WxeParameterDeclaration parameterDeclaration = GetParameterDeclaration(parameterDeclarations);
var actualParameterType = GetActualParameterType(parameterDeclaration.Type);
if (!typeof(ISecurableObject).IsAssignableFrom(actualParameterType))
{
throw new WxeException(string.Format(
"The parameter '{1}' specified by the {0} applied to WxeFunction '{2}' does not implement interface '{3}'.",
_attribute.GetType().Name, parameterDeclaration.Name, _functionType.FullName, typeof(ISecurableObject).FullName));
}
if (SecurableClass == null)
{
return(actualParameterType);
}
CheckParameterDeclarationMatchesSecurableClass(actualParameterType, parameterDeclaration.Name);
return(SecurableClass);
}
public NameValueCollection SerializeParametersForQueryString()
{
NameValueCollection serializedParameters = new NameValueCollection();
WxeParameterDeclaration[] parameterDeclarations = ParameterDeclarations;
NameObjectCollection callerVariables = null;
if (_function.ParentStep != null)
{
callerVariables = _function.ParentStep.Variables;
}
bool hasActualParameters = _actualParameters.Length > 0;
for (int i = 0; i < parameterDeclarations.Length; i++)
{
WxeParameterDeclaration parameterDeclaration = parameterDeclarations[i];
object parameterValue = null;
if (hasActualParameters)
{
if (i < _actualParameters.Length)
{
parameterValue = _actualParameters[i];
}
}
else
{
parameterValue = _variables[parameterDeclaration.Name];
}
string serializedValue = parameterDeclaration.Converter.ConvertToString(parameterValue, callerVariables);
if (serializedValue != null)
{
serializedParameters.Add(parameterDeclaration.Name, serializedValue);
}
}
return(serializedParameters);
}
public WxeParameterConverterMock(WxeParameterDeclaration parameter)
: base(parameter)
{
}
public TestFunction(WxeParameterDeclaration parameterDeclaration, object parameterValue)
: base(WxeTransactionMode <ClientTransactionFactory> .None, new[] { parameterDeclaration }, new[] { parameterValue })
{
}
/// <summary>
/// Parses a string of comma separated actual parameters.
/// </summary>
/// <param name="parameterDeclarations">
/// The <see cref="WxeParameterDeclaration"/> list used for parsing the <paramref name="actualParameters"/>.
/// Must not be <see langword="null"/> or contain items that are <see langword="null"/>.
/// </param>
/// <param name="actualParameters">
/// The comma separated list of parameters. Must contain an entry for each required parameter.
/// Must not be <see langword="null"/>.
/// </param>
/// <param name="culture"> The <see cref="CultureInfo"/> to use as the current culture. </param>
/// <returns> An array of parameter values. </returns>
/// <remarks>
/// <list type="table">
/// <listheader>
/// <term> Type </term>
/// <description> Syntax </description>
/// </listheader>
/// <item>
/// <term> <see cref="String"/> </term>
/// <description> A quoted string. Escape quotes and line breaks using the backslash character.</description>
/// </item>
/// <item>
/// <term> Any type that has a <see langword="static"/> <b>Parse</b> method. </term>
/// <description> A quoted string that can be passed to the type's <b>Parse</b> method. For boolean constants
/// ("true", "false") and numeric constants, quotes are optional. </description>
/// </item>
/// <item>
/// <term> Variable Reference </term>
/// <description> An unquoted variable name. </description>
/// </item>
/// </list>
/// </remarks>
/// <example>
/// "the first \"string\" argument, containing quotes and a comma", "true", "12/30/04 12:00", variableName
/// </example>
public static object[] ParseActualParameters(WxeParameterDeclaration[] parameterDeclarations, string actualParameters, CultureInfo culture)
{
ArgumentUtility.CheckNotNullOrItemsNull("parameterDeclarations", parameterDeclarations);
ArgumentUtility.CheckNotNull("actualParameters", actualParameters);
StringUtility.ParsedItem[] parsedItems = StringUtility.ParseSeparatedList(actualParameters, ',');
if (parsedItems.Length > parameterDeclarations.Length)
{
throw new ApplicationException("Number of actual parameters exceeds number of declared parameters.");
}
ArrayList arguments = new ArrayList();
for (int i = 0; i < parsedItems.Length; ++i)
{
StringUtility.ParsedItem item = parsedItems[i];
WxeParameterDeclaration paramDecl = parameterDeclarations[i];
try
{
if (item.IsQuoted)
{
if (paramDecl.Type == typeof(string)) // string constant
{
arguments.Add(item.Value);
}
else // parse constant
{
arguments.Add(s_typeConversionProvider.Convert(null, culture, typeof(string), paramDecl.Type, item.Value));
}
}
else
{
if (string.CompareOrdinal(item.Value, "true") == 0) // true
{
arguments.Add(true);
}
else if (string.CompareOrdinal(item.Value, "false") == 0) // false
{
arguments.Add(false);
}
else if (item.Value.Length > 0 && char.IsDigit(item.Value[0])) // starts with digit -> parse constant
{
arguments.Add(s_typeConversionProvider.Convert(null, culture, typeof(string), paramDecl.Type, item.Value));
}
else // variable name
{
arguments.Add(new WxeVariableReference(item.Value));
}
}
}
catch (ArgumentException e)
{
throw new ApplicationException("Parameter " + paramDecl.Name + ": " + e.Message, e);
}
catch (ParseException e)
{
throw new ApplicationException("Parameter " + paramDecl.Name + ": " + e.Message, e);
}
}
return(arguments.ToArray());
}
public void g()
{
WxeParameterDeclaration parameter =
new WxeParameterDeclaration("param", true, WxeParameterDirection.In, typeof(string));
}
