Merge branch 'master' into settings-bundle

src/DataTables/AttachmentDataTable.php

@@ -34,6 +34,7 @@ use App\Services\EntityURLGenerator;
 use Doctrine\ORM\QueryBuilder;
 use Omines\DataTablesBundle\Adapter\Doctrine\ORM\SearchCriteriaProvider;
 use Omines\DataTablesBundle\Adapter\Doctrine\ORMAdapter;
+use Omines\DataTablesBundle\Column\NumberColumn;
 use Omines\DataTablesBundle\Column\TextColumn;
 use Omines\DataTablesBundle\DataTable;
 use Omines\DataTablesBundle\DataTableTypeInterface;
@@ -84,6 +85,11 @@ final class AttachmentDataTable implements DataTableTypeInterface
             },
         ]);
 
+        $dataTable->add('id', NumberColumn::class, [
+            'label' => $this->translator->trans('part.table.id'),
+            'visible' => false,
+        ]);
+
         $dataTable->add('name', TextColumn::class, [
             'label' => 'attachment.edit.name',
             'orderField' => 'NATSORT(attachment.name)',

src/DataTables/Filters/Constraints/EntityConstraint.php

@@ -137,7 +137,7 @@ class EntityConstraint extends AbstractConstraint
         }
 
         //We need to handle null values differently, as they can not be compared with == or !=
-        if (!$this->value instanceof AbstractDBElement) {
+        if ($this->value === null) {
             if($this->operator === '=' || $this->operator === 'INCLUDING_CHILDREN') {
                 $queryBuilder->andWhere(sprintf("%s IS NULL", $this->property));
                 return;
@@ -152,8 +152,9 @@ class EntityConstraint extends AbstractConstraint
         }
 
         if($this->operator === '=' || $this->operator === '!=') {
-           $this->addSimpleAndConstraint($queryBuilder, $this->property, $this->identifier, $this->operator, $this->value);
-           return;
+            //Include null values on != operator, so that really all values are returned that are not equal to the given value
+            $this->addSimpleAndConstraint($queryBuilder, $this->property, $this->identifier, $this->operator, $this->value, $this->operator === '!=');
+            return;
         }
 
         //Otherwise retrieve the children list and apply the operator to it
@@ -168,7 +169,8 @@ class EntityConstraint extends AbstractConstraint
             }
 
             if ($this->operator === 'EXCLUDING_CHILDREN') {
-                $this->addSimpleAndConstraint($queryBuilder, $this->property, $this->identifier, 'NOT IN', $list);
+                //Include null values in the result, so that all elements that are not in the list are returned
+                $this->addSimpleAndConstraint($queryBuilder, $this->property, $this->identifier, 'NOT IN', $list, true);
                 return;
             }
         } else {

src/DataTables/Filters/Constraints/FilterTrait.php

@@ -56,8 +56,14 @@ trait FilterTrait
 
     /**
      * Adds a simple constraint in the form of (property OPERATOR value) (e.g. "part.name = :name") to the given query builder.
+     * @param  QueryBuilder  $queryBuilder The query builder to add the constraint to
+     * @param  string  $property The property to compare
+     * @param  string  $parameterIdentifier The identifier for the parameter
+     * @param  string  $comparison_operator The comparison operator to use
+     * @param  mixed  $value The value to compare to
+     * @param  bool  $include_null If true, the result of this constraint will also include null values of this property (useful for exclusion filters)
      */
-    protected function addSimpleAndConstraint(QueryBuilder $queryBuilder, string $property, string $parameterIdentifier, string $comparison_operator, mixed $value): void
+    protected function addSimpleAndConstraint(QueryBuilder $queryBuilder, string $property, string $parameterIdentifier, string $comparison_operator, mixed $value, bool $include_null = false): void
     {
         if ($comparison_operator === 'IN' || $comparison_operator === 'NOT IN') {
             $expression = sprintf("%s %s (:%s)", $property, $comparison_operator, $parameterIdentifier);
@@ -65,6 +71,10 @@ trait FilterTrait
             $expression = sprintf("%s %s :%s", $property, $comparison_operator, $parameterIdentifier);
         }
 
+        if ($include_null) {
+            $expression = sprintf("(%s OR %s IS NULL)", $expression, $property);
+        }
+
         if($this->useHaving || $this->isAggregateFunctionString($property)) { //If the property is an aggregate function, we have to use the "having" instead of the "where"
             $queryBuilder->andHaving($expression);
         } else {

src/DataTables/Filters/Constraints/Part/TagsConstraint.php

@@ -85,15 +85,18 @@ class TagsConstraint extends AbstractConstraint
      */
     protected function getExpressionForTag(QueryBuilder $queryBuilder, string $tag): Orx
     {
+        //Escape any %, _ or \ in the tag
+        $tag = addcslashes($tag, '%_\\');
+
         $tag_identifier_prefix = uniqid($this->identifier . '_', false);
 
         $expr = $queryBuilder->expr();
 
         $tmp = $expr->orX(
-            $expr->like($this->property, ':' . $tag_identifier_prefix . '_1'),
-            $expr->like($this->property, ':' . $tag_identifier_prefix . '_2'),
-            $expr->like($this->property, ':' . $tag_identifier_prefix . '_3'),
-            $expr->eq($this->property, ':' . $tag_identifier_prefix . '_4'),
+            'ILIKE(' . $this->property . ', :' . $tag_identifier_prefix . '_1) = TRUE',
+            'ILIKE(' . $this->property . ', :' . $tag_identifier_prefix . '_2) = TRUE',
+            'ILIKE(' . $this->property . ', :' . $tag_identifier_prefix . '_3) = TRUE',
+            'ILIKE(' . $this->property . ', :' . $tag_identifier_prefix . '_4) = TRUE',
         );
 
         //Set the parameters for the LIKE expression, in each variation of the tag (so with a comma, at the end, at the beginning, and on both ends, and equaling the tag)
@@ -130,6 +133,7 @@ class TagsConstraint extends AbstractConstraint
             return;
         }
 
+        //@phpstan-ignore-next-line Keep this check to ensure that everything has the same structure even if we add a new operator
         if ($this->operator === 'NONE') {
             $queryBuilder->andWhere($queryBuilder->expr()->not($queryBuilder->expr()->orX(...$tagsExpressions)));
             return;

src/DataTables/Filters/Constraints/TextConstraint.php

@@ -107,7 +107,8 @@ class TextConstraint extends AbstractConstraint
         }
 
         if ($like_value !== null) {
-            $this->addSimpleAndConstraint($queryBuilder, $this->property, $this->identifier, 'LIKE', $like_value);
+            $queryBuilder->andWhere(sprintf('ILIKE(%s, :%s) = TRUE', $this->property, $this->identifier));
+            $queryBuilder->setParameter($this->identifier, $like_value);
             return;
         }
 

src/DataTables/Filters/PartSearchFilter.php

@@ -21,7 +21,6 @@ declare(strict_types=1);
  *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 namespace App\DataTables\Filters;
-
 use Doctrine\ORM\QueryBuilder;
 
 class PartSearchFilter implements FilterInterface
@@ -132,15 +131,15 @@ class PartSearchFilter implements FilterInterface
                 return sprintf("REGEXP(%s, :search_query) = TRUE", $field);
             }
 
-            return sprintf("%s LIKE :search_query", $field);
+            return sprintf("ILIKE(%s, :search_query) = TRUE", $field);
         }, $fields_to_search);
 
-        //Add Or concatation of the expressions to our query
+        //Add Or concatenation of the expressions to our query
         $queryBuilder->andWhere(
             $queryBuilder->expr()->orX(...$expressions)
         );
 
-        //For regex we pass the query as is, for like we add % to the start and end as wildcards
+        //For regex, we pass the query as is, for like we add % to the start and end as wildcards
         if ($this->regex) {
             $queryBuilder->setParameter('search_query', $this->keyword);
         } else {

src/DataTables/PartsDataTable.php

@@ -138,7 +138,8 @@ final class PartsDataTable implements DataTableTypeInterface
             ])
             ->add('storelocation', TextColumn::class, [
                 'label' => $this->translator->trans('part.table.storeLocations'),
-                'orderField' => 'NATSORT(_storelocations.name)',
+                //We need to use a aggregate function to get the first store location, as we have a one-to-many relation
+                'orderField' => 'NATSORT(MIN(_storelocations.name))',
                 'render' => fn ($value, Part $context) => $this->partDataTableHelper->renderStorageLocations($context),
             ], alias: 'storage_location')
 

src/DataTables/ProjectBomEntriesDataTable.php

@@ -87,16 +87,14 @@ class ProjectBomEntriesDataTable implements DataTableTypeInterface
                     if(!$context->getPart() instanceof Part) {
                         return htmlspecialchars((string) $context->getName());
                     }
-                    if($context->getPart() instanceof Part) {
-                        $tmp = $this->partDataTableHelper->renderName($context->getPart());
-                        if($context->getName() !== null && $context->getName() !== '') {
-                            $tmp .= '<br><b>'.htmlspecialchars($context->getName()).'</b>';
-                        }
-                        return $tmp;
-                    }
 
-                    //@phpstan-ignore-next-line
-                    throw new \RuntimeException('This should never happen!');
+                    //Part exists if we reach this point
+
+                    $tmp = $this->partDataTableHelper->renderName($context->getPart());
+                    if($context->getName() !== null && $context->getName() !== '') {
+                        $tmp .= '<br><b>'.htmlspecialchars($context->getName()).'</b>';
+                    }
+                    return $tmp;
                 },
             ])
             ->add('ipn', TextColumn::class, [