/// <summary> /// Initializes a new instance of the <see cref="PrimaryKeyFunctionField"/> class. /// </summary> /// <param name="uniqueKeyElement">The table element.</param> public PrimaryKeyFunctionField(UniqueElement uniqueKeyElement) { // Initialize the object. this.Name = "primaryKeyFunction"; this.uniqueKeyElement = uniqueKeyElement; // /// <summary> // /// Used to get the primary key from the record. // /// </summary> // private Func<Buyer, object> primaryKeyFunction = ((Expression<Func<Buyer, object>>)(b => b.BuyerId)).Compile(); this.Syntax = SyntaxFactory.FieldDeclaration( SyntaxFactory.VariableDeclaration( SyntaxFactory.GenericName( SyntaxFactory.Identifier("Func")) .WithTypeArgumentList( SyntaxFactory.TypeArgumentList( SyntaxFactory.SeparatedList <TypeSyntax>( new SyntaxNodeOrToken[] { SyntaxFactory.IdentifierName(this.uniqueKeyElement.Table.Name), SyntaxFactory.Token(SyntaxKind.CommaToken), SyntaxFactory.PredefinedType( SyntaxFactory.Token(SyntaxKind.ObjectKeyword)), })))) .WithVariables( SyntaxFactory.SingletonSeparatedList <VariableDeclaratorSyntax>( SyntaxFactory.VariableDeclarator( SyntaxFactory.Identifier("primaryKeyFunction")) .WithInitializer(this.Initializer)))) .WithModifiers(PrimaryKeyFunctionField.Modifiers) .WithLeadingTrivia(PrimaryKeyFunctionField.DocumentationComment); }
/// <summary> /// Initializes a new instance of the <see cref="GetMethod"/> class. /// </summary> /// <param name="uniqueKeyElement">The unique constraint schema.</param> public GetMethod(UniqueElement uniqueKeyElement) { // Initialize the object. Note that we decorate the name of every method that's not the primary key to prevent ambiguous signatures. this.uniqueKeyElement = uniqueKeyElement; this.Name = $"Get{this.uniqueKeyElement.Table.Name}"; // /// <summary> // /// Gets a specific <see cref="Province"/> record. // /// </summary> // /// <param name="provinceId">The primary key identifier.</param> // /// <returns>The result of the GET verb.</returns> // [HttpGet("{provinceId}")] // public async Task<IActionResult> GetProvince([FromRoute] int provinceId) // { // <Body> // } this.Syntax = SyntaxFactory.MethodDeclaration( SyntaxFactory.GenericName( SyntaxFactory.Identifier("Task")) .WithTypeArgumentList( SyntaxFactory.TypeArgumentList( SyntaxFactory.SingletonSeparatedList <TypeSyntax>( SyntaxFactory.IdentifierName("IActionResult")))), SyntaxFactory.Identifier(this.Name)) .WithAttributeLists(this.Attributes) .WithModifiers(GetMethod.Modifiers) .WithParameterList(this.Parameters) .WithBody(this.Body) .WithLeadingTrivia(this.DocumentationComment); }
/// <summary> /// Gets the syntax for the creation of an anonymous type. /// </summary> /// <param name="uniqueKeyElement">The description of a unique key.</param> /// <param name="variableName">The name of the variable holding the keys.</param> /// <returns>An expression that builds an anonymous type from a table description.</returns> public static SeparatedSyntaxList <ArgumentSyntax> GetMemberSyntax(UniqueElement uniqueKeyElement, string variableName) { SeparatedSyntaxList <ArgumentSyntax> findParameters; if (uniqueKeyElement.Columns.Count == 1) { // country = this.dataModel.Countries.CountryCountryCodeKey.Find(countryCountryCodeKeyCountryCode); ColumnElement columnElement = uniqueKeyElement.Columns[0].Column; string propertyName = columnElement.Name; findParameters = SyntaxFactory.SingletonSeparatedList <ArgumentSyntax>( SyntaxFactory.Argument( SyntaxFactory.MemberAccessExpression( SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.IdentifierName(variableName), SyntaxFactory.IdentifierName(propertyName)))); } else { // region = this.dataModel.Regions.RegionExternalKey.Find((regionExternalKeyName, regionExternalKeyCountryCode)); List <SyntaxNodeOrToken> keys = new List <SyntaxNodeOrToken>(); foreach (ColumnReferenceElement columnReferenceElement in uniqueKeyElement.Columns) { if (keys.Count != 0) { keys.Add(SyntaxFactory.Token(SyntaxKind.CommaToken)); } ColumnElement columnElement = columnReferenceElement.Column; string attributeName = columnElement.Name.ToVariableName(); keys.Add( SyntaxFactory.Argument( SyntaxFactory.MemberAccessExpression( SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.IdentifierName(variableName), SyntaxFactory.IdentifierName(attributeName)))); } findParameters = SyntaxFactory.SingletonSeparatedList <ArgumentSyntax>( SyntaxFactory.Argument( SyntaxFactory.TupleExpression( SyntaxFactory.SeparatedList <ArgumentSyntax>(keys)))); } // This is either the parameter or a tuple that can be used as parameters to a 'Find' operation. return(findParameters); }
/// <summary> /// Constructs an initializer for a unique index. /// </summary> /// <param name="uniqueElement">The unique index description.</param> /// <returns>Code to initialize a unique index.</returns> private static ExpressionSyntax GetUniqueInitializer(UniqueElement uniqueElement) { // new ForeignIndex<Account,Item>("AccountSymbolKey") ExpressionSyntax expressionSyntax = SyntaxFactory.ObjectCreationExpression( SyntaxFactory.GenericName( SyntaxFactory.Identifier("UniqueIndex")) .WithTypeArgumentList( SyntaxFactory.TypeArgumentList( SyntaxFactory.SingletonSeparatedList <TypeSyntax>( SyntaxFactory.IdentifierName(uniqueElement.Table.Name))))) .WithArgumentList( SyntaxFactory.ArgumentList( SyntaxFactory.SingletonSeparatedList <ArgumentSyntax>( SyntaxFactory.Argument( SyntaxFactory.LiteralExpression( SyntaxKind.StringLiteralExpression, SyntaxFactory.Literal(uniqueElement.Name)))))); // .HasIndex(a => a.ItemId) expressionSyntax = SyntaxFactory.InvocationExpression( SyntaxFactory.MemberAccessExpression( SyntaxKind.SimpleMemberAccessExpression, expressionSyntax, SyntaxFactory.IdentifierName("HasIndex"))) .WithArgumentList( SyntaxFactory.ArgumentList( SyntaxFactory.SingletonSeparatedList <ArgumentSyntax>( SyntaxFactory.Argument(UniqueKeyExpression.GetUniqueKey(uniqueElement))))); // .HasFilter(a => a.Symbol != null) if (uniqueElement.IsNullable) { expressionSyntax = SyntaxFactory.InvocationExpression( SyntaxFactory.MemberAccessExpression( SyntaxKind.SimpleMemberAccessExpression, expressionSyntax, SyntaxFactory.IdentifierName("HasFilter"))) .WithArgumentList( SyntaxFactory.ArgumentList( SyntaxFactory.SingletonSeparatedList <ArgumentSyntax>( SyntaxFactory.Argument(NullableKeyFilterExpression.GetNullableKeyFilter(uniqueElement))))); } return(expressionSyntax); }
/// <summary> /// Initializes a new instance of the <see cref="DictionaryField"/> class. /// </summary> /// <param name="uniqueKeyElement">The table schema.</param> public DictionaryField(UniqueElement uniqueKeyElement) { // Initialize the object. this.uniqueKeyElement = uniqueKeyElement; // This is the name of the field. this.Name = "dictionary"; // /// <summary> // /// The dictionary containing the index. // /// </summary> // private Dictionary<Guid, ProvinceRow> dictionary = new Dictionary<Guid, ProvinceRow>(); this.Syntax = SyntaxFactory.FieldDeclaration( SyntaxFactory.VariableDeclaration(this.Type) .WithVariables( SyntaxFactory.SingletonSeparatedList <VariableDeclaratorSyntax>( SyntaxFactory.VariableDeclarator( SyntaxFactory.Identifier(this.Name)) .WithInitializer(this.Initializer)))) .WithModifiers(DictionaryField.Modifiers) .WithLeadingTrivia(DictionaryField.DocumentationComment); }
/// <summary> /// Initializes a new instance of the <see cref="GenericUniqueIndexProperty"/> class. /// </summary> /// <param name="uniqueKeyElement">The unique key element.</param> public GenericUniqueIndexProperty(UniqueElement uniqueKeyElement) { // Initialize the object. this.uniqueKeyElement = uniqueKeyElement; this.Name = this.uniqueKeyElement.Name; // /// <summary> // /// Gets the BuyerExternalId0Key unique index. // /// </summary> // public UniqueIndex<Buyer> BuyerExternalId0Key { get; } = new UniqueIndex<Buyer>("BuyerExternalId0Key").HasIndex(b => b.ExternalId0); this.Syntax = SyntaxFactory.PropertyDeclaration( SyntaxFactory.GenericName( SyntaxFactory.Identifier("UniqueIndex")) .WithTypeArgumentList( SyntaxFactory.TypeArgumentList( SyntaxFactory.SingletonSeparatedList <TypeSyntax>( SyntaxFactory.IdentifierName(this.uniqueKeyElement.Table.Name)))), SyntaxFactory.Identifier(this.Name)) .WithModifiers(GenericUniqueIndexProperty.Modifiers) .WithAccessorList(GenericUniqueIndexProperty.AccessorList) .WithLeadingTrivia(this.DocumentationComment); }
// --------------------------------------------------------------------------------------------------------------------------------------------------------- /// <summary> /// Shows the appropriate context menu, depending on the supplied Visual Context, for the specified pointed object. /// Returns the generated context menu. /// </summary> public ContextMenu ShowContextMenu(FrameworkElement VisualContext, UniqueElement PointedObject, UniqueElement DefaultPointedObject = null, Action CloseAction = null) { ContextMenu Result = null; if (PointedObject == null) { PointedObject = DefaultPointedObject; } if (PointedObject is Idea) { PointedObject = ((Idea)PointedObject).MainSymbol; } if (PointedObject is View) { Result = CurrentView.Presenter.DisplayContextMenu <View>((View)PointedObject, ContextMenuOptionsForViews, CloseAction); } else if (PointedObject is VisualSymbol) { Result = CurrentView.Presenter.DisplayContextMenu <VisualSymbol>((VisualSymbol)PointedObject, ContextMenuOptionsForVisualSymbols, CloseAction); } else if (PointedObject is VisualConnector) { Result = CurrentView.Presenter.DisplayContextMenu <VisualConnector>((VisualConnector)PointedObject, ContextMenuOptionsForVisualConnectors, CloseAction); } else if (PointedObject is VisualComplement) { Result = CurrentView.Presenter.DisplayContextMenu <VisualComplement>((VisualComplement)PointedObject, ContextMenuOptionsForVisualComplements, CloseAction); } return(Result); }
/// <summary> /// Creates an argument that creates a lambda expression for extracting the key from a class. /// </summary> /// <param name="uniqueKeyElement">The unique key element.</param> /// <param name="isAnonymous">Indicates we should create an anonymous key for Entity Framework.</param> /// <returns>An argument that extracts a key from an object.</returns> public static ExpressionSyntax GetUniqueKey(UniqueElement uniqueKeyElement, bool isAnonymous = false) { // Validate the parameter if (uniqueKeyElement == null) { throw new ArgumentNullException(nameof(uniqueKeyElement)); } // Used as a variable when constructing the lambda expression. string abbreviation = uniqueKeyElement.Table.Name[0].ToString(CultureInfo.InvariantCulture).ToLowerInvariant(); // This will create an expression for extracting the key from record. CSharpSyntaxNode syntaxNode = null; if (uniqueKeyElement.Columns.Count == 1) { // A simple key can be used like a value type. syntaxNode = SyntaxFactory.MemberAccessExpression( SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.IdentifierName(abbreviation), SyntaxFactory.IdentifierName(uniqueKeyElement.Columns[0].Column.Name)); } else { // A Compound key must be constructed from an anomymous type. List <SyntaxNodeOrToken> keyElements = new List <SyntaxNodeOrToken>(); foreach (ColumnReferenceElement columnReferenceElement in uniqueKeyElement.Columns) { if (keyElements.Count != 0) { keyElements.Add(SyntaxFactory.Token(SyntaxKind.CommaToken)); } if (isAnonymous) { keyElements.Add( SyntaxFactory.AnonymousObjectMemberDeclarator( SyntaxFactory.MemberAccessExpression( SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.IdentifierName(abbreviation), SyntaxFactory.IdentifierName(columnReferenceElement.Column.Name)))); } else { keyElements.Add( SyntaxFactory.Argument( SyntaxFactory.MemberAccessExpression( SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.IdentifierName(abbreviation), SyntaxFactory.IdentifierName(columnReferenceElement.Column.Name)))); } } if (isAnonymous) { // b => b.BuyerId or b => new { b.BuyerId, b.ExternalId0 } syntaxNode = SyntaxFactory.AnonymousObjectCreationExpression( SyntaxFactory.SeparatedList <AnonymousObjectMemberDeclaratorSyntax>(keyElements.ToArray())); } else { // b => b.BuyerId or p => ValueTuple.Create(p.Name, p.CountryCode) syntaxNode = SyntaxFactory.InvocationExpression( SyntaxFactory.MemberAccessExpression( SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.IdentifierName("ValueTuple"), SyntaxFactory.IdentifierName("Create"))) .WithArgumentList( SyntaxFactory.ArgumentList( SyntaxFactory.SeparatedList <ArgumentSyntax>(keyElements.ToArray()))); } } // this.BuyerKey = new UniqueIndex<Buyer>("BuyerKey").HasIndex(b => b.BuyerId); return(SyntaxFactory.SimpleLambdaExpression(SyntaxFactory.Parameter(SyntaxFactory.Identifier(abbreviation)), syntaxNode)); }
public static string Process(string input1, string input2, string input3) { string output = string.Empty; switch (input3) { case "add": output = Addition.Add(input1, input2).ToString(); break; case "subtraction": output = Subtraction.Sub(input1, input2).ToString(); break; case "multiplication": output = Multiplication.Mul(input1, input2).ToString(); break; case "division": output = Division.Div(input1, input2).ToString(); break; case "divby3notby6": output = Divisionbythreenotbysix.Run(input1).ToString(); break; case "armstrongornot": output = Armstrongnumber.Check(input1).ToString(); break; case "factorial": output = Factorial.Calculate(input1).ToString(); break; case "palindrome": output = PalindromeNumber.Find(input1).ToString(); break; case "reverse": output = ReverseNumber.Reverse(input1).ToString(); break; case "sumofdigits": output = Sumofdigits.Find(input1).ToString(); break; case "decimaltobinary": output = DecimaltoBinary.Converts(input1).ToString(); break; case "numberincharacter": output = NumbersInCharacters.Print(input1).ToString(); break; case "strreverse": output = StringReverse.Reverse(input1).ToString(); break; case "duplicate": output = DuplicateElement.Find(input1).ToString(); break; case "unique": output = UniqueElement.Return(input1).ToString(); break; case "strpalindrome": output = StringPalindrome.Find(input1).ToString(); break; case "length": output = StringLength.Calculate(input1).ToString(); break; case "vowels": output = NumofVowels.Print(input1).ToString(); break; case "search": output = CharacterSearching.Search(input1, input2).ToString(); break; case "count": output = WordCount.Count(input1).ToString(); break; case "date": output = DateandTime.Calculate(input1).ToString(); break; } return(output); }