Beispiel #1
0
        internal static string getOperator(QueryComparisonOperators op)
        {
            switch (op)
            {
            case QueryComparisonOperators.EqualTo: goto default;

            case QueryComparisonOperators.GreaterOrEqual: return(">=");

            case QueryComparisonOperators.GreaterThan: return(">");

            case QueryComparisonOperators.IsLike: return("IS LIKE");

            case QueryComparisonOperators.IsNotLike: return("IS NOT LIKE");

            case QueryComparisonOperators.IsNotNull: return("IS NOT NULL");

            case QueryComparisonOperators.IsNull: return("IS NULL");

            case QueryComparisonOperators.LessOrEqual: return("<=");

            case QueryComparisonOperators.LessThan: return("<");

            case QueryComparisonOperators.NotEqualTo: return("!=");

            default:
                return("=");
            }
        }
Beispiel #2
0
        protected override IQueryBuilder <EventModel> CreateQueryBuilder(EventModel Source, QueryComparisonOperators Operator, bool IdOnly)
        {
            var queryBuilder = new QueryBuilder <EventModel>();

            if (Source.IsChanged(x => x.ID))
            {
                queryBuilder.Where(x => x.ID, Source.ID, Operator);
            }
            if (!IdOnly && Source.IsChanged(x => x.Code))
            {
                queryBuilder.Where(x => x.Code, Source.Code, Operator);
            }
            if (!IdOnly && Source.IsChanged(x => x.Content))
            {
                queryBuilder.Where(x => x.Content, Source.Content, Operator);
            }
            if (!IdOnly && Source.IsChanged(x => x.Type))
            {
                queryBuilder.Where(x => x.Type, Source.Type, Operator);
            }
            return(queryBuilder);
        }
        protected override IQueryBuilder <RoleModel> CreateQueryBuilder(RoleModel Source, QueryComparisonOperators Operator, bool IdOnly)
        {
            var queryBuilder = new QueryBuilder <RoleModel>();

            if (Source.IsChanged(x => x.ID))
            {
                queryBuilder.Where(x => x.ID, Source.ID, Operator);
            }
            if (!IdOnly && Source.IsChanged(x => x.Name))
            {
                queryBuilder.Where(x => x.Name, Source.Name, Operator);
            }
            if (!IdOnly && Source.IsChanged(x => x.Description))
            {
                queryBuilder.Where(x => x.Description, Source.Description, Operator);
            }
            if (!IdOnly && Source.IsChanged(x => x.Mode))
            {
                queryBuilder.Where(x => x.Mode, Source.Mode, Operator);
            }
            return(queryBuilder);
        }
Beispiel #4
0
 public DatabaseCondition(string Table1, string Column1, QueryLogicalOperators LogicalOperator, QueryComparisonOperators ComparisonOperator, Int32 Depth)
 {
     this.Table1             = Table1;
     this.Column1            = Column1;
     this.LogicalOperator    = LogicalOperator;
     this.ComparisonOperator = ComparisonOperator;
     this.Depth            = Depth;
     this.CanPerformAction = false;
     this.Action           = QueryColumnActions.None;
     this.Table2           = null;
     this.Column2          = null;
     this.Value            = null;
     this.Wildcard         = "*";
     this.CompareColumns   = false;
 }
Beispiel #5
0
        protected override IQueryBuilder <UserModel> CreateQueryBuilder(UserModel Source, QueryComparisonOperators Operator, bool IdOnly)
        {
            var queryBuilder = new QueryBuilder <UserModel>();

            if (Source.IsChanged(x => x.ID))
            {
                queryBuilder.Where(x => x.ID, Source.ID, Operator);
            }
            if (!IdOnly && Source.IsChanged(x => x.Login))
            {
                queryBuilder.Where(x => x.Login, Source.Login, Operator);
            }
            if (!IdOnly && Source.IsChanged(x => x.Email))
            {
                queryBuilder.Where(x => x.Email, Source.Email, Operator);
            }
            if (!IdOnly && Source.IsChanged(x => x.Name))
            {
                queryBuilder.Where(x => x.Name, Source.Name, Operator);
            }
            if (!IdOnly && Source.IsChanged(x => x.CreatedMethod))
            {
                queryBuilder.Where(x => x.CreatedMethod, Source.CreatedMethod, Operator);
            }
            if (!IdOnly && Source.IsChanged(x => x.Pin))
            {
                queryBuilder.Where(x => x.Pin, Source.Pin, Operator);
            }
            if (!IdOnly && Source.IsChanged(x => x.Manager))
            {
                queryBuilder.Where(x => x.Manager, Source.Manager, Operator);
            }
            if (!IdOnly && Source.IsChanged(x => x.Role))
            {
                queryBuilder.Where(x => x.Role, Source.Role, Operator);
            }
            return(queryBuilder);
        }
Beispiel #6
0
 protected abstract IQueryBuilder <M> CreateQueryBuilder(M Source, QueryComparisonOperators Operator, Boolean IdOnly);
        protected override IQueryBuilder <ActionModel> CreateQueryBuilder(ActionModel Source, QueryComparisonOperators Operator, bool IdOnly)
        {
            var queryBuilder = new QueryBuilder <ActionModel>();

            if (Source.IsChanged(x => x.ID))
            {
                queryBuilder.Where(x => x.ID, Source.ID, Operator);
            }
            return(queryBuilder);
        }