public void Add(List<Namespace> namespaces, DocumentedMethod association) { if (association.Method == null) { return; } Namespace ns = this.FindNamespace(association, namespaces); DeclaredType type = this.FindType(ns, association); DeclaredType methodReturnType = DeclaredType.Unresolved( Identifier.FromType(association.Method.ReturnType), association.Method.ReturnType, Namespace.Unresolved(Identifier.FromNamespace(association.Method.ReturnType.Namespace))); Method doc = Method.Unresolved( Identifier.FromMethod(association.Method, association.TargetType), type, association.Method, methodReturnType); this.ParseSummary(association, doc); this.ParseRemarks(association, doc); this.ParseValue(association, doc); this.ParseReturns(association, doc); this.ParseExample(association, doc); foreach (ParameterInfo parameter in association.Method.GetParameters()) { DeclaredType reference = DeclaredType.Unresolved( Identifier.FromType(parameter.ParameterType), parameter.ParameterType, Namespace.Unresolved(Identifier.FromNamespace(parameter.ParameterType.Namespace))); var docParam = new MethodParameter(parameter.Name, reference); this.ParseParamSummary(association, docParam); doc.AddParameter(docParam); } if (this.matchedAssociations.ContainsKey(association.Name)) { return; // weird case when a type has the same method declared twice } this.matchedAssociations.Add(association.Name, doc); if (type == null) { return; } type.AddMethod(doc); }
public void Add( List<Namespace> namespaces, DocumentedMethod association ) { Namespace ns = null; DeclaredType type = null; try { if( association.Method == null ) return; ns = FindNamespace( association, namespaces ); type = FindType( ns, association ); var methodReturnType = DeclaredType.Unresolved( Identifier.FromType( association.Method.ReturnType ), association.Method.ReturnType, Namespace.Unresolved( Identifier.FromNamespace( association.Method.ReturnType.Namespace ) ) ); var doc = Method.Unresolved( Identifier.FromMethod( association.Method, association.TargetType ), type, association.Method, methodReturnType ); ParseSummary( association, doc ); ParseRemarks( association, doc ); ParseValue( association, doc ); ParseReturns( association, doc ); ParseExample( association, doc ); foreach( var parameter in association.Method.GetParameters() ) { var reference = DeclaredType.Unresolved( Identifier.FromType( parameter.ParameterType ), parameter.ParameterType, Namespace.Unresolved( Identifier.FromNamespace( parameter.ParameterType.Namespace ) ) ); var docParam = new MethodParameter( parameter.Name, reference ); ParseParamSummary( association, docParam ); doc.AddParameter( docParam ); } if( matchedAssociations.ContainsKey( association.Name ) ) return; // weird case when a type has the same method declared twice matchedAssociations.Add( association.Name, doc ); if( type == null ) return; type.AddMethod( doc ); } catch( IOException ex ) { var doc = Method.Unresolved( Identifier.FromMethod( association.Method, association.TargetType ), type, association.Method, new NullReference() ); type.AddMethod( doc ); } }
private void WriteObject(object cmdletOutput, MethodParameter methodParameter) { Dbg.Assert(methodParameter != null, "Caller should verify that methodParameter != null"); if ((cmdletOutput != null) && (!string.IsNullOrEmpty(methodParameter.ParameterTypeName))) { PSObject pso = PSObject.AsPSObject(cmdletOutput); if (!pso.TypeNames.Contains(methodParameter.ParameterTypeName, StringComparer.OrdinalIgnoreCase)) { pso.TypeNames.Insert(0, methodParameter.ParameterTypeName); } } this.WriteObject(cmdletOutput); }
public void For_ArrayList() { var parameterInfo = typeof(Tekla.Structures.Model.Assembly) .GetMethods() .FirstOrDefault(m => m.Name.Equals("Add", StringComparison.InvariantCulture) && m.GetParameters().FirstOrDefault().ParameterType.IsAssignableFrom(typeof(System.Collections.ArrayList))) .GetParameters().FirstOrDefault(); var methodParameter = new MethodParameter(parameterInfo); Assert.AreEqual("System.Collections.ArrayList Assemblables_", methodParameter.MethodDeclaration); Assert.AreEqual("var Assemblables = ArrayListConverter.ToTSObjects(Assemblables_);", methodParameter.ConverterToTS); Assert.AreEqual("Assemblables", methodParameter.ParameterName); Assert.AreEqual("Assemblables_ = ArrayListConverter.FromTSObjects(Assemblables);", methodParameter.ConverterFromTS); }
public void For_ArrayofType() { var parameterInfo = typeof(Tekla.Structures.Model.ModelObjectSelector) .GetMethods() .FirstOrDefault(m => m.Name.Equals("GetAllObjectsWithType", StringComparison.InvariantCulture) && m.GetParameters().FirstOrDefault().ParameterType.IsArray) .GetParameters().FirstOrDefault(); var methodParameter = new MethodParameter(parameterInfo); Assert.AreEqual("System.Type[] TypeFilter_", methodParameter.MethodDeclaration); Assert.AreEqual("var TypeFilter = TypeConverter.ToTSObjects(TypeFilter_);", methodParameter.ConverterToTS); Assert.AreEqual("TypeFilter", methodParameter.ParameterName); Assert.AreEqual("TypeFilter_ = TypeConverter.FromTSObject(TypeFilter);", methodParameter.ConverterFromTS); }
public void For_Params_Int() { var parameterInfo = typeof(Tekla.Structures.MacroBuilder) .GetMethods() .FirstOrDefault(m => m.Name.Equals("TableSelect", StringComparison.InvariantCulture) && m.GetParameters().Length > 1) .GetParameters().FirstOrDefault(p => p.GetCustomAttributes(typeof(ParamArrayAttribute), false).Length > 0); var methodParameter = new MethodParameter(parameterInfo); Assert.AreEqual("params System.Int32[] items", methodParameter.MethodDeclaration); Assert.AreEqual(string.Empty, methodParameter.ConverterToTS); Assert.AreEqual("items", methodParameter.ParameterName); Assert.AreEqual(string.Empty, methodParameter.ConverterFromTS); }
private MethodSignature ReadMethodSignature(MethodBase method) { var parameters = method.GetParameters().Select(ReadParameter).ToList(); MethodParameter returnParameter = null; if (method is MethodInfo nonConstructor && nonConstructor.ReturnType != typeof(void)) { returnParameter = ReadParameter(nonConstructor.ReturnParameter); } return(new MethodSignature { Parameters = parameters, ReturnValue = returnParameter }); }
public void For_Out_Phase() { var parameterInfo = typeof(Tekla.Structures.Model.Beam) .GetMethods() .FirstOrDefault(m => m.Name.Equals("GetPhase", StringComparison.InvariantCulture) && m.GetParameters().Length > 0) .GetParameters().FirstOrDefault(); var methodParameter = new MethodParameter(parameterInfo); Assert.AreEqual("out Dynamic.Tekla.Structures.Model.Phase phase_", methodParameter.MethodDeclaration); Assert.AreEqual("var phase = Dynamic.Tekla.Structures.Model.Phase_.GetTSObject(null);", methodParameter.ConverterToTS); Assert.AreEqual("phase", methodParameter.ParameterName); Assert.AreEqual("phase_ = Dynamic.Tekla.Structures.Model.Phase_.FromTSObject(phase);", methodParameter.ConverterFromTS); }
public void For_List() { var parameterInfo = typeof(Tekla.Structures.Drawing.DatabaseObject) .GetMethods() .FirstOrDefault(m => m.Name.Equals("GetIntegerUserProperties", StringComparison.InvariantCulture) && m.GetParameters().Length > 1) .GetParameters().FirstOrDefault(); var methodParameter = new MethodParameter(parameterInfo); Assert.AreEqual("System.Collections.Generic.List<System.String> names", methodParameter.MethodDeclaration); Assert.AreEqual(string.Empty, methodParameter.ConverterToTS); Assert.AreEqual("names", methodParameter.ParameterName); Assert.AreEqual(string.Empty, methodParameter.ConverterFromTS); }
/// <summary> /// 检测异æ¥å›žè°ƒæ–¹æ³• /// </summary> protected override void checkAsynchronousReturn() { if (methodParameters == null) { base.checkAsynchronousReturn(); if (methodParameters.Length != 0) { if (!methodParameters[0].IsRefOrOut && methodParameters[0].ParameterType.Type == typeof(serverSocketSenderType)) { clientParameterName = methodParameters[0].ParameterName; methodParameters = MethodParameter.Get(methodParameters.getSub(1, methodParameters.Length - 1)); } } } }
public void RefResolveMethodOneParamter_string_Int() { MethodInfo methodInfo = typeof(SampleCls).ResolveMethod("GetCount", new Type[] { typeof(string) }, new MethodParameter[] { MethodParameter.CreateGeneric <string>(true), MethodParameter.Create <int>() }); Assert.IsNotNull(methodInfo); Assert.AreEqual("GetCount", methodInfo.Name); Assert.AreEqual(2, methodInfo.GetParameters().Length); Assert.AreEqual(true, methodInfo.GetParameters()[0].ParameterType.IsByRef); Assert.AreEqual(typeof(string), methodInfo.GetParameters()[0].ParameterType.GetElementType()); Assert.AreEqual(typeof(int), methodInfo.GetParameters()[1].ParameterType); }
/// <summary> /// Determine whether the given dependency carries a value attribute. /// </summary> public Object GetSuggestedValue(DependencyDescriptor descriptor) { Object value = FindValue(descriptor.Attributes); if (value == null) { MethodParameter methodParam = descriptor.MethodParameter; if (methodParam != null) { value = FindValue(methodParam.MethodAttributes); } } return(value); }
public void For_Ref_String() { var parameterInfo = typeof(Tekla.Structures.Model.ModelObject) .GetMethods() .FirstOrDefault(m => m.Name.Equals("GetReportProperty", StringComparison.InvariantCulture) && m.GetParameters().Length > 1) .GetParameters().FirstOrDefault(p => p.ParameterType.IsByRef); var methodParameter = new MethodParameter(parameterInfo); Assert.AreEqual("ref System.String value", methodParameter.MethodDeclaration); Assert.AreEqual(string.Empty, methodParameter.ConverterToTS); Assert.AreEqual("value", methodParameter.ParameterName); Assert.AreEqual(string.Empty, methodParameter.ConverterFromTS); }
private string GetMethodParameterPresentableTypeName(MethodParameter parameter) { var methodLevelGenerics = Regex.Matches(parameter.TypeId, "``+(?<genericParams>\\d)"); var typeText = parameter.TypeId.Replace("{", "<").Replace("}", ">"); var c = 1; if (methodLevelGenerics.Count > 0) { foreach (Match methodLevelGeneric in methodLevelGenerics) { var idx = int.Parse(methodLevelGeneric.Groups["genericParams"].Value); if (idx < parameter.Method.TypeParameters.Count) { typeText = typeText.Replace(methodLevelGeneric.Value, parameter.Method.TypeParameters[idx].Name); } else { typeText = typeText.Replace(methodLevelGeneric.Value, "T" + c); } c++; } } var classLevelGenerics = Regex.Matches(parameter.TypeId, "`+(?<genericParams>\\d)"); if (classLevelGenerics.Count > 0) { foreach (Match classLevelGeneric in classLevelGenerics) { var idx = int.Parse(classLevelGeneric.Groups["genericParams"].Value); if (idx < parameter.Method.ContainingType.TypeParameters.Count) { typeText = typeText.Replace(classLevelGeneric.Value, parameter.Method.ContainingType.TypeParameters[idx].Name); } else { typeText = typeText.Replace(classLevelGeneric.Value, "T" + c); } c++; } } if (typeText.StartsWith(parameter.Method.Model.AssemblyName)) { typeText = typeText.Split(new[] { "." }, StringSplitOptions.None).Last(); } return(typeText); }
public static MethodParameter CreateParameter(string name, SoType soType, bool isRequired) { MethodParameter methodParam = new MethodParameter { Name = name, IsRequired = isRequired, MetaData = new MetaData { DisplayName = name }, SoType = soType, Type = MapHelper.GetTypeBySoType(soType) }; return(methodParam); }
public void For_Type() { var parameterInfo = typeof(Tekla.Structures.Drawing.ViewBase) .GetMethods() .FirstOrDefault(m => m.Name.Equals("GetAllObjects", StringComparison.InvariantCulture) && m.GetParameters().Length > 0 && m.GetParameters().FirstOrDefault().ParameterType.IsAssignableFrom(typeof(System.Type))) .GetParameters().FirstOrDefault(); var methodParameter = new MethodParameter(parameterInfo); Assert.AreEqual("System.Type Type_", methodParameter.MethodDeclaration); Assert.AreEqual("var Type = TypeConverter.ToTSObjects(Type_);", methodParameter.ConverterToTS); Assert.AreEqual("Type", methodParameter.ParameterName); Assert.AreEqual("Type_ = TypeConverter.FromTSObject(Type);", methodParameter.ConverterFromTS); }
private void OnNext(CimMethodResult methodResult) { Dictionary <string, MethodParameter> strs = new Dictionary <string, MethodParameter>(StringComparer.OrdinalIgnoreCase); foreach (MethodParameter methodOutputParameter in base.GetMethodOutputParameters()) { this.ProcessOutParameter(methodResult, methodOutputParameter, strs); } if (strs.Count != 1) { if (strs.Count > 1) { PSObject pSObject = new PSObject(); foreach (KeyValuePair <string, MethodParameter> str in strs) { PSNoteProperty pSNoteProperty = new PSNoteProperty(str.Key, str.Value.Value); pSObject.Properties.Add(pSNoteProperty); } this.WriteObject(pSObject); } } else { MethodParameter methodParameter = strs.Values.Single <MethodParameter>(); if (methodParameter.Value != null) { IEnumerable enumerable = LanguagePrimitives.GetEnumerable(methodParameter.Value); if (enumerable == null) { this.WriteObject(methodParameter.Value, methodParameter); return; } else { foreach (object obj in enumerable) { this.WriteObject(obj, methodParameter); } } } else { return; } } }
/* * // NOTE: This isn't applicable to C# - can't change accessibility * def ensureAccessible[T <: AccessibleObject](accessible: T): T = { * if (!accessible.isAccessible) { * accessible.setAccessible(true) * } * accessible * } */ internal static ParameterHandler <TContext>[] GetParameterHandlers <TContext>(MethodBase method) where TContext : IContext { var methodParameters = method.GetParameters().ToArray(); var handlers = new ParameterHandler <TContext> [methodParameters.Length]; for (var i = 0; i < methodParameters.Length; i++) { var parameter = new MethodParameter(method, i); var contextClass = typeof(TContext); if (IsWithinBounds(parameter.ParameterType, typeof(IContext), contextClass)) { handlers[i] = new ContextParameterHandler <TContext>(); } else if (typeof(IContext).IsAssignableFrom(parameter.ParameterType)) { throw new CloudStateException( $"Unsupported context parameter on [{method.Name}], " + $"[{parameter.ParameterType.Name}] must be the same or a super type of [{contextClass.Name}]" ); } else if (parameter.ParameterType == typeof(IServiceCallFactory)) { handlers[i] = new ServiceCallFactoryParameterHandler <TContext>(); } else if (parameter.Attributes.Any(x => typeof(EntityIdAttribute) == x.GetType())) { if (parameter.ParameterType != typeof(string)) { throw new CloudStateException( $"[EntityIdAttribute] annotated parameter on method {method.Name} " + $"has type {parameter.ParameterType}, but must be String." ); } handlers[i] = new EntityIdParameterHandler <TContext>(); } else { // TODO: revisit extra arguments implementation handlers[i] = new MainArgumentParameterHandler <TContext>(parameter.ParameterType); } } return(handlers); }
private MethodParameter[] PrepareParameters(MethodInfo mInfo, object[] data) // dynamic data { List <MethodParameter> result = new List <MethodParameter>(); int index = 0; foreach (var p in mInfo.GetParameters()) { var t = data[index]; index++; MethodParameter param = new MethodParameter(p.Name, p.ParameterType, t); result.Add(param); } return(result.ToArray()); }
public static MethodParameter CreateParameter(string name, SoType soType, bool isRequired, string description) { MethodParameter methodParam = new MethodParameter { Name = name, IsRequired = isRequired, MetaData = new MetaData { Description = description, DisplayName = AddSpaceBeforeCaptialLetter(name) }, SoType = soType, Type = Convert.ToString(soType) }; return(methodParam); }
public static void WriteElement(MethodGenerator g, string dtoMemberName, Type elementType, Action loadValue) { var method = typeof(IDTOWriter).ResolveMethod("WriteElement", new Type[] { elementType }, MethodParameter.Create <string>(), MethodParameter.Create <bool>(), MethodParameter.CreateGeneric(elementType)); var prmIndex = SerializationArgs.WriterIndex; g.Call(method, () => { g.LoadParameter(prmIndex); g.Load(dtoMemberName); g.Load(IsPrimitive(elementType)); loadValue(); }); }
private static string FormatMethodParameter(MethodParameter parameter) { var builder = new StringBuilder(); for (var i = 0; i < parameter.Modifiers.Count; i++) { builder.Append(parameter.Modifiers[i]); builder.Append(' '); } builder.Append(parameter.TypeName); builder.Append(' '); builder.Append(parameter.ParameterName); return(builder.ToString()); }
public ServiceObjectMethodBuilder AddParameter(string name, SoType soType, bool isRequired = false) { var methodParam = new MethodParameter { Name = name, IsRequired = isRequired, MetaData = new MetaData { DisplayName = name }, SoType = soType, Type = MapHelper.GetTypeBySoType(soType) }; method.MethodParameters.Create(methodParam); return(this); }
private void ProcessOutParameter(CimMethodResult methodResult, MethodParameter methodParameter, IDictionary <string, MethodParameter> cmdletOutput) { Dbg.Assert(methodResult != null, "Caller should verify methodResult != null"); Dbg.Assert(methodParameter != null, "Caller should verify methodParameter != null"); Dbg.Assert(0 != (methodParameter.Bindings & (MethodParameterBindings.Out | MethodParameterBindings.Error)), "Caller should verify that this is an out parameter"); Dbg.Assert(cmdletOutput != null, "Caller should verify cmdletOutput != null"); Dbg.Assert(this.MethodSubject != null, "MethodSubject property should be initialized before starting main job processing"); CimMethodParameter outParameter = methodResult.OutParameters[methodParameter.Name]; object valueReturnedFromMethod = (outParameter == null) ? null : outParameter.Value; object dotNetValue = CimValueConverter.ConvertFromCimToDotNet(valueReturnedFromMethod, methodParameter.ParameterType); if (MethodParameterBindings.Out == (methodParameter.Bindings & MethodParameterBindings.Out)) { methodParameter.Value = dotNetValue; cmdletOutput.Add(methodParameter.Name, methodParameter); var cimInstances = dotNetValue as CimInstance[]; if (cimInstances != null) { foreach (var instance in cimInstances) { CimCmdletAdapter.AssociateSessionOfOriginWithInstance(instance, this.JobContext.Session); } } var cimInstance = dotNetValue as CimInstance; if (cimInstance != null) { CimCmdletAdapter.AssociateSessionOfOriginWithInstance(cimInstance, this.JobContext.Session); } } else if (MethodParameterBindings.Error == (methodParameter.Bindings & MethodParameterBindings.Error)) { var gotError = (bool)LanguagePrimitives.ConvertTo(dotNetValue, typeof(bool), CultureInfo.InvariantCulture); if (gotError) { var errorCodeAsString = (string)LanguagePrimitives.ConvertTo(dotNetValue, typeof(string), CultureInfo.InvariantCulture); CimJobException cje = CimJobException.CreateFromMethodErrorCode(this.GetDescription(), this.JobContext, this.MethodName, errorCodeAsString); throw cje; } } }
public MethodParameter ReadMethodParameter() { var ibyte = (byte)_stream.ReadByte(); if ((ibyte) != 0x0A) { throw new InvalidDataException($"Trying to ReadMethodParameter but streams identifier byte is {ibyte}"); } var name = ReadString(); var val = ReadVariable(); var ret = new MethodParameter { Name = name, Value = val }; return(ret); }
public void AddMemberMethod(object _customerClass, MethodParameter parameter) { CodeMemberMethod method = new CodeMemberMethod(); method.Attributes = MemberAttributes.Public | MemberAttributes.Final; method.Name = parameter.methodName; method.ReturnType = new CodeTypeReference(parameter.methodReturnType); foreach (var item in parameter.methodParameter) { method.Parameters.Add(new CodeParameterDeclarationExpression(item.Key, item.Value)); } method.Statements.Add(new CodeSnippetStatement(parameter.methodSpinnet)); method.Statements.Add(new CodeMethodReturnStatement(new CodeArgumentReferenceExpression(parameter.methodReturn))); CodeTypeDeclaration customerClass = (CodeTypeDeclaration)_customerClass; customerClass.Members.Add(method); }
public void MethodParameter_Ctor_Fills_TypeParserResolver_Property_When_No_Default_Passed() { var param = new MethodParameter(_ExampleMethod_byteArrayWithExpect, null); Assert.AreEqual("byteArrayWithExpect", param.Name); Assert.AreEqual(PathPart.Normalise(param.Name), param.NormalisedName); Assert.AreEqual(typeof(byte[]), param.ParameterType); Assert.AreEqual(false, param.IsOptional); Assert.AreEqual(System.DBNull.Value, param.DefaultValue); Assert.AreEqual(typeof(byte), param.ElementType); Assert.IsTrue(param.IsArray); Assert.IsNotNull(param.TypeParserResolver); var parsers = param.TypeParserResolver.GetParsers(); Assert.AreEqual(1, parsers.Length); Assert.IsInstanceOfType(parsers[0], typeof(ByteArray_Mime64_Parser)); }
/// <summary> /// 检测异æ¥å›žè°ƒæ–¹æ³• /// </summary> protected virtual void checkAsynchronousReturn() { if (methodParameters == null) { methodParameters = Method.Parameters; methodReturnType = Method.ReturnType; if (Method.ReturnType.Type == typeof(void) && methodParameters.Length != 0) { Type type = methodParameters[methodParameters.Length - 1].ParameterType.Type; if (type.IsGenericType) { Type parameterType = null; if (isAsynchronousFunc && type.GetGenericTypeDefinition() == typeof(Func <,>)) { Type[] types = type.GetGenericArguments(); if (types[1] == typeof(bool)) { parameterType = types[0]; } } else if (type.GetGenericTypeDefinition() == typeof(Action <>)) { parameterType = type.GetGenericArguments()[0]; } if (parameterType != null) { if (parameterType == typeof(AutoCSer.Net.TcpServer.ReturnValue)) { isAsynchronousCallback = true; } else if (parameterType.IsGenericType && parameterType.GetGenericTypeDefinition() == typeof(AutoCSer.Net.TcpServer.ReturnValue <>)) { methodReturnType = parameterType.GetGenericArguments()[0]; isAsynchronousCallback = true; } if (isAsynchronousCallback) { methodParameters = MethodParameter.Get(methodParameters.AsSpan(0, methodParameters.Length - 1).GetArray()); } } } } } }
public async Task ShouldInvokeSynchronousOutVoidMethod(string expected) { var method = GetMethod(nameof(SynchronousOutVoid)); var invoker = new MethodInvoker(Mock.Of <ILogger <MethodInvoker> >()); var arguments = new MethodParameter[] { new MethodParameter { Name = "value", Value = expected }, new MethodParameter { Name = "copy", Out = true } }; var result = await invoker.InvokeMethodAsync(this, method, arguments); Assert.NotNull(result); Assert.True(result.IsVoid); Assert.False(result.IsAsync); Assert.Null(result.Result); Assert.Equal(expected, _value); Assert.Contains("copy", result.OutParameters); Assert.Equal(expected, result.OutParameters["copy"]); }
//----------------------------------------------------------------------------------------------------------------------------------------------------- private static ParameterSyntax EmitParameterSyntax(MethodParameter parameter) { var syntax = Parameter(Identifier(parameter.Name)); switch (parameter.Modifier) { case MethodParameterModifier.Ref: syntax = syntax.WithModifiers(TokenList(Token(SyntaxKind.RefKeyword))); break; case MethodParameterModifier.Out: syntax = syntax.WithModifiers(TokenList(Token(SyntaxKind.OutKeyword))); break; } syntax = syntax.WithType(parameter.Type.GetTypeNameSyntax()); return(syntax); }
private void OnPropertiesListChanged(object sender, ListChangedEventArgs e) { if (e.ListChangedType != ListChangedType.ItemAdded) { return; } var property = ((PropertyCollection)sender)[e.NewIndex]; if (!MustEncrypt(property)) { return; } property.DbType = System.Data.DbType.Binary; property.MaxLength = 8000; if (property.Entity.AmbientParameters[PassPhraseToken] != null) { return; } // create one pass phrase ambient parameter for each entity that has at least one crypt property var passPhraseParameter = new MethodParameter { Name = PassPhraseToken, ClrFullTypeName = "string", Nullable = CodeFluent.Model.Code.Nullable.False, Options = MethodParameterOptions.Ambient | MethodParameterOptions.Inherits | MethodParameterOptions.UsedForLoad | MethodParameterOptions.UsedForSearch | MethodParameterOptions.UsedForCount | MethodParameterOptions.UsedForRaw | MethodParameterOptions.UsedForSave, ModelName = "[" + Project.DefaultNamespace + ".PassPhrase.GetPassPhrase()]", AmbientExpression = "(1=1)" }; property.Entity.AmbientParameters.Add(passPhraseParameter); }
protected string GetStringParameter(string name, bool isRequired = false) { MethodParameter p = ServiceBroker.Service.ServiceObjects[0].Methods[0].MethodParameters[name]; if (p == null) { if (isRequired) { throw new ArgumentException(string.Format(Constants.ErrorMessages.RequiredParameterNotFound, name)); } return(string.Empty); } string val = p.Value as string; if (isRequired && string.IsNullOrWhiteSpace(val)) { throw new ArgumentException(string.Format("{0} is required but is empty.", name)); } return(val); }
/// <summary> /// Gets the code for multiple parameters. /// </summary> /// <param name="parameters">The parameters.</param> /// <returns>The code.</returns> public virtual string GetParameters(MethodParameter[] parameters) { if (parameters == null) return string.Empty; var sb = new StringBuilder(); for (var i = 0; i < parameters.Length; i++) { sb.Append(GetParameter(parameters[i])); if (i < parameters.Length - 1) sb.Append(ParameterSpacer); } return sb.ToString(); }
/// <summary> /// Gets the code for creating a parameter. /// </summary> /// <param name="parameter">The parameter.</param> /// <returns>The code.</returns> public virtual string GetParameter(MethodParameter parameter) { return parameter.Type + " " + parameter.Name; }
/// <summary> /// Gets the code for a method header. /// </summary> /// <param name="methodName">Name of the method.</param> /// <param name="visibility">The visibility.</param> /// <param name="parameters">The parameters.</param> /// <param name="returnType">Type of the return.</param> /// <param name="isVirtual">If this method will be virtual.</param> /// <param name="isStatic">If this method will be static.</param> /// <returns>The code.</returns> public virtual string GetMethodHeader(string methodName, MemberVisibilityLevel visibility, MethodParameter[] parameters, string returnType, bool isVirtual, bool isStatic) { var sb = new StringBuilder(256); sb.Append(GetMethodNameAndVisibility(methodName, visibility, returnType, isVirtual, isStatic)); // Parameters sb.Append(OpenParameterString); sb.Append(GetParameters(parameters)); sb.Append(CloseParameterString); return sb.ToString(); }
/// <summary> /// Gets the code for a method header. /// </summary> /// <param name="methodName">Name of the method.</param> /// <param name="visibility">The visibility.</param> /// <param name="parameters">The parameters.</param> /// <param name="returnType">Type of the return.</param> /// <param name="isVirtual">If this method will be virtual.</param> /// <param name="isStatic">If this method will be static.</param> /// <returns>The code.</returns> public string GetMethodHeader(string methodName, MemberVisibilityLevel visibility, MethodParameter[] parameters, Type returnType, bool isVirtual, bool isStatic) { return GetMethodHeader(methodName, visibility, parameters, GetTypeString(returnType), isVirtual, isStatic); }
/// <summary> /// Gets the code for the header of an extension method. /// </summary> /// <param name="methodName">Name of the method.</param> /// <param name="extender">The extender.</param> /// <param name="parameters">The parameters.</param> /// <param name="returnType">Type of the return.</param> /// <returns>The code.</returns> public virtual string GetExtensionMethodHeader(string methodName, MethodParameter extender, MethodParameter[] parameters, Type returnType) { var sb = new StringBuilder(256); sb.Append(GetMethodNameAndVisibility(methodName, MemberVisibilityLevel.Public, returnType, false, true)); sb.Append(OpenParameterString); // First parameter sb.Append("this "); sb.Append(GetParameter(extender)); // Additional parameters if (parameters != null && parameters.Length > 0) { sb.Append(ParameterSpacer); sb.Append(GetParameters(parameters)); } sb.Append(CloseParameterString); return sb.ToString(); }
/// <summary> /// Gets the header for a constructor. /// </summary> /// <param name="className">Name of the class.</param> /// <param name="visibility">The visibility.</param> /// <param name="parameters">The parameters.</param> /// <returns>The code.</returns> public virtual string GetConstructorHeader(string className, MemberVisibilityLevel visibility, MethodParameter[] parameters) { return GetMethodHeader(className, visibility, parameters, string.Empty, false, false); }
private bool IsEnabled(MethodParameter parameter) { if (parameter.IsPagingParameter) return false; return parameter.GetAttributeValue("enabled", NamespaceUri, true); }
private FilterFunctions GetFilterFunctions(MethodParameter parameter) { if (parameter == null) return DefaultFilterFunctions; FilterFunctions defaultValue = GetDefaultFilterFunctions(parameter.Method); return parameter.GetAttributeValue("filterFunctions", NamespaceUri, defaultValue); }
public override List<ServiceObject> DescribeServiceObjects() { string[] ldaps = base.LDAPPaths.Split(new char[] { ';' }, StringSplitOptions.RemoveEmptyEntries); string[] netbios = base.NetBiosNames.Split(new char[] { ';' }, StringSplitOptions.RemoveEmptyEntries); if (ldaps.Length != netbios.Length) { throw new ArgumentException("The LDAP paths and NetBioses count do not match."); } ServiceObject soUser = Helper.CreateServiceObject("AD User", "Active Directory User."); soUser.Properties.Add(Helper.CreateProperty(Constants.SOProperties.ActiveDirectory.UserFQN, SoType.Text, "The FQN username. Domain\\samlaccountname")); soUser.Properties.Add(Helper.CreateProperty(Constants.SOProperties.ActiveDirectory.SubStringSearchInput, SoType.Text, "The string used to search for a specific value.")); soUser.Properties.Add(Helper.CreateProperty(Constants.SOProperties.ActiveDirectory.SamAccountName, SoType.Text, "The SAM Account name")); soUser.Properties.Add(Helper.CreateProperty(Constants.SOProperties.ActiveDirectory.Name, SoType.Text, "The name of the user")); soUser.Properties.Add(Helper.CreateProperty(Constants.SOProperties.ActiveDirectory.Description, SoType.Text, "Description")); soUser.Properties.Add(Helper.CreateProperty(Constants.SOProperties.ActiveDirectory.Email, SoType.Text, "Email Address")); soUser.Properties.Add(Helper.CreateProperty(Constants.SOProperties.ActiveDirectory.Manager, SoType.Text, "The Manager")); soUser.Properties.Add(Helper.CreateProperty(Constants.SOProperties.ActiveDirectory.ObjectSID, SoType.Text, "An objectSID")); soUser.Properties.Add(Helper.CreateProperty(Constants.SOProperties.ActiveDirectory.DisplayName, SoType.Text, "Display Name")); soUser.Properties.Add(Helper.CreateProperty(Constants.SOProperties.ActiveDirectory.CommonName, SoType.Text, "The common name of the object.")); soUser.Properties.Add(Helper.CreateProperty(Constants.SOProperties.ActiveDirectory.GivenName, SoType.Text, "Given Name")); soUser.Properties.Add(Helper.CreateProperty(Constants.SOProperties.ActiveDirectory.Initials, SoType.Text, "Initials")); soUser.Properties.Add(Helper.CreateProperty(Constants.SOProperties.ActiveDirectory.Surname, SoType.Text, "Surname")); soUser.Properties.Add(Helper.CreateProperty(Constants.SOProperties.ActiveDirectory.MaxSearchResultSize, SoType.Number, "Override the default max result size per LDAP directory.")); soUser.Properties.Add(Helper.CreateProperty(Constants.SOProperties.ActiveDirectory.OrganisationalUnit, SoType.Text, "OrganisationalUnit")); foreach (string prop in AdditionalADProps) { soUser.Properties.Add(Helper.CreateProperty(prop, SoType.Text, prop)); } Method mGetUsers = Helper.CreateMethod(Constants.Methods.ActiveDirectory.GetUsers, "Get all users, filtered by exact matching of the input properties.", MethodType.List); mGetUsers.InputProperties.Add(Constants.SOProperties.ActiveDirectory.UserFQN); mGetUsers.InputProperties.Add(Constants.SOProperties.ActiveDirectory.DisplayName); mGetUsers.InputProperties.Add(Constants.SOProperties.ActiveDirectory.Email); mGetUsers.InputProperties.Add(Constants.SOProperties.ActiveDirectory.MaxSearchResultSize); mGetUsers.ReturnProperties.Add(Constants.SOProperties.ActiveDirectory.UserFQN); mGetUsers.ReturnProperties.Add(Constants.SOProperties.ActiveDirectory.SamAccountName); mGetUsers.ReturnProperties.Add(Constants.SOProperties.ActiveDirectory.DisplayName); mGetUsers.ReturnProperties.Add(Constants.SOProperties.ActiveDirectory.Email); foreach (string prop in AdditionalADProps) { mGetUsers.ReturnProperties.Add(prop); } soUser.Methods.Add(mGetUsers); Method mGetUserDetails = Helper.CreateMethod(Constants.Methods.ActiveDirectory.GetUserDetails, "Get all details for the users.", MethodType.Read); mGetUserDetails.InputProperties.Add(Constants.SOProperties.ActiveDirectory.UserFQN); mGetUserDetails.Validation.RequiredProperties.Add(Constants.SOProperties.ActiveDirectory.UserFQN); mGetUserDetails.ReturnProperties.Add(Constants.SOProperties.ActiveDirectory.SamAccountName); mGetUserDetails.ReturnProperties.Add(Constants.SOProperties.ActiveDirectory.DisplayName); mGetUserDetails.ReturnProperties.Add(Constants.SOProperties.ActiveDirectory.CommonName); mGetUserDetails.ReturnProperties.Add(Constants.SOProperties.ActiveDirectory.GivenName); mGetUserDetails.ReturnProperties.Add(Constants.SOProperties.ActiveDirectory.Initials); mGetUserDetails.ReturnProperties.Add(Constants.SOProperties.ActiveDirectory.Surname); mGetUserDetails.ReturnProperties.Add(Constants.SOProperties.ActiveDirectory.Email); mGetUserDetails.ReturnProperties.Add(Constants.SOProperties.ActiveDirectory.OrganisationalUnit); foreach (string prop in AdditionalADProps) { mGetUserDetails.ReturnProperties.Add(prop); } soUser.Methods.Add(mGetUserDetails); Method mSearchUser = Helper.CreateMethod(Constants.Methods.ActiveDirectory.SearchUsers, "Performs a StartWith query on DisplayName, SamlAccountName and E-mail.", MethodType.List); mSearchUser.InputProperties.Add(Constants.SOProperties.ActiveDirectory.SubStringSearchInput); mSearchUser.InputProperties.Add(Constants.SOProperties.ActiveDirectory.MaxSearchResultSize); mSearchUser.Validation.RequiredProperties.Add(Constants.SOProperties.ActiveDirectory.SubStringSearchInput); mSearchUser.ReturnProperties.Add(Constants.SOProperties.ActiveDirectory.UserFQN); mSearchUser.ReturnProperties.Add(Constants.SOProperties.ActiveDirectory.SamAccountName); mSearchUser.ReturnProperties.Add(Constants.SOProperties.ActiveDirectory.DisplayName); mSearchUser.ReturnProperties.Add(Constants.SOProperties.ActiveDirectory.Email); soUser.Methods.Add(mSearchUser); Method mUMGetUsers = Helper.CreateMethod(Constants.Methods.ActiveDirectory.UMGetUsers, "Performs a search using FILTERs provided to the SMO.", MethodType.List); mUMGetUsers.InputProperties.Add(Constants.SOProperties.ActiveDirectory.Name); mUMGetUsers.InputProperties.Add(Constants.SOProperties.ActiveDirectory.Description); mUMGetUsers.InputProperties.Add(Constants.SOProperties.ActiveDirectory.Email); mUMGetUsers.InputProperties.Add(Constants.SOProperties.ActiveDirectory.Manager); mUMGetUsers.InputProperties.Add(Constants.SOProperties.ActiveDirectory.DisplayName); mUMGetUsers.InputProperties.Add(Constants.SOProperties.ActiveDirectory.MaxSearchResultSize); mUMGetUsers.ReturnProperties.Add(Constants.SOProperties.ActiveDirectory.UserFQN); mUMGetUsers.ReturnProperties.Add(Constants.SOProperties.ActiveDirectory.Name); mUMGetUsers.ReturnProperties.Add(Constants.SOProperties.ActiveDirectory.Description); mUMGetUsers.ReturnProperties.Add(Constants.SOProperties.ActiveDirectory.DisplayName); mUMGetUsers.ReturnProperties.Add(Constants.SOProperties.ActiveDirectory.Email); mUMGetUsers.ReturnProperties.Add(Constants.SOProperties.ActiveDirectory.Manager); mUMGetUsers.ReturnProperties.Add(Constants.SOProperties.ActiveDirectory.ObjectSID); MethodParameter methParm = new MethodParameter(); methParm.IsRequired = true; methParm.MetaData = new SourceCode.SmartObjects.Services.ServiceSDK.Objects.MetaData(); methParm.MetaData.Description = Constants.SOProperties.ActiveDirectory.Label; methParm.MetaData.DisplayName = Constants.SOProperties.ActiveDirectory.Label; methParm.Name = Constants.SOProperties.ActiveDirectory.Label; methParm.SoType = SoType.Text; methParm.Type = MapHelper.GetTypeBySoType(methParm.SoType); mUMGetUsers.MethodParameters.Add(methParm); soUser.Methods.Add(mUMGetUsers); return new List<ServiceObject>() { soUser }; }
private void OnPropertiesListChanged(object sender, ListChangedEventArgs e) { if (e.ListChangedType != ListChangedType.ItemAdded) return; var property = ((PropertyCollection)sender)[e.NewIndex]; if (!MustEncrypt(property)) return; property.DbType = System.Data.DbType.Binary; property.MaxLength = 8000; if (property.Entity.AmbientParameters[PassPhraseParameterName] != null) return; // create one pass phrase ambient parameter for each entity that has at least one crypt property var passPhraseParameter = new MethodParameter { Name = PassPhraseParameterName, ClrFullTypeName = "string", Nullable = CodeFluent.Model.Code.Nullable.False, Options = MethodParameterOptions.Ambient | MethodParameterOptions.Inherits | MethodParameterOptions.UsedForLoad | MethodParameterOptions.UsedForSearch | MethodParameterOptions.UsedForCount | MethodParameterOptions.UsedForRaw | MethodParameterOptions.UsedForSave, ModelName = "[" + Project.DefaultNamespace + ".PassPhrase.GetPassPhrase()]", AmbientExpression = "(1=1)" }; property.Entity.AmbientParameters.Add(passPhraseParameter); }
private string GetMethodParameterName(MethodParameter parameter) { string name = parameter.GetAttributeValue("parameterNameFormat", NamespaceUri, (string)null); if (!string.IsNullOrEmpty(name)) return name; string format = GetMethodParameterNameFormat(parameter.Method); return string.Format(format, parameter.Name); }
public VariableAssignmentAction(Func<MethodBuilderBundle> bundle, int localIndex, MethodParameter parameter) : this(bundle, localIndex) { this.parameter = parameter; }
public static MethodParameter CreateParameter(string name, SoType soType, bool isRequired, string description) { MethodParameter methodParam = new MethodParameter { Name = name, IsRequired = isRequired, MetaData = new MetaData { Description = description, DisplayName = AddSpaceBeforeCaptialLetter(name) }, SoType = soType, Type = Convert.ToString(soType) }; return methodParam; }
private void UpdateMethods() { // Add arguments Search method // SEARCH(FirstName, LastName) // => SEARCH(FirstName, FirstNameFilterFunction, LastName, LastNameFilterFunction) foreach (var entity in Project.Entities) { foreach (var method in entity.Methods) { if (!IsEnabled(method)) continue; int newParameterCount = 0; foreach (var parameter in method.Parameters.Clone()) { if (!IsEnabled(parameter)) continue; newParameterCount += 1; MethodParameter newParameter = new MethodParameter(); newParameter.Name = GetMethodParameterName(parameter); newParameter.ClrFullTypeName = FilterFunctionsEnumeration.ClrFullTypeName; newParameter.DbType = FilterFunctionsEnumeration.EnumDbType; newParameter.MustUsePersistenceDefaultValue = false; newParameter.Nullable = Nullable.False; newParameter.ModelNullable = Nullable.False; method.Parameters.Insert(parameter.Index + newParameterCount, newParameter); newParameter.Data[NamespaceUri + ":parameter"] = parameter; // Save the original parameter to retrieve it when updating the procedure } } } }