rework aux lock rules, use sorm model, deprecate old class and let name and description be translatable, fixes #1791

Closes #1791

Merge request studip/studip!1177

1 files changed, 96 insertions, 37 deletions

diff --git a/lib/models/AuxLockRule.php b/lib/models/AuxLockRule.php
index d0686a9..4bf8e8b 100644
--- a/lib/models/AuxLockRule.php
+++ b/lib/models/AuxLockRule.php
@@ -13,31 +13,75 @@
  * @license     http://www.gnu.org/licenses/gpl-2.0.html GPL version 2
  * @category    Stud.IP
  * @since       3.0
+ *
  * @property string lock_id database column
  * @property string id alias column for lock_id
  * @property string name database column
  * @property string description database column
- * @property string attributes database column
- * @property string sorting database column
+ * @property JSONArrayObject attributes database column
+ * @property JSONArrayObject sorting database column
  * @property array datafields computed column
  * @property string order computed column
- * @property Course course belongs_to Course
+ * @property Course[]|SimpleORMapCollection courses has_and_belongs_to_many Courses
  */
 class AuxLockRule extends SimpleORMap
 {
     protected static function configure($config = [])
     {
         $config['db_table'] = 'aux_lock_rules';
-        $config['belongs_to']['course'] = [
-            'class_name' => Course::class,
-            'foreign_key' => 'lock_id',
-            'assoc_foreign_key' => 'aux_lock_rule',
+
+        $config['has_many'] = [
+            'courses' => [
+                'class_name'        => Course::class,
+                'foreign_key'       => 'lock_id',
+                'assoc_foreign_key' => 'aux_lock_rule',
+            ],
+        ];
+
+        $config['additional_fields'] = [
+            'datafields' => true
+        ];
+
+        $config['serialized_fields'] = [
+            'attributes' => JSONArrayObject::class,
+            'sorting'    => JSONArrayObject::class,
         ];
-        $config['additional_fields']['datafields'] = true;
-        $config['additional_fields']['order'] = true;
+
+        $config['i18n_fields'] = [
+            'name'        => true,
+            'description' => true,
+        ];
+
+        $config['registered_callbacks'] = [
+            'before_store' => [
+                function (AuxLockRule $rule) {
+                    $rule->sorting = array_filter($rule->sorting->getArrayCopy(), function ($id) use ($rule) {
+                        return $rule->attributes->contains($id);
+                    }, ARRAY_FILTER_USE_KEY);
+                },
+            ],
+            'before_delete' => [
+                function (AuxLockRule $rule) {
+                    return count($rule->courses) === 0;
+                },
+            ]
+        ];
+
         parent::configure($config);
     }
 
+    public static function findOneByCourse(Course $course): ?AuxLockRule
+    {
+        return self::findOneByCourseId($course->id);
+    }
+
+    public static function findOneByCourseId(string $course_id): ?AuxLockRule
+    {
+        $condition = "JOIN seminare ON lock_id = aux_lock_rule
+                      WHERE Seminar_id = ?";
+        return self::findOneBySQL($condition, [$course_id]);
+    }
+
     /**
      * Cache to avoid loading datafields for a user more than once
      */
@@ -50,8 +94,8 @@ class AuxLockRule extends SimpleORMap
      */
     public function getDatafields()
     {
-        $attributes = json_decode($this->attributes, true) ?: [];
-        $sorting    = json_decode($this->sorting, true) ?: [];
+        $attributes = $this->attributes->getArrayCopy();
+        $sorting    = $this->sorting->getArrayCopy();
 
         foreach ($attributes as $key => $attr) {
             if (!$attr) {
@@ -64,11 +108,8 @@ class AuxLockRule extends SimpleORMap
 
     /**
      * Updates a datafield of a courseMember by the given data
-     *
-     * @param object $member
-     * @param object $data
      */
-    public function updateMember($member, $data)
+    public function updateMember(CourseMember $member, array $data)
     {
         foreach ($data as $key => $value) {
             $datafield = current($this->getDatafield($member, $key));
@@ -88,23 +129,22 @@ class AuxLockRule extends SimpleORMap
      */
     public function getCourseData($course = null, $display_only = false)
     {
-
         // set course
         if (!$course) {
             $course = $this->course;
         }
 
         $mapping = [
-            'vadozent' => join(', ', $course->members->findBy('status', 'dozent')->getUserFullname()),
+            'vadozent'   => join(', ', $course->members->findBy('status', 'dozent')->getUserFullname()),
             'vasemester' => $course->start_semester->name,
-            'vatitle' => $course->name,
-            'vanr' => $course->VeranstaltungsNummer,
+            'vatitle'    => $course->name,
+            'vanr'       => $course->veranstaltungsnummer,
         ];
         $head_mapping = [
-            'vadozent' => _('Dozenten'),
+            'vadozent'   => _('Dozenten'),
             'vasemester' => _('Semester'),
-            'vatitle' => _('Veranstaltungstitel'),
-            'vanr' => _('Veranstaltungsnummer'),
+            'vatitle'    => _('Veranstaltungstitel'),
+            'vanr'       => _('Veranstaltungsnummer'),
         ];
 
         // start collecting entries
@@ -145,38 +185,44 @@ class AuxLockRule extends SimpleORMap
         return $result;
     }
 
-    public function getMemberData($member)
+    public function getMemberData(CourseMember $member)
     {
         $datafields = SimpleCollection::createFromArray(DatafieldEntryModel::findByModel($member));
 
         $result = [];
-        foreach (array_keys($this->datafields) as $field) {
+        foreach ($this->attributes as $field) {
             // since we have no only datafields we have to filter!
-            if ($new = $datafields->findOneBy('datafield_id', $field)) {
+            $new = $datafields->findOneBy('datafield_id', $field);
+            if ($new) {
                 $result[] = $new;
             }
         }
+
+        usort($result, function (DatafieldEntryModel $a, DatafieldEntryModel $b) {
+            $a_order = $this->sorting[$a->datafield_id] ?? 0;
+            $b_order = $this->sorting[$b->datafield_id] ?? 0;
+            return $a_order - $b_order;
+        });
+
         return $result;
     }
 
     /**
      * Caching for the datafields
-     * @param type $member
-     * @param type $fieldID
-     * @return null
      */
-     private function getDatafield($member, $fieldID)
+     private function getDatafield(CourseMember $member, $field_id): ?array
      {
-         if (mb_strlen($fieldID) == 32) {
-             if (!array_key_exists($fieldID, $this->datafieldCache)) {
-                 $this->datafieldCache[$fieldID] = DataField::find($fieldID);
+         if (mb_strlen($field_id) === 32) {
+             if (!array_key_exists($field_id, $this->datafieldCache)) {
+                 $this->datafieldCache[$field_id] = DataField::find($field_id);
              }
-             if (isset($this->datafieldCache[$fieldID])) {
-                 if ($this->datafieldCache[$fieldID]->object_type == 'usersemdata') {
-                     $field = current(DatafieldEntryModel::findByModel($member, $fieldID));
+             if (isset($this->datafieldCache[$field_id])) {
+                 $field = null;
+                 if ($this->datafieldCache[$field_id]->object_type === 'usersemdata') {
+                     $field = current(DatafieldEntryModel::findByModel($member, $field_id));
                  }
-                 if ($this->datafieldCache[$fieldID]->object_type == 'user') {
-                     $field = current(DatafieldEntryModel::findByModel(User::find($member->user_id), $fieldID));
+                 if ($this->datafieldCache[$field_id]->object_type === 'user') {
+                     $field = current(DatafieldEntryModel::findByModel(User::find($member->user_id), $field_id));
                  }
                  if ($field) {
                      $range_id = $field->sec_range_id ? [$field->range_id, $field->sec_range_id] : $field->range_id;
@@ -185,6 +231,19 @@ class AuxLockRule extends SimpleORMap
                  }
              }
          }
+
+         return null;
      }
 
+     public static function validateFields(array $fields): bool
+     {
+         $entries = DataField::getDataFields('usersemdata');
+         foreach ($entries as $entry) {
+             if (in_array($entry->id, $fields)) {
+                 return true;
+             }
+         }
+
+         return false;
+     }
 }