search based on raw column query solves issue #5

Author: jeffreydevreede

src/LiveControl/EloquentDataTable/DataTable.php

@@ -2,19 +2,22 @@
 namespace LiveControl\EloquentDataTable;
 
 use Exception;
+use Illuminate\Database\Eloquent\Model;
+use Illuminate\Database\Eloquent\Builder;
+use Illuminate\Database\Query\Expression as raw;
 use LiveControl\EloquentDataTable\VersionTransformers\Version110Transformer;
 use LiveControl\EloquentDataTable\VersionTransformers\VersionTransformerContract;
 
-use Illuminate\Database\Query\Expression as raw;
-use Illuminate\Database\Eloquent\Builder;
-use Illuminate\Database\Eloquent\Model;
 
 class DataTable
 {
     private $builder;
     private $columns;
     private $formatRowFunction;
 
+    /**
+     * @var VersionTransformerContract
+     */
     protected static $versionTransformer;
 
     private $rawColumns;
@@ -36,7 +39,7 @@ public function __construct($builder, $columns, $formatRowFunction = null)
         $this->setBuilder($builder);
         $this->setColumns($columns);
 
-        if ( $formatRowFunction !== null ) {
+        if ($formatRowFunction !== null) {
             $this->setFormatRowFunction($formatRowFunction);
         }
     }
@@ -48,7 +51,7 @@ public function __construct($builder, $columns, $formatRowFunction = null)
      */
     public function setBuilder($builder)
     {
-        if ( ! ($builder instanceof Builder || $builder instanceof Model) ) {
+        if ( ! ($builder instanceof Builder || $builder instanceof Model)) {
             throw new Exception('$builder variable is not an instance of Builder or Model.');
         }
 
@@ -87,6 +90,7 @@ public function setVersionTransformer(VersionTransformerContract $versionTransfo
     }
 
     /**
+     * Make the datatable response.
      * @return array
      * @throws Exception
      */
@@ -97,7 +101,7 @@ public function make()
         $this->rawColumns = $this->getRawColumns($this->columns);
         $this->columnNames = $this->getColumnNames();
 
-        if ( static::$versionTransformer === null ) {
+        if (static::$versionTransformer === null) {
             static::$versionTransformer = new Version110Transformer();
         }
 
@@ -111,7 +115,6 @@ public function make()
 
         $this->rows = $this->builder->get();
 
-        // format rows
         $rows = [];
         foreach ($this->rows as $row) {
             $rows[] = $this->formatRow($row);
@@ -127,10 +130,14 @@ public function make()
         ];
     }
 
+    /**
+     * @param $data
+     * @return array|mixed
+     */
     private function formatRow($data)
     {
         // if we have a custom format row function we trigger it instead of the default handling.
-        if ( $this->formatRowFunction !== null ) {
+        if ($this->formatRowFunction !== null) {
             $function = $this->formatRowFunction;
 
             return call_user_func($function, $data);
@@ -147,25 +154,31 @@ private function formatRow($data)
         return $data;
     }
 
+    /**
+     * @param $data
+     * @return mixed
+     */
     private function formatRowIndexes($data)
     {
-        if ( isset($data['id']) ) {
+        if (isset($data['id'])) {
             $data[static::$versionTransformer->transform('DT_RowId')] = $data['id'];
         }
         return $data;
     }
 
+    /**
+     * @return array
+     */
     private function getColumnNames()
     {
         $names = [];
         foreach ($this->columns as $index => $column) {
-            if ( $column instanceof ExpressionWithName ) {
+            if ($column instanceof ExpressionWithName) {
                 $names[] = $column->getName();
                 continue;
             }
 
-            if(is_string($column) && strstr($column, '.'))
-            {
+            if (is_string($column) && strstr($column, '.')) {
                 $column = explode('.', $column);
             }
 
@@ -174,6 +187,10 @@ private function getColumnNames()
         return $names;
     }
 
+    /**
+     * @param $columns
+     * @return array
+     */
     private function getRawColumns($columns)
     {
         $rawColumns = [];
@@ -183,14 +200,18 @@ private function getRawColumns($columns)
         return $rawColumns;
     }
 
+    /**
+     * @param $column
+     * @return raw|string
+     */
     private function getRawColumnQuery($column)
     {
-        if ( $column instanceof ExpressionWithName ) {
+        if ($column instanceof ExpressionWithName) {
             return $column->getExpression();
         }
 
-        if ( is_array($column) ) {
-            if ( $this->getDatabaseDriver() == 'sqlite' ) {
+        if (is_array($column)) {
+            if ($this->getDatabaseDriver() == 'sqlite') {
                 return '(' . implode(' || " " || ', $this->getRawColumns($column)) . ')';
             }
             return 'CONCAT(' . implode(', " ", ', $this->getRawColumns($column)) . ')';
@@ -199,27 +220,38 @@ private function getRawColumnQuery($column)
         return Model::resolveConnection()->getQueryGrammar()->wrap($column);
     }
 
+    /**
+     * @return string
+     */
     private function getDatabaseDriver()
     {
         return Model::resolveConnection()->getDriverName();
     }
 
+    /**
+     *
+     */
     private function addSelect()
     {
         $rawSelect = [];
         foreach ($this->columns as $index => $column) {
-            if ( isset($this->rawColumns[$index]) ) {
+            if (isset($this->rawColumns[$index])) {
                 $rawSelect[] = $this->rawColumns[$index] . ' as ' . Model::resolveConnection()->getQueryGrammar()->wrap($this->columnNames[$index]);
             }
         }
         $this->builder = $this->builder->select(new raw(implode(', ', $rawSelect)));
     }
 
+    /**
+     * @param $array
+     * @param bool|false $inForeach
+     * @return array|string
+     */
     private function arrayToCamelcase($array, $inForeach = false)
     {
         $result = [];
         foreach ($array as $value) {
-            if ( is_array($value) ) {
+            if (is_array($value)) {
                 $result += $this->arrayToCamelcase($value, true);
             }
             $value = explode('.', $value);
@@ -230,45 +262,63 @@ private function arrayToCamelcase($array, $inForeach = false)
         return (! $inForeach ? camel_case(implode('_', $result)) : $result);
     }
 
+    /**
+     * Add the filters based on the search value given.
+     * @return $this
+     */
     private function addFilters()
     {
         $search = static::$versionTransformer->getSearchValue();
-        if ( $search != '' ) {
+        if ($search != '') {
             $this->addAllFilter($search);
         }
         $this->addColumnFilters();
         return $this;
     }
 
+    /**
+     * Searches in all the columns.
+     * @param $search
+     */
     private function addAllFilter($search)
     {
         $this->builder = $this->builder->where(
             function ($query) use ($search) {
-                foreach ($this->columnNames as $column) {
-                    $query->orWhere($column, 'like', '%' . $search . '%');
+                foreach ($this->columns as $column) {
+                    $query->orWhere(
+                        new raw($this->getRawColumnQuery($column)),
+                        'like',
+                        '%' . $search . '%'
+                    );
                 }
             }
         );
     }
 
+    /**
+     * Add column specific filters.
+     */
     private function addColumnFilters()
     {
-        foreach ($this->columnNames as $i => $column) {
-            if ( static::$versionTransformer->isColumnSearched($i) ) {
+        foreach ($this->columns as $i => $column) {
+            if (static::$versionTransformer->isColumnSearched($i)) {
                 $this->builder->where(
-                    $column,
+                    new raw($this->getRawColumnQuery($column)),
                     'like',
                     '%' . static::$versionTransformer->getColumnSearchValue($i) . '%'
                 );
             }
         }
     }
 
+    /**
+     * Depending on the sorted column this will add orderBy to the builder.
+     */
     protected function addOrderBy()
     {
-        if ( static::$versionTransformer->isOrdered() ) {
+        if (static::$versionTransformer->isOrdered()) {
             foreach (static::$versionTransformer->getOrderedColumns() as $index => $direction) {
-                if ( isset($this->columnNames[$index]) ) {
+                if (isset($this->columnNames[$index])) {
                     $this->builder->orderBy(
                         $this->columnNames[$index],
                         $direction
@@ -278,14 +328,17 @@ protected function addOrderBy()
         }
     }
 
+    /**
+     * Adds the pagination limits to the builder
+     */
     private function addLimits()
     {
-        if ( isset($_POST[static::$versionTransformer->transform(
+        if (isset($_POST[static::$versionTransformer->transform(
                     'start'
                 )]) && $_POST[static::$versionTransformer->transform('length')] != '-1'
         ) {
             $this->builder->skip((int)$_POST[static::$versionTransformer->transform('start')])->take(
-                (int) $_POST[static::$versionTransformer->transform('length')]
+                (int)$_POST[static::$versionTransformer->transform('length')]
             );
         }
     }