CustomQueryBuilder::contains() - Code Metrics - raystech/laravel-starter-kit - Measure and Improve Code Quality continuously with Scrutinizer

CustomQueryBuilder::contains() A
last analyzed 2019-02-03 16:37 UTC

↳ Parent: CustomQueryBuilder

Complexity

Conditions	1
Paths	1

Size

Total Lines	2
Code Lines	1

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
eloc	1
dl	0
loc	2
c	0
b	0
f	0
rs	10
cc	1
nc	1
nop	2

<?php

namespace Raystech\StarterKit\Supports;

class CustomQueryBuilder
{
  private $relation_counter = 0;
  public function apply($query, $data) {
    $keyword = request('q');
    $data_filters = $data['allowedFilters'];

    $filter_prep = [
      'column'   => '',
      'operator' => 'contains',
      'query_1'  => '',
      'match'    => 'or', 
    ];

    foreach ($data_filters as $filter) {
      $filter_prep['column'] = $filter;
      $filter_prep['query_1'] = $keyword;
      $this->makeFilter($query, $filter_prep);
    }

    if(isset($data['f'])) {
      foreach ($data['f'] as $filter) {
        $filter['match'] = $data['filter_match'] ?? 'and';
        $this->makeFilter($query, $filter);
      }
    }

    // dd($this->relation_counter);
    return $query;
  }

  public function makeFilter($query, $filter) {
    if(strpos($filter['column'], '.') !== false) {
      // nested column
      list($relation, $filter['column']) = explode('.', $filter['column']);
      $filter['match'] = 'and';
      // $filter['match'] = 'or';

      if($filter['column'] == 'count') {
        $this->{camel_case($filter['operator'])}($filter, $query, $relation);

      } else {
        if($this->relation_counter == 0) {
          $query->whereHas($relation, function($q) use ($filter) {
            $this->{camel_case($filter['operator'])}($filter, $q);
          });
        } else {
          $query->orWhereHas($relation, function($q) use ($filter) {
            $this->{camel_case($filter['operator'])}($filter, $q);
          });
        }
        $this->relation_counter++;
      }
    } else {
      $this->relation_counter++;
      // normal column
      $this->{camel_case($filter['operator'])}($filter, $query);
    }
  }

  public function equalTo($filter, $query) {
    return $query->where($filter['column'], '=', $filter['query_1'], $filter['match']);
  }

  public function notEqualTo($filter, $query) {
    return $query->where($filter['column'], '<>', $filter['query_1'], $filter['match']);
  }

  public function lessThan($filter, $query) {
    return $query->where($filter['column'], '<', $filter['query_1'], $filter['match']);
  }

  public function greaterThan($filter, $query) {
    return $query->where($filter['column'], '>', $filter['query_1'], $filter['match']);
  }

  public function between($filter, $query) {
    return $query->whereBetween($filter['column'], [
      $filter['query_1'], $filter['query_2']
    ], $filter['match']);
  }

  public function notBetween($filter, $query) {
    return $query->whereNotBetween($filter['column'], [
      $filter['query_1'], $filter['query_2']
    ], $filter['match']);
  }

  public function contains($filter, $query) {
    return $query->where($filter['column'], 'like', '%'.$filter['query_1'].'%', $filter['match']);
  }

  public function startsWith($filter, $query) {
    return $query->where($filter['column'], 'like', $filter['query_1'].'%', $filter['match']);
  }

  public function endsWith($filter, $query) {
    return $query->where($filter['column'], 'like', '%'.$filter['query_1'], $filter['match']);
  }

  public function inThePast($filter, $query) {
    $end = now()->endOfDay();
    $begin = now();

    switch ($filter['query_2']) {
      case 'hours':
      $begin->subHours($filter['query_1']);
      break;
      case 'days':
      $begin->subDays($filter['query_1'])->startOfDay();
      break;
      case 'months':
      $begin->subMonths($filter['query_1'])->startOfDay();
      break;
      case 'years':
      $begin->subYears($filter['query_1'])->startOfDay();
      break;
      default:
      $begin->subDays($filter['query_1'])->startOfDay();
      break;
    }

    return $query->whereBetween($filter['column'], [$begin, $end], $filter['match']);
  }

  public function inTheNext($filter, $query) {
    $begin = now()->startOfDay();
    $end = now();

    switch ($filter['query_2']) {
      case 'hours':
      $begin->addHours($filter['query_1']);
      break;
      case 'days':
      $begin->addDays($filter['query_1'])->endOfDay();
      break;
      case 'months':
      $begin->addMonths($filter['query_1'])->endOfDay();
      break;
      case 'years':
      $begin->addYears($filter['query_1'])->endOfDay();
      break;
      default:
      $begin->addDays($filter['query_1'])->endOfDay();
      break;
    }

    return $query->whereBetween($filter['column'], [$begin, $end], $filter['match']);
  }

