public override DbExpression Visit(DbScanExpression expression)
        {
            var column = EdmHelper.GetFactoryColumnName(expression.Target.ElementType);

            if (!string.IsNullOrEmpty(column))
            {
                // Get the current expression
                var dbExpression = base.Visit(expression);
                // Get the current expression binding
                var currentExpressionBinding = DbExpressionBuilder.Bind(dbExpression);

                //FactoryId = @Paramname_1
                // Create the variable reference in order to create the property
                var variableReferenceLeftSide = DbExpressionBuilder.Variable(currentExpressionBinding.VariableType,
                                                                             currentExpressionBinding.VariableName);
                // Create the property based on the variable in order to apply the equality
                var tenantPropertyLeftSide = DbExpressionBuilder.Property(variableReferenceLeftSide, column);
                // Create the parameter which is an object representation of a sql parameter.
                // We have to create a parameter and not perform a direct comparison with Equal function for example
                // as this logic is cached per query and called only once
                var tenantParameterLeftSide = DbExpressionBuilder.Parameter(tenantPropertyLeftSide.Property.TypeUsage,
                                                                            FactoryConstants.FactoryIdFilterParameterName);
                // Apply the equality between property and parameter.
                var filterExpressionLeftSide = DbExpressionBuilder.Equal(tenantPropertyLeftSide, tenantParameterLeftSide);

                //1 = @Paramname_2
                // Create the variable reference in order to create the property
                var variableReferenceRightSide = DbExpressionBuilder.Variable(currentExpressionBinding.VariableType,
                                                                              currentExpressionBinding.VariableName);
                // Create the property based on the variable in order to apply the equality
                var tenantPropertyRightSide = DbExpression.FromInt32(1);
                // Create the parameter which is an object representation of a sql parameter.
                // We have to create a parameter and not perform a direct comparison with Equal function for example
                // as this logic is cached per query and called only once
                var tenantParameterRightSide = DbExpressionBuilder.Parameter(TypeUsage.CreateDefaultTypeUsage(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Int32)),
                                                                             FactoryConstants.FactoryOverrideFilterParameterName);
                // Apply the equality between property and parameter.
                var filterExpressionRightSide = DbExpressionBuilder.Equal(tenantPropertyRightSide, tenantParameterRightSide);
                DbExpressionBuilder.
                var filterExpression = DbExpressionBuilder.Or(filterExpressionLeftSide, filterExpressionRightSide);

                // Apply the filtering to the initial query
                return(DbExpressionBuilder.Filter(currentExpressionBinding, filterExpression));
            }

            return(base.Visit(expression));
        }
Beispiel #2
0
        public virtual void TreeCreated(DbCommandTreeInterceptionContext interceptionContext)
        {
            if (interceptionContext.OriginalResult.DataSpace == DataSpace.SSpace)
            {
                // Check that there is an authenticated user in this context
                var identity = Thread.CurrentPrincipal.Identity;
                if (identity == null)
                {
                    return;
                }
                //var userIdclaim = identity.Claims.SingleOrDefault(c => c.Type == ClaimTypes.NameIdentifier);
                //if (userIdclaim == null)
                //{
                //    return;
                //}
                // In case of query command change the query by adding a filtering based on tenantId
                var queryCommand = interceptionContext.Result as DbQueryCommandTree;
                if (queryCommand != null)
                {
                    var newQuery = queryCommand.Query.Accept(new FactoryQueryVisitor());
                    interceptionContext.Result = new DbQueryCommandTree(
                        queryCommand.MetadataWorkspace,
                        queryCommand.DataSpace,
                        newQuery);
                    return;
                }

                var insertCommand = interceptionContext.Result as DbInsertCommandTree;
                if (insertCommand != null)
                {
                    var column = EdmHelper.GetFactoryColumnName(insertCommand.Target.VariableType.EdmType);
                    if (!string.IsNullOrEmpty(column))
                    {
                        // Create the variable reference in order to create the property
                        var variableReference = DbExpressionBuilder.Variable(insertCommand.Target.VariableType,
                                                                             insertCommand.Target.VariableName);
                        // Create the property to which will assign the correct value
                        var tenantProperty = DbExpressionBuilder.Property(variableReference, column);
                        // Create the set clause, object representation of sql insert command
                        var tenantSetClause =
                            DbExpressionBuilder.SetClause(tenantProperty, DbExpression.FromString("1"));

                        // Remove potential assignment of tenantId for extra safety
                        var filteredSetClauses =
                            insertCommand.SetClauses.Cast <DbSetClause>()
                            .Where(sc => ((DbPropertyExpression)sc.Property).Property.Name != column);

                        // Construct the final clauses, object representation of sql insert command values
                        var finalSetClauses =
                            new ReadOnlyCollection <DbModificationClause>
                                (new List <DbModificationClause>(filteredSetClauses)
                        {
                            tenantSetClause
                        });

                        var newInsertCommand = new DbInsertCommandTree(
                            insertCommand.MetadataWorkspace,
                            insertCommand.DataSpace,
                            insertCommand.Target,
                            finalSetClauses,
                            insertCommand.Returning);

                        interceptionContext.Result = newInsertCommand;
                        return;
                    }
                }
            }
        }