Made it possible to sort on 1 to 1 relationship attributes (#1833)

* Made it possible to sort on 1 to 1 relationship attributes

* Added the possibility to do left, right and outer joins to the ORM, and filtering on joins

* Added to the orm a coalesce order filter which is needed to order on taskwrappername or taskname

* Added different types of joins to the abstractmodelfactory

* Added an additional way to parse the filters, needed for the taskwrappers to handle the unconventional relation between taskwrapper and task

* Fixed bug in creating join filter

---------

Co-authored-by: jessevz <jesse.van.zutphen@nfi.nl>
Co-authored-by: Sein Coray <s3inlc@hashes.org>

Author: 3 people

src/dba/AbstractModelFactory.class.php

@@ -562,6 +562,7 @@ public function getFromDB($pk): ?AbstractModel {
    * @return AbstractModel[]|AbstractModel Returns a list of matching objects or Null
    */
   private function filterWithJoin(array $options): array|AbstractModel {
+    $vals = array();
     $joins = $this->getJoins($options);
     $factories = array($this);
     $query = "SELECT " . Util::createPrefixedString($this->getMappedModelTable(), self::getMappedModelKeys($this->getNullObject()));
@@ -580,11 +581,14 @@ private function filterWithJoin(array $options): array|AbstractModel {
       }
       $match1 = self::getMappedModelKey($localFactory->getNullObject(), $join->getMatch1());
       $match2 = self::getMappedModelKey($joinFactory->getNullObject(), $join->getMatch2());
-      $query .= " INNER JOIN " . $joinFactory->getMappedModelTable() . " ON " . $localFactory->getMappedModelTable() . "." . $match1 . "=" . $joinFactory->getMappedModelTable() . "." . $match2 . " ";
+      $query .= " " . $join->getJoinType() . " JOIN " . $joinFactory->getMappedModelTable() . " ON " . $localFactory->getMappedModelTable() . "." . $match1 . "=" . $joinFactory->getMappedModelTable() . "." . $match2 . " ";
+      $joinQueryFilters = $join->getQueryFilters();
+      if (count($joinQueryFilters) > 0) {
+        $query .= $this->applyFilters($vals, $joinQueryFilters, true) ;
+      }
     }
 
     // Apply all normal filter to this query
-    $vals = array();
     if (array_key_exists("filter", $options)) {
       $query .= $this->applyFilters($vals, $options['filter']);
     }
@@ -605,7 +609,6 @@ private function filterWithJoin(array $options): array|AbstractModel {
     if (array_key_exists("limit", $options)) {
       $query .= $this->applyLimit($options['limit']);
     }
-    
     $dbh = self::getDB();
     $stmt = $dbh->prepare($query);
     $stmt->execute($vals);
@@ -709,7 +712,7 @@ public function filter(array $options, bool $single = false) {
    * @param $filters Filter|Filter[]
    * @return string
    */
-  private function applyFilters(&$vals, Filter|array $filters): string {
+  private function applyFilters(&$vals, Filter|array $filters, bool $isJoinFilter = false): string {
     $parts = array();
     if (!is_array($filters)) {
       $filters = array($filters);
@@ -730,6 +733,9 @@ private function applyFilters(&$vals, Filter|array $filters): string {
         $vals[] = $v;
       }
     }
+    if ($isJoinFilter) {
+      return " AND " . implode(" AND ", $parts);
+    }
     return " WHERE " . implode(" AND ", $parts);
   }
 
@@ -758,7 +764,7 @@ private function applyJoins($joins): string {
       }
       $match1 = self::getMappedModelKey($localFactory->getNullObject(), $join->getMatch1());
       $match2 = self::getMappedModelKey($joinFactory->getNullObject(), $join->getMatch2());
-      $query .= " INNER JOIN " . $joinFactory->getMappedModelTable() . " ON " . $localFactory->getMappedModelTable() . "." . $match1 . "=" . $joinFactory->getMappedModelTable() . "." . $match2 . " ";
+      $query .= " " . $join->getJoinType() . " JOIN " . $joinFactory->getMappedModelTable() . " ON " . $localFactory->getMappedModelTable() . "." . $match1 . "=" . $joinFactory->getMappedModelTable() . "." . $match2 . " ";
     }
     return $query;
   }

src/dba/CoalesceOrderFilter.class.php

@@ -0,0 +1,22 @@
+<?php
+
+namespace DBA;
+
+class CoalesceOrderFilter extends Order {
+  // The columns to do the COALESCE function on
+  private $columns;
+  private $type;
+  
+  function __construct($columns, $type) {
+    $this->columns = $columns;
+    $this->type = $type;
+  }
+  
+  function getQueryString(AbstractModelFactory $factory, bool $includeTable = false): string {
+    $mapped_columns = [];
+    foreach($this->columns as $column) {
+      array_push($mapped_columns, AbstractModelFactory::getMappedModelKey($factory->getNullObject(), $column));
+    }
+    return "COALESCE(" . implode(", ", $mapped_columns) . ") " . $this->type;
+  }
+}

src/dba/Join.class.php

@@ -17,4 +17,14 @@ abstract function getMatch1();
    * @return string
    */
   abstract function getMatch2();
+  
+  /**
+   * @return string
+   */
+  abstract function getJoinType();
+
+  /**
+   * @return QueryFilter[] array of queryfilters that have to be performed on the join
+   */
+  abstract function getQueryFilters();
 }

src/dba/JoinFilter.class.php

@@ -27,18 +27,36 @@ class JoinFilter extends Join {
    * @var AbstractModelFactory
    */
   private $overrideOwnFactory;
+
+  /**
+   * @var string
+   */
+  private $joinType;
+
+  /**
+   * @var QueryFilter[] array of queryfilters that have to be performed on the join
+   */
+  private $queryFilters;
+
+  // string constants for the join types
+  public const string INNER = "INNER";
+  public const string LEFT = "LEFT";
+  public const string RIGHT = "RIGHT";
 
   /**
    * JoinFilter constructor.
    * @param $otherFactory AbstractModelFactory
    * @param $matching1 string
    * @param $matching2 string
    * @param $overrideOwnFactory AbstractModelFactory
+   * @param $joinType string is normally inner, left or right
    */
-  function __construct($otherFactory, $matching1, $matching2, $overrideOwnFactory = null) {
+  function __construct($otherFactory, $matching1, $matching2, $overrideOwnFactory = null, $joinType = JoinFilter::INNER, $queryFilters = []) {
     $this->otherFactory = $otherFactory;
     $this->match1 = $matching1;
     $this->match2 = $matching2;
+    $this->joinType = $joinType;
+    $this->queryFilters = $queryFilters;
 
     $this->otherTableName = $this->otherFactory->getMappedModelTable();
     $this->overrideOwnFactory = $overrideOwnFactory;
@@ -62,6 +80,23 @@ function getMatch2() {
   function getOtherTableName() {
     return $this->otherTableName;
   }
+
+  function getJoinType() {
+    return $this->joinType;
+  }
+
+  function setJoinType($joinType) {
+    $this->joinType = $joinType;
+  }
+
+
+  function getQueryFilters() {
+    return $this->queryFilters;
+  }
+  
+  function setQueryFilters(array $queryFilters) {
+    $this->queryFilters = $queryFilters;
+  }
 
   /**
    * @return AbstractModelFactory

src/dba/OrderFilter.class.php

@@ -15,6 +15,14 @@ function __construct($by, $type, $overrideFactory = null) {
     $this->type = $type;
     $this->overrideFactory = $overrideFactory;
   }
+
+  function getBy(): string {
+    return $this->by;
+  }
+
+  function getType(): string {
+    return $this->type;
+  }
 
   function getQueryString(AbstractModelFactory $factory, bool $includeTable = false): string {
     if ($this->overrideFactory != null) {

src/dba/init.php

@@ -13,6 +13,7 @@
 require_once(dirname(__FILE__) . "/Aggregation.class.php");
 require_once(dirname(__FILE__) . "/Filter.class.php");
 require_once(dirname(__FILE__) . "/Order.class.php");
+require_once(dirname(__FILE__) . "/CoalesceOrderFilter.class.php");
 require_once(dirname(__FILE__) . "/Join.class.php");
 require_once(dirname(__FILE__) . "/Group.class.php");
 require_once(dirname(__FILE__) . "/Limit.class.php");

src/inc/apiv2/common/AbstractBaseAPI.class.php

@@ -144,6 +144,16 @@ protected function getFeatures(): array {
     }
     return $features;
   }
+
+  /**
+   * Get features based on DBA model features
+   *
+   * @param string $dbaClass is the dba class to get the features from
+   */
+  //TODO doesnt retrieve features based on form fields, could be done by adding api class in relationship objects
+  final protected function getFeaturesOther(string $dbaClass): array {
+    return call_user_func($dbaClass . '::getFeatures');
+  }
 
   protected function getUpdateHandlers($id, $current_user): array {
     return [];
@@ -174,6 +184,11 @@ public function getAliasedFeatures(): array {
     $features = $this->getFeatures();
     return $this->mapFeatures($features);
   }
+
+  public function getAliasedFeaturesOther($dbaClass): array {
+    $features = $this->getFeaturesOther($dbaClass);
+    return $this->mapFeatures($features);
+  }
 
   final protected function mapFeatures($features): array {
     $mappedFeatures = [];
@@ -183,6 +198,18 @@ final protected function mapFeatures($features): array {
     }
     return $mappedFeatures;
   }
+
+  public static function getToOneRelationships(): array {
+    return [];
+  }
+  
+  public static function getToManyRelationships(): array {
+    return [];
+  }
+
+  public function getAllRelationships(): array {
+    return array_merge($this->getToOneRelationships(), $this->getToManyRelationships());
+  }
 
   /**
    * Retrieve currently logged-in user
@@ -1145,19 +1172,39 @@ protected function makeOrderFilterTemplates(Request $request, array $features, s
     $orderings = $this->getQueryParameterAsList($request, 'sort');
     $contains_primary_key = false;
     foreach ($orderings as $order) {
-      if (preg_match('/^(?P<operator>[-])?(?P<key>[_a-zA-Z]+)$/', $order, $matches)) {
+      $factory = null;
+      $joinKey = null;
+      $features_sort = $features;
+      if (preg_match('/^(?P<operator>[-])?(?P<key>[_a-zA-Z.]+)$/', $order, $matches)) {
         // Special filtering of _id to use for uniform access to model primary key
         $cast_key = $matches['key'] == 'id' ? $this->getPrimaryKey() : $matches['key'];
         if ($cast_key == $this->getPrimaryKey()) {
           $contains_primary_key = true;
         }
-        if (array_key_exists($cast_key, $features)) {
-          $remappedKey = $features[$cast_key]['dbname'];
+        if (strpos($cast_key, ".")) {
+          $parts = explode(".", $cast_key);
+            if (count($parts) == 2) { // Only relations of 1 deep allowed ex. task.keyspace
+              $relationString = $parts[0];
+              //currently getting all relationships, but its probably only possible to sort on  1 to 1 relations
+              $relations = $this->getAllRelationships();
+              if (array_key_exists($relationString, $relations)) {
+                $relationClass = $relations[$relationString]['relationType'];
+                $relationFeatures = $this->getAliasedFeaturesOther($relationClass);
+                $factory = $this->getModelFactory($relationClass);
+                $joinKey = $relations[$relationString]['relationKey'];
+                $key = $relations[$relationString]['key'];
+                $features_sort = $relationFeatures;
+                $cast_key = $parts[1];
+              }
+            }
+          }
+        if (array_key_exists($cast_key, $features_sort)) {
+          $remappedKey = $features_sort[$cast_key]['dbname'];
           $type = ($matches['operator'] == '-') ? "DESC" : "ASC";
           if ($reverseSort) {
             $type = ($type == "ASC") ? "DESC" : "ASC";
           }
-          $orderTemplates[] = ['by' => $remappedKey, 'type' => $type];
+          $orderTemplates[] = ['by' => $remappedKey, 'type' => $type, 'factory' => $factory, 'joinKey' => $joinKey, 'key' => $key];
         }
         else {
           throw new HttpForbidden("Ordering parameter '" . $order . "' is not valid");
@@ -1170,7 +1217,7 @@ protected function makeOrderFilterTemplates(Request $request, array $features, s
 
     //when no primary key has been added in the sort parameter, add the default case of sorting on primary key as last sort
     if (!$contains_primary_key) {
-      $orderTemplates[] = ['by' => $this->getPrimaryKey(), 'type' => $defaultSort];
+      $orderTemplates[] = ['by' => $this->getPrimaryKey(), 'type' => $defaultSort, 'factory' => null, 'joinKey' => null];
     }
 
     return $orderTemplates;