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)); }