  public function inThePeriod($filter, $query)
  {
    $begin = now();
    $end = now();

    switch ($filter['query_1']) {
      case 'today':
      $begin->startOfDay();
      $end->endOfDay();
      break;

      case 'yesterday':
      $begin->subDay(1)->startOfDay();
      $end->subDay(1)->endOfDay();
      break;

      case 'tomorrow':
      $begin->addDay(1)->startOfDay();
      $end->addDay(1)->endOfDay();
      break;
      
      case 'last_month':
      $begin->subMonth(1)->startOfMonth();
      $end->subMonth(1)->endOfMonth();
      break;

      case 'this_month':
      $begin->startOfMonth();
      $end->endOfMonth();
      break;

      case 'next_month':
      $begin->addMonth(1)->startOfMonth();
      $end->addMonth(1)->endOfMonth();
      break;

      case 'last_year':
      $begin->subYear(1)->startOfYear();
      $end->subYear(1)->endOfYear();
      break;

      case 'this_year':
      $begin->startOfYear();
      $end->endOfYear();
      break;

      case 'next_year':
      $begin->addYear(1)->startOfYear();
      $end->addYear(1)->endOfYear();
      break;

      default:
        # code...
      break;
    }

    return $query->whereBetween($filter['column'], [$begin, $end], $filter['match']);

  }

  public function equalToCount($filter, $query, $relation) {
    return $query->has($relation, '=', $filter['query_1']);
  }

  public function notEqualToCount($filter, $query, $relation) {
    return $query->has($relation, '<>', $filter['query_1']);
  }

  public function lessThanCount($filter, $query, $relation) {
    return $query->has($relation, '<', $filter['query_1']);
  }

  public function greaterThanCount($filter, $query, $relation) {
    return $query->has($relation, '>', $filter['query_1']);
  }
}

1			<?php
2
3			namespace Raystech\StarterKit\Supports;
4
5			class CustomQueryBuilder
6			{
7			private $relation_counter = 0;
8			public function apply($query, $data) {
9			$keyword = request('q');
10			$data_filters = $data['allowedFilters'];
11
12			$filter_prep = [
13			'column' => '',
14			'operator' => 'contains',
15			'query_1' => '',
16			'match' => 'or',
17			];
18
19			foreach ($data_filters as $filter) {
20			$filter_prep['column'] = $filter;
21			$filter_prep['query_1'] = $keyword;
22			$this->makeFilter($query, $filter_prep);
23			}
24
25			if(isset($data['f'])) {
26			foreach ($data['f'] as $filter) {
27			$filter['match'] = $data['filter_match'] ?? 'and';
28			$this->makeFilter($query, $filter);
29			}
30			}
31
32			// dd($this->relation_counter);
33			return $query;
34			}
35
36			public function makeFilter($query, $filter) {
37			if(strpos($filter['column'], '.') !== false) {
38			// nested column
39			list($relation, $filter['column']) = explode('.', $filter['column']);
40			$filter['match'] = 'and';
41			// $filter['match'] = 'or';
42
43			if($filter['column'] == 'count') {
44			$this->{camel_case($filter['operator'])}($filter, $query, $relation);
45
46			} else {
47			if($this->relation_counter == 0) {
48			$query->whereHas($relation, function($q) use ($filter) {
49			$this->{camel_case($filter['operator'])}($filter, $q);
50			});
51			} else {
52			$query->orWhereHas($relation, function($q) use ($filter) {
53			$this->{camel_case($filter['operator'])}($filter, $q);
54			});
55			}
56			$this->relation_counter++;
57			}
58			} else {
59			$this->relation_counter++;
60			// normal column
61			$this->{camel_case($filter['operator'])}($filter, $query);
62			}
63			}
64
65			public function equalTo($filter, $query) {
66			return $query->where($filter['column'], '=', $filter['query_1'], $filter['match']);
67			}
68
69			public function notEqualTo($filter, $query) {
70			return $query->where($filter['column'], '<>', $filter['query_1'], $filter['match']);
71			}
72
73			public function lessThan($filter, $query) {
74			return $query->where($filter['column'], '<', $filter['query_1'], $filter['match']);
75			}
76
77			public function greaterThan($filter, $query) {
78			return $query->where($filter['column'], '>', $filter['query_1'], $filter['match']);
79			}
80
81			public function between($filter, $query) {
82			return $query->whereBetween($filter['column'], [
83			$filter['query_1'], $filter['query_2']
84			], $filter['match']);
85			}
86
87			public function notBetween($filter, $query) {
88			return $query->whereNotBetween($filter['column'], [
89			$filter['query_1'], $filter['query_2']
90			], $filter['match']);
91			}
92
93			public function contains($filter, $query) {
94			return $query->where($filter['column'], 'like', '%'.$filter['query_1'].'%', $filter['match']);
95			}
96
97			public function startsWith($filter, $query) {
98			return $query->where($filter['column'], 'like', $filter['query_1'].'%', $filter['match']);
99			}
100
101			public function endsWith($filter, $query) {
102			return $query->where($filter['column'], 'like', '%'.$filter['query_1'], $filter['match']);
103			}
104
105			public function inThePast($filter, $query) {
106			$end = now()->endOfDay();
107			$begin = now();
108
109			switch ($filter['query_2']) {
110			case 'hours':
111			$begin->subHours($filter['query_1']);
112			break;
113			case 'days':
114			$begin->subDays($filter['query_1'])->startOfDay();
115			break;
116			case 'months':
117			$begin->subMonths($filter['query_1'])->startOfDay();
118			break;
119			case 'years':
120			$begin->subYears($filter['query_1'])->startOfDay();
121			break;
122			default:
123			$begin->subDays($filter['query_1'])->startOfDay();
124			break;
125			}
126
127			return $query->whereBetween($filter['column'], [$begin, $end], $filter['match']);
128			}
129
130			public function inTheNext($filter, $query) {
131			$begin = now()->startOfDay();
132			$end = now();
133
134			switch ($filter['query_2']) {
135			case 'hours':
136			$begin->addHours($filter['query_1']);
137			break;
138			case 'days':
139			$begin->addDays($filter['query_1'])->endOfDay();
140			break;
141			case 'months':
142			$begin->addMonths($filter['query_1'])->endOfDay();
143			break;
144			case 'years':
145			$begin->addYears($filter['query_1'])->endOfDay();
146			break;
147			default:
148			$begin->addDays($filter['query_1'])->endOfDay();
149			break;
150			}
151
152			return $query->whereBetween($filter['column'], [$begin, $end], $filter['match']);
153			}
154
155			public function inThePeriod($filter, $query)
156			{
157			$begin = now();
158			$end = now();
159
160			switch ($filter['query_1']) {
161			case 'today':
162			$begin->startOfDay();
163			$end->endOfDay();
164			break;
165
166			case 'yesterday':
167			$begin->subDay(1)->startOfDay();
168			$end->subDay(1)->endOfDay();
169			break;
170
171			case 'tomorrow':
172			$begin->addDay(1)->startOfDay();
173			$end->addDay(1)->endOfDay();
174			break;
175
176			case 'last_month':
177			$begin->subMonth(1)->startOfMonth();
178			$end->subMonth(1)->endOfMonth();
179			break;
180
181			case 'this_month':
182			$begin->startOfMonth();
183			$end->endOfMonth();
184			break;
185
186			case 'next_month':
187			$begin->addMonth(1)->startOfMonth();
188			$end->addMonth(1)->endOfMonth();
189			break;
190
191			case 'last_year':
192			$begin->subYear(1)->startOfYear();
193			$end->subYear(1)->endOfYear();
194			break;
195
196			case 'this_year':
197			$begin->startOfYear();
198			$end->endOfYear();
199			break;
200
201			case 'next_year':
202			$begin->addYear(1)->startOfYear();
203			$end->addYear(1)->endOfYear();
204			break;
205
206			default:
207			# code...
208			break;
209			}
210
211			return $query->whereBetween($filter['column'], [$begin, $end], $filter['match']);
212
213			}
214
215			public function equalToCount($filter, $query, $relation) {
216			return $query->has($relation, '=', $filter['query_1']);
217			}
218
219			public function notEqualToCount($filter, $query, $relation) {
220			return $query->has($relation, '<>', $filter['query_1']);
221			}
222
223			public function lessThanCount($filter, $query, $relation) {
224			return $query->has($relation, '<', $filter['query_1']);
225			}
226
227			public function greaterThanCount($filter, $query, $relation) {
228			return $query->has($relation, '>', $filter['query_1']);
229			}
230			}

raystech / laravel-starter-kit

GitHub Access Token became invalid

CustomQueryBuilder::contains() A last analyzed 2019-02-03 16:37 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

CustomQueryBuilder::contains() A
last analyzed 2019-02-03 16:37 UTC