├── package.yml
├── .github
    └── workflows
    │   └── publish-to-redaxo.yml
├── fragments
    └── navigation_array
    │   └── navigation.php
├── LICENSE
├── lib
    └── NavigationArray
    │   └── BuildArray.php
└── README.md


/package.yml:
--------------------------------------------------------------------------------
 1 | package: navigation_array
 2 | version: '5.3.3'
 3 | author: 'Friends Of REDAXO'
 4 | supportpage: https://github.com/FriendsOfREDAXO/navigation_array
 5 | info: 'REDAXO AddOn:Navigation Array'
 6 | 
 7 | requires:
 8 |     redaxo: '^5.15.0'
 9 |     php:
10 |         version: '>=8.1'    
11 | 


--------------------------------------------------------------------------------
/.github/workflows/publish-to-redaxo.yml:
--------------------------------------------------------------------------------
 1 | name: Publish release
 2 | 
 3 | on:
 4 |   release:
 5 |     types:
 6 |       - published
 7 | 
 8 | jobs:
 9 |   redaxo_publish:
10 |     runs-on: ubuntu-latest
11 |     steps:
12 |     - uses: actions/checkout@v3
13 |     - uses: FriendsOfREDAXO/installer-action@v1
14 |       with:
15 |         myredaxo-username: ${{ secrets.MYREDAXO_USERNAME }}
16 |         myredaxo-api-key: ${{ secrets.MYREDAXO_API_KEY }}
17 |         description: ${{ github.event.release.body }}
18 |         
19 | 


--------------------------------------------------------------------------------
/fragments/navigation_array/navigation.php:
--------------------------------------------------------------------------------
 1 | <?php foreach ($this->getVar('navigationArray') as $categoryArray): ?>
 2 |     <li>
 3 |         <a class="<?= $categoryArray['active'] ? $this->getVar('activeClass') : '' ?>" role="menuitem" href="<?= rex_escape($categoryArray['url']) ?>">
 4 |             <?= $categoryArray['catName'] ?>
 5 |         </a>
 6 |         <?php if (!empty($categoryArray['children'])): ?>
 7 |             <ul role="menu">
 8 |                 <?php
 9 |                 $this->subfragment('navigation_array/navigation.php', ['navigationArray' => $categoryArray['children']]);
10 |                 ?>
11 |             </ul>
12 |         <?php endif; ?>
13 |     </li>
14 | <?php endforeach; ?>


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2024 Friends Of REDAXO
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/lib/NavigationArray/BuildArray.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace FriendsOfRedaxo\NavigationArray;
  4 | 
  5 | use rex_addon;
  6 | use rex_article;
  7 | use rex_category;
  8 | use rex_clang;
  9 | use rex_exception;
 10 | use rex_logger;
 11 | use rex_yrewrite;
 12 | 
 13 | use function call_user_func;
 14 | use function in_array;
 15 | use function is_array;
 16 | use function is_callable;
 17 | use function is_int;
 18 | 
 19 | class BuildArray
 20 | {
 21 |     private $categoryFilterCallback;
 22 |     private $customDataCallback;
 23 |     private $depth;
 24 |     private $ignoreOfflines;
 25 |     private $level;
 26 |     private $start;
 27 |     private $startCats;
 28 |     private $excludedCategories = []; // Neue Eigenschaft
 29 | 
 30 |     public function __construct(int $start = -1, int $depth = 4, bool $ignoreOfflines = true, $depthSaved = 0, int $level = 0)
 31 |     {
 32 |         $this->start = $start;
 33 |         $this->depth = $depth;
 34 |         $this->ignoreOfflines = $ignoreOfflines;
 35 |         $this->level = $level;
 36 |     }
 37 | 
 38 |     /**
 39 |      * Set categories to exclude from the navigation (int or array of ints with category ids).
 40 |      *
 41 |      * @param int|array $excludedCategories
 42 |      * @return $this
 43 |      */
 44 |     public function setExcludedCategories(int|array $excludedCategories): self
 45 |     {
 46 |         if (is_int($excludedCategories)) {
 47 |             $excludedCategories = [$excludedCategories];
 48 |         }
 49 | 
 50 |         if (!is_array($excludedCategories)) {
 51 |             $message = 'Excluded categories must be an integer or an array of integers.';
 52 |             rex_logger::logError(E_USER_ERROR, $message, __FILE__, __LINE__);
 53 |             throw new rex_exception($message);
 54 |         }
 55 | 
 56 |         $this->excludedCategories = $excludedCategories;
 57 |         return $this;
 58 |     }
 59 | 
 60 |     /**
 61 |      * Set ID of the category to start with (default: -1, yrewrite mountID or root category).
 62 |      *
 63 |      * @param int $start
 64 |      * @return $this
 65 |      */
 66 |     public function setStart(int $start): self
 67 |     {
 68 |         $this->start = $start;
 69 |         return $this;
 70 |     }
 71 | 
 72 |     /**
 73 |      * Set how many levels should the navigation show (default: 4).
 74 |      *
 75 |      * @param int $depth
 76 |      * @return $this
 77 |      */
 78 |     public function setDepth(int $depth): self
 79 |     {
 80 |         $this->depth = $depth;
 81 |         return $this;
 82 |     }
 83 | 
 84 |     /**
 85 |      * Set whether offline categories should be ignored (default: true).
 86 |      *
 87 |      * @param int $ignore 1 for true, 0 for false
 88 |      * @return $this
 89 |      */
 90 |     public function setIgnore(int $ignore): self
 91 |     {
 92 |         $this->ignoreOfflines = (bool)$ignore;
 93 |         return $this;
 94 |     }
 95 | 
 96 |     /**
 97 |      * @param int $lvl
 98 |      * @return $this
 99 |      */
100 |     public function setLevel(int $lvl): self
101 |     {
102 |         $this->level = $lvl;
103 |         return $this;
104 |     }
105 | 
106 |     /**
107 |      * Create a new instance of BuildArray.
108 |      *
109 |      * @return self
110 |      */
111 |     public static function create(): self
112 |     {
113 |         return new self();
114 |     }
115 | 
116 |     /**
117 |      * Generate the navigation array.
118 |      *
119 |      * @return array
120 |      */
121 |     public function generate(): array
122 |     {
123 |         $result = [];
124 |         $currentCat = rex_category::getCurrent();
125 |         $currentCatpath = $currentCat ? $currentCat->getPathAsArray() : [];
126 |         $currentCat_id = $currentCat ? $currentCat->getId() : 0;
127 | 
128 |         $this->initializeStartCategory();
129 | 
130 |         foreach ($this->startCats as $cat) {
131 |             if ($this->isPermitted($cat)) {
132 |                 $result[] = $this->processCategory($cat, $currentCatpath, $currentCat_id);
133 |             }
134 |         }
135 |         return array_filter($result);
136 |     }
137 | 
138 |     /**
139 |      * Set a callback to filter categories.
140 |      *
141 |      * @param callable $callback
142 |      * @return $this
143 |      */
144 |     public function setCategoryFilterCallback(callable $callback): self
145 |     {
146 |         $this->categoryFilterCallback = $callback;
147 |         return $this;
148 |     }
149 | 
150 |     /**
151 |      * Set a callback to add custom data to the category array.
152 |      *
153 |      * @param callable $callback
154 |      * @return $this
155 |      */
156 |     public function setCustomDataCallback(callable $callback): self
157 |     {
158 |         $this->customDataCallback = $callback;
159 |         return $this;
160 |     }
161 | 
162 |     /**
163 |      * Generate the navigation array as JSON.
164 |      *
165 |      * @return string
166 |      */
167 |     public function toJson(): string
168 |     {
169 |         $array = $this->generate();
170 |         return json_encode($array, JSON_PRETTY_PRINT);
171 |     }
172 | 
173 |     /**
174 |      * Initialize the start category based on the provided start value
175 |      * or fallback to yrewrite domain or root categories
176 |      * 
177 |      * @return void
178 |      */
179 |     private function initializeStartCategory(): void
180 |     {
181 |         // Erster Schritt: Startwert ermitteln, falls es -1 (Default) ist
182 |         if ($this->start == -1) {
183 |             // YRewrite Domain-Startpunkt versuchen zu holen
184 |             if (rex_addon::get('yrewrite')->isAvailable()) {
185 |                 $domain = rex_yrewrite::getDomainByArticleId(rex_article::getCurrentId(), rex_clang::getCurrentId());
186 |                 $this->start = ($domain !== null) ? $domain->getMountId() : 0;
187 |             } else {
188 |                 // Fallback auf Root-Kategorien
189 |                 $this->start = 0;
190 |             }
191 |         }
192 |         
193 |         // Zweiter Schritt: Kategorien basierend auf dem ermittelten Startwert laden
194 |         // Arrays von Kategorie-IDs
195 |         if (is_array($this->start)) {
196 |             $this->startCats = [];
197 |             foreach ($this->start as $startCatId) {
198 |                 $startCat = rex_category::get($startCatId);
199 |                 if ($startCat) {
200 |                     $this->startCats[] = $startCat;
201 |                 }
202 |             }
203 |             return;
204 |         }
205 |         
206 |         // Spezifische Kategorie-ID (nicht 0)
207 |         if ($this->start != 0) {
208 |             $startCat = rex_category::get($this->start);
209 |             if ($startCat) {
210 |                 $this->startCats = $startCat->getChildren($this->ignoreOfflines);
211 |                 return;
212 |             }
213 |         }
214 |         
215 |         // Fallback auf Root-Kategorien
216 |         $this->startCats = rex_category::getRootCategories($this->ignoreOfflines);
217 |     }
218 | 
219 |     /**
220 |      * Check if the category is permitted by ycom.
221 |      *
222 |      * @param rex_category $cat
223 |      * @return bool
224 |      */
225 |     private function isCategoryPermitted(rex_category $cat): bool
226 |     {
227 |         // Erst prüfen, ob das ycom-Addon überhaupt installiert und aktiviert ist
228 |         if (!rex_addon::get('ycom')->isAvailable()) {
229 |             return true;
230 |         }
231 |         
232 |         // Dann prüfen, ob das auth-Plugin verfügbar ist
233 |         $ycom_check = rex_addon::get('ycom')->getPlugin('auth')->isAvailable();
234 |         return !$ycom_check || $cat->isPermitted();
235 |     }
236 | 
237 |     /**
238 |      * Check if category meets all navigation requirements
239 |      * Prüft ob die Kategorie alle Anforderungen erfüllt (YCom, Ausschlüsse, Filter)
240 |      *
241 |      * @param rex_category $cat
242 |      * @return bool
243 |      */
244 |     private function isPermitted(rex_category $cat): bool
245 |     {
246 |         // Prüfe YCom Berechtigungen
247 |         if (!$this->isCategoryPermitted($cat)) {
248 |             return false;
249 |         }
250 | 
251 |         // Prüfe ob Kategorie ausgeschlossen ist
252 |         if (in_array($cat->getId(), $this->excludedCategories)) {
253 |             return false;
254 |         }
255 | 
256 |         // Prüfe Category Filter Callback
257 |         if (is_callable($this->categoryFilterCallback) && !call_user_func($this->categoryFilterCallback, $cat)) {
258 |             return false;
259 |         }
260 | 
261 |         return true;
262 |     }
263 | 
264 |     /**
265 |      * @param rex_category $cat
266 |      * @param array $currentCatpath
267 |      * @param int $currentCat_id
268 |      * @return array
269 |      */
270 |     private function processCategory(rex_category $cat, array $currentCatpath, int $currentCat_id): array
271 |     {
272 |         $catId = $cat->getId();
273 | 
274 |         // Base category data
275 |         $categoryArray = [
276 |             'catId' => $catId,
277 |             'parentId' => $cat->getParentId(),
278 |             'level' => $this->level,
279 |             'catName' => $cat->getName(),
280 |             'url' => $cat->getUrl(),
281 |             'path' => $cat->getPathAsArray(),
282 |             'active' => in_array($catId, $currentCatpath) || $currentCat_id == $catId,
283 |             'current' => $currentCat_id == $catId,
284 |         ];
285 | 
286 |         // Process children only if we haven't reached the maximum depth
287 |         $children = [];
288 |         if ($this->level < $this->depth) {
289 |             $childCats = $cat->getChildren($this->ignoreOfflines);
290 |             if ($childCats) {
291 |                 $this->level++; // Increment level for children
292 |                 foreach ($childCats as $child) {
293 |                     if ($this->isPermitted($child)) {
294 |                         $children[] = $this->processCategory($child, $currentCatpath, $currentCat_id);
295 |                     }
296 |                 }
297 |                 $this->level--; // Restore level after processing children
298 |             }
299 |         }
300 | 
301 |         $categoryArray['hasChildren'] = !empty($children);
302 |         $categoryArray['children'] = $children;
303 | 
304 |         // Add custom data if callback is set
305 |         if (is_callable($this->customDataCallback)) {
306 |             $customData = call_user_func($this->customDataCallback, $cat);
307 |             if (is_array($customData)) {
308 |                 $categoryArray = array_merge($categoryArray, $customData);
309 |             }
310 |         }
311 | 
312 |         return $categoryArray;
313 |     }
314 | 
315 |     /**
316 |      * Get category information either for current category or by ID
317 |      * 
318 |      * @param int|null $categoryId Optional category ID
319 |      * @return array
320 |      */
321 |     public function getCategory(?int $categoryId = null): array
322 |     {
323 |         // Kategorie ermitteln (entweder durch ID oder current)
324 |         $cat = null;
325 |         if ($categoryId !== null) {
326 |             $cat = rex_category::get($categoryId);
327 |         } else {
328 |             $cat = rex_category::getCurrent();
329 |         }
330 | 
331 |         if (!$cat) {
332 |             return [];
333 |         }
334 | 
335 |         // YCom-Berechtigungen prüfen
336 |         $hasYcomPermissions = $this->isCategoryPermitted($cat);
337 | 
338 |         // Filter-Status prüfen
339 |         $isFilterPermitted = true;
340 |         if (is_callable($this->categoryFilterCallback)) {
341 |             $isFilterPermitted = call_user_func($this->categoryFilterCallback, $cat);
342 |         }
343 | 
344 |         $catId = $cat->getId();
345 |         $path = $cat->getPathAsArray();
346 |         $currentCat = rex_category::getCurrent();
347 |         $currentCatpath = $currentCat ? $currentCat->getPathAsArray() : [];
348 |         $currentCat_id = $currentCat ? $currentCat->getId() : 0;
349 | 
350 |         // Kinder mit processCategory verarbeiten
351 |         $children = [];
352 |         $childCategories = $cat->getChildren($this->ignoreOfflines);
353 |         if ($childCategories) {
354 |             foreach ($childCategories as $childCat) {
355 |                 if ($this->isPermitted($childCat)) {
356 |                     $children[] = $this->processCategory($childCat, $currentCatpath, $currentCat_id);
357 |                 }
358 |             }
359 |         }
360 | 
361 |         $categoryArray = [
362 |             'catId' => $catId,
363 |             'parentId' => $cat->getParentId(),
364 |             'catName' => $cat->getName(),
365 |             'url' => $cat->getUrl(),
366 |             'hasChildren' => !empty($children),
367 |             'children' => $children,  // Kinder aus processCategory
368 |             'path' => $path,
369 |             'pathCount' => count($path),
370 |             'active' => in_array($catId, $currentCatpath) || $currentCat_id == $catId,
371 |             'current' => $currentCat_id == $catId,
372 |             'cat' => $cat,
373 |             'ycom_permitted' => $hasYcomPermissions,
374 |             'filter_permitted' => $isFilterPermitted,
375 |             'is_permitted' => $hasYcomPermissions && $isFilterPermitted
376 |         ];
377 | 
378 |         // Custom Data hinzufügen wenn ein Callback definiert ist
379 |         if (is_callable($this->customDataCallback)) {
380 |             $customData = call_user_func($this->customDataCallback, $cat);
381 |             if (is_array($customData)) {
382 |                 $categoryArray = array_merge($categoryArray, $customData);
383 |             }
384 |         }
385 | 
386 |         return $categoryArray;
387 |     }
388 | 
389 |     /**
390 |      * Walk through the navigation and apply a callback to each item.
391 |      *
392 |      * @param callable $callback The callback function to apply to each item.
393 |      *                            It will receive the item (category array) and the level as arguments.
394 |      * @return void
395 |      */
396 |     public function walk(callable $callback): void
397 |     {
398 |         $this->initializeStartCategory();
399 | 
400 |         $currentCat = rex_category::getCurrent();
401 |         $currentCatpath = $currentCat ? $currentCat->getPathAsArray() : [];
402 |         $currentCat_id = $currentCat ? $currentCat->getId() : 0;
403 | 
404 |         foreach ($this->startCats as $cat) {
405 |             if ($this->isPermitted($cat)) {
406 |                 // Start mit Level 0 für die Root-Kategorien
407 |                 $this->walkRecursive($cat, $callback, $currentCatpath, $currentCat_id, 0);
408 |             }
409 |         }
410 |     }
411 | 
412 |     /**
413 |      * Recursive helper function for the walk method.
414 |      *
415 |      * @param rex_category $cat
416 |      * @param callable $callback
417 |      * @param array $currentCatpath
418 |      * @param int $currentCat_id
419 |      * @param int $level
420 |      * @return void
421 |      */
422 |     private function walkRecursive(rex_category $cat, callable $callback, array $currentCatpath, int $currentCat_id, int $level): void
423 |     {
424 |         // Prüfe zuerst, ob wir die maximale Tiefe überschritten haben
425 |         if ($level > $this->depth) {
426 |             return;
427 |         }
428 | 
429 |         $item = $this->processCategory($cat, $currentCatpath, $currentCat_id);
430 |         if (!empty($item)) {
431 |             call_user_func($callback, $item, $level);
432 |         }
433 | 
434 |         // Hole Kindkategorien nur wenn wir noch nicht die maximale Tiefe erreicht haben
435 |         if ($level < $this->depth) {
436 |             $childCats = $cat->getChildren($this->ignoreOfflines);
437 |             if (!empty($childCats)) {
438 |                 foreach ($childCats as $child) {
439 |                     if ($this->isPermitted($child)) {
440 |                         $this->walkRecursive($child, $callback, $currentCatpath, $currentCat_id, $level + 1);
441 |                     }
442 |                 }
443 |             }
444 |         }
445 |     }
446 | }
447 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | # REDAXO Navigation Array
  2 | 
  3 | Navigation Array ist eine PHP-Klasse für die einfache Erstellung einer Navigationsstruktur als Array. Diese Klasse bietet flexible Möglichkeiten, Navigationsdaten auszulesen, zu filtern und zu verarbeiten, insbesondere durch die Nutzung der `walk()`-Methode.
  4 | 
  5 | ## Erklärung der Klasse
  6 | 
  7 | Die `FriendsOfRedaxo\NavigationArray\BuildArray` Klasse bietet folgende Hauptfunktionalitäten:
  8 | 
  9 | *   **Erstellung eines Navigationsarrays:** Generiert ein verschachteltes Array, das die Kategorien und ihre Hierarchie darstellt.
 10 | *   **Filterung von Kategorien:** Ermöglicht das Herausfiltern von Kategorien basierend auf benutzerdefinierten Kriterien.
 11 | *   **Hinzufügen benutzerdefinierter Daten:** Fügt zusätzliche Informationen zu jedem Kategorie-Array hinzu.
 12 | *   **Rekursive Navigationstraversierung:** Die `walk()`-Methode erlaubt es, die Navigationsstruktur rekursiv zu durchlaufen und dabei individuelle Operationen auszuführen.
 13 | *   **Abrufen von Kategorieinformationen:** Mit der `getCategory()`-Methode können detaillierte Informationen zu einzelnen Kategorien abgerufen werden.
 14 | 
 15 | ### Kernfunktionen
 16 | 
 17 | -   Berücksichtigung von Offline-Artikeln und YCom-Rechten.
 18 | -   Frei wählbare Startkategorie.
 19 | -   Festlegbare Tiefe der Navigation.
 20 | -   Filterung und Manipulation von Kategorien über Callbacks.
 21 | 
 22 | ### Features
 23 | 
 24 | -   `getCategory`-Methode zum Abrufen von Kategorieinformationen (inkl. Kindkategorien).
 25 | -   `walk()`-Methode für einfache, rekursive Navigationstraversierung.
 26 | -   Mitgelieferte Fragmente für die HTML-Ausgabe der Navigation (siehe Beispiele unten).
 27 | 
 28 | ## Auslesen der Daten
 29 | 
 30 | ### Array-Struktur
 31 | 
 32 | Das generierte Array enthält alle Kategorien und Unterkategorien bis zur angegebenen Tiefe. Offline-Kategorien und Rechte aus YCom werden vorher entfernt.
 33 | 
 34 | ```php
 35 | array:7 [
 36 |     0 => array:11 [▶]
 37 |     1 => array:11 [▶]
 38 |     2 => array:11 [▶]
 39 |     3 => array:11 [▶]
 40 |     4 => array:11 [
 41 |         "catId" => 43
 42 |         "parentId" => 0
 43 |         "level" => 0
 44 |         "catName" => "Kontakt"
 45 |         "url" => "/kontakt/"
 46 |         "hasChildren" => true
 47 |         "children" => array:2 [
 48 |             0 => array:11 [
 49 |                 "catId" => 178
 50 |                 "parentId" => 43
 51 |                 "level" => 1
 52 |                 "catName" => "Kontaktformular"
 53 |                 "url" => "/kontakt/kontaktformular/"
 54 |                 "hasChildren" => false
 55 |                 "children" => []
 56 |                 "path" => array:1 [▶]
 57 |                 "active" => false
 58 |                 "current" => false
 59 |             ]
 60 |             1 => array:11 [▶]
 61 |         ]
 62 |         "path" => []
 63 |         "active" => true
 64 |         "current" => true
 65 |     ]
 66 |     5 => array:11 [▶]
 67 |     6 => array:11 [▶]
 68 | ]
 69 | ```
 70 | 
 71 | ### Array generieren
 72 | 
 73 | #### Aufruf mit Konstruktor
 74 | 
 75 | ```php
 76 | // define namespace
 77 | use FriendsOfRedaxo\NavigationArray\BuildArray;
 78 | // create object
 79 | $navigationObject = new BuildArray(-1, 3);
 80 | // generate navigation array
 81 | $navigationArray = $navigationObject->generate();
 82 | ```
 83 | 
 84 | #### Aufruf mit Methoden
 85 | 
 86 | ```php
 87 | // define namespace
 88 | use FriendsOfRedaxo\NavigationArray\BuildArray;
 89 | // create navigation array
 90 | $navigationArray = BuildArray::create()
 91 |     ->setStart(-1)
 92 |     ->setDepth(4)
 93 |     ->setIgnore(true)
 94 |     ->setCategoryFilterCallback(CategoryFilter())
 95 |     ->setCustomDataCallback(CustomData())
 96 |     ->generate();
 97 | ```
 98 | 
 99 | ## Erstellen von Navigationen
100 | 
101 | ### Verwendung der `walk()`-Methode
102 | 
103 | Die `walk()`-Methode ermöglicht es, die Navigation rekursiv zu durchlaufen und dabei eine Callback-Funktion auf jedes Element anzuwenden. Dies ist ideal für benutzerdefinierte Ausgaben oder Manipulationen der Navigationsdaten.
104 | 
105 | #### Verwendung
106 | 
107 | ```php
108 | public function walk(callable $callback): void
109 | ```
110 | 
111 | #### Parameter
112 | 
113 | -   `$callback`: Eine `callable`-Funktion, die für jedes Navigationselement aufgerufen wird. Die Funktion erhält zwei Parameter:
114 |     -   `$item`: Das aktuelle Navigationselement (als `array`).
115 |     -   `$level`: Die aktuelle Ebene der Navigation (als `int`).
116 | 
117 | #### Beispiel: Verschachtelte HTML-Liste mit `walk()`
118 | 
119 | ```php
120 | <?php
121 | use FriendsOfRedaxo\NavigationArray\BuildArray;
122 | 
123 | $htmlNavigation = '';
124 | $currentLevel = 0;
125 | $lastItem = null;
126 | 
127 | $navigation = BuildArray::create()
128 |     ->setDepth(3)
129 |     ->setExcludedCategories([32,34])
130 |     ->setCategoryFilterCallback(function(rex_category $cat){
131 |         return true;
132 |     })
133 |     ->setCustomDataCallback(function(rex_category $cat){
134 |         return [
135 |             'css_id' => 'cat-'.$cat->getId(),
136 |             'description' => $cat->getValue('description')
137 |         ];
138 |     });
139 | 
140 | $items = []; // Sammle alle Items
141 | $navigation->walk(function ($item, $level) use (&$items) {
142 |     $items[] = ['item' => $item, 'level' => $level];
143 | });
144 | 
145 | // Verarbeite die Items
146 | for ($i = 0; $i < count($items); $i++) {
147 |     $currentItem = $items[$i];
148 |     $level = $currentItem['level'];
149 |     $item = $currentItem['item'];
150 |     
151 |     // Prüfe auf Leveländerungen
152 |     if ($level > $currentLevel) {
153 |         $htmlNavigation .= "\n" . str_repeat('  ', $level) . '<ul>';
154 |     } elseif ($level < $currentLevel) {
155 |         // Schließe übergeordnete Level
156 |         $diff = $currentLevel - $level;
157 |         for ($j = 0; $j < $diff; $j++) {
158 |             $htmlNavigation .= '</li>' . "\n" . str_repeat('  ', $currentLevel - $j - 1) . '</ul>';
159 |             if ($j < $diff - 1) {
160 |                 $htmlNavigation .= '</li>';
161 |             }
162 |         }
163 |     } elseif ($i > 0) {
164 |         // Auf gleichem Level: Schließe vorheriges li
165 |         $htmlNavigation .= '</li>';
166 |     }
167 |     
168 |     $htmlNavigation .= "\n" . str_repeat('  ', $level);
169 |     $activeClass = $item['active'] ? ' class="active"' : '';
170 |     $htmlNavigation .= '<li' . $activeClass . '>';
171 |     $htmlNavigation .= '<a href="' . $item['url'] . '" id="' . $item['css_id'] . '">';
172 |     $htmlNavigation .= $item['catName'];
173 |     $htmlNavigation .= '</a>';
174 |     
175 |     $currentLevel = $level;
176 | }
177 | 
178 | // Schließe verbleibende offene Tags
179 | if ($currentLevel >= 0) {
180 |     for ($i = $currentLevel; $i >= 0; $i--) {
181 |         $htmlNavigation .= '</li>' . "\n" . str_repeat('  ', $i) . '</ul>';
182 |     }
183 | }
184 | 
185 | echo $htmlNavigation;
186 | ```
187 | 
188 | #### Beispiel: Logausgabe der Navigation mit `walk()`
189 | 
190 | ```php
191 | <?php
192 | use FriendsOfRedaxo\NavigationArray\BuildArray;
193 | 
194 | $navigation = BuildArray::create()->setDepth(2);
195 | 
196 | $navigation->walk(function ($item, $level) {
197 |     echo str_repeat("  ", $level) . "Kategorie: " . $item['catName'] . ", Level: " . $level . ", URL: " . $item['url'] . "<br>";
198 | });
199 | ```
200 | 
201 | #### Beispiel: Einfache Navigation mit `walk()` und REDAXO Fragment
202 | 
203 | Hier ein Beispiel, wie du die `walk()`-Methode in Verbindung mit einem REDAXO-Fragment für eine einfache Navigation verwenden kannst.
204 | 
205 | **1. Fragment (`simple_navigation.php`)**:
206 | Erstelle eine Fragmentdatei im Verzeichnis `fragments/navigation_array` mit folgendem Inhalt:
207 | 
208 | ```php
209 | <?php
210 |     $items = $this->getVar('items');
211 |     $level = $this->getVar('level', 0);
212 |     $activeClass = $this->getVar('activeClass', 'active');
213 |     
214 |     if (empty($items)) {
215 |         return '';
216 |     }
217 |     $output = '<ul>';
218 |     foreach ($items as $item) {
219 |          $active = $item['active'] ? ' class="'.$activeClass.'"' : '';
220 |         $output .= '<li' . $active . '><a href="'.$item['url'].'">'.$item['catName'].'</a>';
221 |          if(isset($item['children']) && !empty($item['children'])){
222 |            
223 |             $output .= $this->subfragment('navigation_array/simple_navigation.php', [
224 |                 'items' => $item['children'],
225 |                 'level' => $level +1,
226 |                 'activeClass' => $activeClass
227 |             ]);
228 |          }
229 |       $output .='</li>';
230 |     }
231 |     $output .= '</ul>';
232 |     echo $output;
233 | ?>
234 | ```
235 | 
236 | **2. Aufruf im Template:**
237 | In deinem REDAXO-Template kannst du die Navigation wie folgt erstellen:
238 | ```php
239 | <?php
240 | use FriendsOfRedaxo\NavigationArray\BuildArray;
241 | 
242 | $navigation = BuildArray::create()->setDepth(3);
243 | $htmlNavigation = '';
244 | $items = [];
245 | $navigation->walk(function ($item, $level) use (&$items) {
246 |    $items[] = $item;
247 | });
248 | 
249 | 
250 | $fragment = new rex_fragment();
251 | $fragment->setVar('items', $items);
252 | $fragment->setVar('activeClass', 'active');
253 | echo $fragment->parse('navigation_array/simple_navigation.php');
254 | ```
255 | 
256 | Dieses Beispiel zeigt, wie du mit der `walk()`-Methode ein Array der Navigation erzeugen kannst und dieses dann mit einem REDAXO-Fragment in eine einfache Navigation umwandeln kannst. Die Rekursion wird nun über die Fragments realisiert, um einen wiederverwendbaren Code zu erhalten.
257 | 
258 | #### Beispiel: Breadcrumb mit `walk()`
259 | 
260 | Hier ist ein modernes Breadcrumb-Beispiel mit der `walk()`-Methode:
261 | 
262 | ```php
263 | <?php
264 | use FriendsOfRedaxo\NavigationArray\BuildArray;
265 | 
266 | $navarray = BuildArray::create()->setDepth(10);
267 | $breadcrumbItems = [];
268 | 
269 | $navarray->walk(function ($item, $level) use (&$breadcrumbItems) {
270 |     if ($item['active']) {
271 |       $liclass = '';
272 |         if ('REX_ARTICLE_ID' == $item['catId']) {
273 |             $liclass = ' class="disabled"';
274 |             $item['url'] = '';
275 |          }
276 |         $breadcrumbItems[] = '<li'.$liclass.'><a href="' . $item['url'] . '">' . $item['catName'] . '</a></li>';
277 |     }
278 | });
279 | echo '<ul class="breadcrumb">';
280 | echo '<li><a title="Home" href="/"><span data-uk-icon="home"></span></a></li>';
281 | echo implode("\n", $breadcrumbItems);
282 | echo '</ul>';
283 | 
284 | ```
285 | 
286 | Dieses Beispiel zeigt, wie du die `walk()` Methode nutzen kannst um einen Breadcrumb zu generieren, und dabei von den bereitgestellten Informationen Gebrauch machst.
287 | 
288 | ### Vergleich: `walk()` vs. Eigene Iteration (Gleiche Ausgabe)
289 | 
290 | Um die Vorteile der `walk()`-Methode zu verdeutlichen, zeigen wir hier, wie man die gleiche verschachtelte Navigation mit beiden Methoden erstellt. Dies ermöglicht einen direkten Code-Vergleich.
291 | 
292 | #### Mit `walk()`-Methode
293 | 
294 | ```php
295 | <?php
296 | use FriendsOfRedaxo\NavigationArray\BuildArray;
297 | 
298 | $navigation = BuildArray::create()->setDepth(3);
299 | $htmlOutput = '';
300 | 
301 | $navigation->walk(function($item, $level) use (&$htmlOutput) {
302 |    $htmlOutput .= str_repeat("&nbsp;&nbsp;", $level) . '<a href="' . $item['url'] . '">' . $item['catName'] . '</a><br>';
303 | });
304 | 
305 | echo $htmlOutput;
306 | ```
307 | 
308 | #### Mit eigener Iterationsfunktion
309 | 
310 | ```php
311 | <?php
312 | use FriendsOfRedaxo\NavigationArray\BuildArray;
313 | 
314 | function myCustomNavigation($items, $level = 0) {
315 |     $output = '';
316 |     foreach ($items as $item) {
317 |         $output .= str_repeat("&nbsp;&nbsp;", $level) . '<a href="' . $item['url'] . '">' . $item['catName'] . '</a><br>';
318 |         if ($item['hasChildren']) {
319 |             $output .= myCustomNavigation($item['children'], $level + 1);
320 |         }
321 |     }
322 |     return $output;
323 | }
324 | 
325 | $navigation = BuildArray::create()->setDepth(3)->generate();
326 | echo myCustomNavigation($navigation);
327 | ```
328 | 
329 | **Analyse:**
330 | 
331 | *   **Klarheit:** Beide Code-Beispiele erzeugen *exakt* die gleiche HTML-Ausgabe.
332 | *   **Code-Kürze:** Die `walk()`-Methode erfordert *deutlich weniger* Code und ist lesbarer, da die Rekursionslogik intern gehandhabt wird.
333 | *   **Wartbarkeit:** Der Code mit `walk()` ist einfacher zu warten, da die Rekursionslogik gekapselt ist.
334 | *   **Flexibilität:** Die `walk()`-Methode ermöglicht es, die Logik der Ausgabe in einem Callback zu definieren, was die Flexibilität erhöht.
335 | 
336 | Dieser direkte Vergleich zeigt, dass die `walk()`-Methode eine prägnantere, klarere und wartungsfreundlichere Möglichkeit bietet, die Navigationsdaten zu verarbeiten.
337 | 
338 | ## Weitere Beispiele
339 | 
340 | Neben der Nutzung von `walk()`, können auch die generierten Arrays direkt für die Ausgabe genutzt werden.
341 | 
342 | ### Fragmente
343 | 
344 | Mit Fragmenten wird die Logik sauber vom Code getrennt. Das Fragment `navigation.php` kann kopiert, angepasst und in `project` oder `theme`-Ordner abgelegt werden.
345 | 
346 | ```php
347 | // Festlegen des Namespace
348 | use FriendsOfRedaxo\NavigationArray\BuildArray;
349 | 
350 | // Navigation Array erstellen
351 | $navigationObject = new BuildArray(-1, 3);
352 | $navigationArray = $navigationObject->generate();
353 | 
354 | //Fragmente laden Navigation Array und Klasse für aktive Elemente übergeben
355 | $fragment = new rex_fragment();
356 | $fragment->setVar('navigationArray', $navigationArray);
357 | $fragment->setVar('activeClass', 'active');
358 | 
359 | // Navigation ausgeben
360 | <nav>
361 |     <ul role="menubar">
362 |         echo $fragment->parse('navigation_array/navigation.php');
363 |     </ul>
364 | </nav>
365 | ```
366 | 
367 | ### Weitere PHP-Funktionen (Auswahl)
368 | 
369 | Hier sind weitere Beispiele für spezifische HTML-Ausgaben
370 | 
371 | #### Beispiel erweiterte Navigation mit Callback
372 | 
373 | ```php
374 | <?php
375 | use FriendsOfRedaxo\NavigationArray\BuildArray;
376 | 
377 | $mainnavi_array = (new BuildArray())
378 |     ->setCustomDataCallback(function($cat) {
379 |         return ['navtype' => $cat->getValue('cat_navigationstyp')];
380 |     })
381 |     ->generate();
382 | 
383 | $mainnavigation_items = [];
384 | 
385 | function createNavigationItems($navi) {
386 |     $items = [];
387 |     $class_active = $navi['active'] ? 'active' : '';
388 |     $class_current = $navi['current'] ? ' current' : '';
389 |     $class_has_child = $navi['children'] ? ' has-child' : '';
390 | 
391 |     $items[] = "<li class=\"{$class_active}{$class_current}{$class_has_child}\"><a href=\"{$navi['url']}\">{$navi['catName']}</a>";
392 | 
393 |     if ($navi['children']) {
394 |         $items[] = '<button class="child-toggle">X</button>';
395 |         $items[] = '<ul>';
396 | 
397 |         foreach ($navi['children'] as $nav_child) {
398 |             $items[] = createNavigationItems($nav_child);
399 |         }
400 | 
401 |         $items[] = '</ul>';
402 |     }
403 | 
404 |     $items[] = '</li>';
405 | 
406 |     return implode($items);
407 | }
408 | 
409 | foreach ($mainnavi_array as $navi) {
410 |     $navtype_arr = explode('|', $navi['navtype']);
411 | 
412 |     if (in_array('main', $navtype_arr)) {
413 |         $mainnavigation_items[] = createNavigationItems($navi);
414 |     }
415 | }
416 | 
417 | $mainnavigation = '<ul id="mainnavigation">' . implode($mainnavigation_items) . '</ul>';
418 | ```
419 | 
420 | #### Beispiel: Bootstrap 5 Navigation
421 | 
422 | ```php
423 | <?php
424 | use FriendsOfRedaxo\NavigationArray\BuildArray;
425 | function bsnavi5($data = array())
426 | {
427 |     $output = array();
428 |     foreach ($data as $cat) {
429 |         $subnavi = $catname = $li = $active =
430 | 
431 |  $ul = $link_extra = "";
432 |         $aclass = 'nav-link';
433 |         $li = ' class="nav-item"';
434 | 
435 |         if ($cat['level'] == 0 && $cat['hasChildren'] == true) {
436 |             $li = ' class="nav-item dropdown"';
437 |             $ul = ' class="dropdown-menu"';
438 |             $link_extra = 'id="ddm' . $cat['catId'] . '" data-bs-toggle="dropdown"';
439 |             $aclass = 'nav-link dropdown-toggle';
440 |         }
441 | 
442 |         if ($cat['level'] == 1 && $cat['hasChildren'] == false) {
443 |             $li = ' class="nav-item dropdown"';
444 |             $aclass = 'dropdown-item';
445 |         }
446 | 
447 |         if ($cat['hasChildren'] == true) {
448 |             $sub = [];
449 |             $sub[] = '<ul' . $ul . '>';
450 |             $sub[] = bsnavi5($cat['children']);
451 |             $sub[] = '</ul>';
452 |             $subnavi = join("\n", $sub);
453 |         }
454 | 
455 |         $catname = $cat['catName'];
456 |         if ($cat['active'] == true) {
457 |             $active = ' active';
458 |         }
459 | 
460 |         $catname = '<a class="' . $aclass . $active . '" href="' . $cat['url'] . '"' . $link_extra . '>' . $catname . '</a>';
461 |         $output[] = '<li ' . $li . '>' . $catname . $subnavi . '</li>';
462 |     }
463 |     return implode("\n", $output);
464 | }
465 | 
466 | 
467 | $NavigationArray = BuildArray::create()->setDepth(4)->generate();
468 | ?>
469 | 
470 | <nav class="navbar navbar-expand-lg navbar-light bg-light">
471 |     <div class="container-fluid">
472 |         <ul class="navbar-nav ms-md-auto mb-0">
473 |             <?= bsnavi5($NavigationArray) ?>
474 |         </ul>
475 |     </div>
476 | </nav>
477 | </body>
478 | ```
479 | 
480 | #### Beispiel UIkit-Drop-Down
481 | 
482 | ```php
483 | <?php
484 | use FriendsOfRedaxo\NavigationArray\BuildArray;
485 | // UIkit NAVIGATION uses navigation_array AddOn
486 | function myNavi_demo($data = array())
487 | {
488 |     $output = [];
489 |     foreach ($data as $cat) {
490 |         $subnavi = $liclass = $ul = "";
491 |         $subclass = 'uk-default';
492 |         if ($cat['level'] == 0 && $cat['hasChildren'] == true) {
493 |             $liclass = 'uk-parent ';
494 |             $ul = ' class="uk-nav uk-navbar-dropdown-nav"';
495 |             $subclass = 'uk-navbar-dropdown uk-margin-remove uk-padding-small';
496 |         }
497 |         if ($cat['hasChildren'] == true) {
498 |             $sub = [];
499 |             $sub[] = '<div class="' . $subclass . '">';
500 |             $sub[] = '<ul' . $ul . '>';
501 |             $sub[] = myNavi_demo($cat['children']);
502 |             $sub[] = '</ul>';
503 |             $sub[] = '</div>';
504 |             $subnavi = join("\n", $sub);
505 |         }
506 |         $catname = $cat['catName'];
507 |         if ($cat['active'] == true) {
508 |             $catname = '' . $catname . '';
509 |             $liclass .= 'uk-active';
510 |         }
511 |         if ($liclass != '') {
512 |             $liclass = ' class="' . $liclass . '"';
513 |         }
514 |         $catname = '<a href="' . $cat['url'] . '">' . $catname . '</a>';
515 |         $output[] = '<li' . $liclass . '>' . $catname . $subnavi . '</li>';
516 |     }
517 | 
518 |     if (!empty($output)) {
519 |         return implode("\n", $output);
520 |     }
521 | }
522 | // Navigation erzeugen
523 | 
524 | $NavigationArray = BuildArray::create()->setDepth(3)->generate();
525 | $navigation = '
526 |     <ul class="uk-navbar-nav">'
527 |     . myNavi_demo($NavigationArray) .
528 |     '</ul>
529 | ';
530 | ?>
531 | <!--- NAVI-BAR --->
532 | <div class="nav">
533 |     <nav class="uk-box-shadow-small uk-background-secondary uk-light " uk-navbar>
534 |         <div class="uk-navbar-left">
535 |             <a class="uk-navbar-item uk-logo" title="Logo: <?=rex::getServerName()?>" href="/">
536 |                 <img class="logo" name="Logo" src="<?=rex_url::media()?>logo.svg" alt="">
537 |             </a>
538 |         </div>
539 |         <div class="uk-visible@m uk-navbar-center uk-text-large">
540 |             <?= $navigation; ?>
541 |         </div>
542 |         <div class="uk-navbar-right">
543 |             <a class="uk-icon-button uk-margin-right" href="https://github.com/FriendsOfREDAXO" uk-icon="icon: github"></a>
544 |         </div>
545 |     </nav>
546 | </div>
547 | <!--- ENDE NAVI-BAR --->
548 | ```
549 | 
550 | ### `getCategory()`
551 | 
552 | Liefert ein Array mit allen Informationen zu einer Kategorie. Funktioniert sowohl für die aktuelle Kategorie als auch für eine spezifische Kategorie-ID.
553 | 
554 | ### Basis-Verwendung
555 | 
556 | ```php
557 | <?php
558 | use FriendsOfRedaxo\NavigationArray\BuildArray;
559 | // Aktuelle Kategorie
560 | $category = BuildArray::create()->getCategory();
561 | 
562 | // Spezifische Kategorie
563 | $category = BuildArray::create()->getCategory(5);
564 | ```
565 | 
566 | ### Rückgabe-Array
567 | 
568 | ```php
569 | [
570 |     // Hauptkategorie-Informationen
571 |     'catId' => 5,                  // ID der Kategorie
572 |     'parentId' => 2,               // ID der Elternkategorie
573 |     'catName' => 'News',           // Name der Kategorie
574 |     'url' => '/news/',             // URL der Kategorie
575 |     'hasChildren' => true,         // Hat Unterkategorien
576 |     'path' => [0,2,5],            // Pfad von Root zur Kategorie
577 |     'pathCount' => 3,              // Anzahl der Ebenen von Root
578 |     'active' => true,              // Ist im aktiven Pfad
579 |     'current' => true,             // Ist aktuelle Kategorie
580 |     'cat' => Object,               // REX Category Objekt
581 |     'ycom_permitted' => true,      // YCom-Berechtigung
582 |     'filter_permitted' => true,    // Filter-Erlaubnis
583 |     'is_permitted' => true,        // Gesamtstatus der Berechtigungen
584 |     
585 |     // Kinder-Array (aus processCategory)
586 |     'children' => [
587 |         [
588 |             'catId' => 15,         // ID der Kindkategorie
589 |             'parentId' => 5,       // ID der Elternkategorie (unsere Hauptkategorie)
590 |             'level' => 3,          // Level aus processCategory
591 |             'catName' => 'Events', // Name der Kindkategorie
592 |             'url' => '/news/events/', // URL der Kindkategorie
593 |             'hasChildren' => false, // Hat diese Kindkategorie weitere Unterkategorien
594 |             'children' => [],       // Eventuelle Kinder der Kindkategorie
595 |             'path' => [0,2,5,15],  // Pfad dieser Kindkategorie
596 |             'active' => false,      // Ist diese Kindkategorie aktiv
597 |             'current' => false      // Ist diese Kindkategorie die aktuelle Kategorie
598 |         ],
599 |         [
600 |             'catId' => 16,
601 |             'parentId' => 5,
602 |             'level' => 3,
603 |             'catName' => 'Blog',
604 |             // ... weitere Eigenschaften wie oben
605 |         ],
606 |         // ... weitere Kindkategorien
607 |     ],
608 | 
609 |     // Zusätzliche Custom-Daten (wenn definiert)
610 |     'custom_field' => 'Wert',
611 |     'another_field' => 'Wert'
612 | ]
613 | ```
614 | 
615 | ### Beispiele
616 | 
617 | #### 1. Kategorie-Vergleich
618 | 
619 | ```php
620 | <?php
621 | use FriendsOfRedaxo\NavigationArray\BuildArray;
622 | $currentCat = BuildArray::create()->getCategory();
623 | $parentCat = BuildArray::create()->getCategory($currentCat['parentId']);
624 | 
625 | echo '<div class="category-nav">';
626 | echo '<h2>' . $parentCat['catName'] . '</h2>';
627 | echo '<h3>Sie befinden sich hier: ' . $currentCat['catName'] . '</h3>';
628 | echo '</div>';
629 | ```
630 | 
631 | #### 2. Mit Custom-Daten
632 | 
633 | ```php
634 | <?php
635 | use FriendsOfRedaxo\NavigationArray\BuildArray;
636 | $category = BuildArray::create()
637 |     ->setCustomDataCallback(function($cat) {
638 |         return [
639 |             'image' => $cat->getValue('cat_image'),
640 |             'description' => $cat->getValue('cat_description')
641 |         ];
642 |     })
643 |     ->getCategory(5);
644 | 
645 | if ($category['is_permitted']) {
646 |     echo '<div class="category-info">';
647 |     echo '<h1>' . $category['catName'] . '</h1>';
648 |     if ($category['image']) {
649 |         echo '<img src="' . $category['image'] . '">';
650 |     }
651 |     echo '</div>';
652 | }
653 | ```
654 | 
655 | #### 3. Mehrere Kategorien verarbeiten
656 | 
657 | ```php
658 | <?php
659 | use FriendsOfRedaxo\NavigationArray\BuildArray;
660 | $builder = BuildArray::create()
661 |     ->setCategoryFilterCallback(function($cat) {
662 |         return $cat->getValue('show_in_nav') == 1;
663 |     });
664 | 
665 | $categories = [
666 |     $builder->getCategory(3),  // Kategorie mit ID 3
667 |     $builder->getCategory(4),  // Kategorie mit ID 4
668 |     $builder->getCategory()    // Aktuelle Kategorie
669 | ];
670 | 
671 | foreach ($categories as $category) {
672 |     if ($category['is_permitted']) {
673 |         echo '<div class="cat-box' . 
674 |              ($category['current'] ? ' current' : '') . 
675 |              ($category['active'] ? ' active' : '') . 
676 |              '">';
677 |         echo $category['catName'];
678 |         echo '</div>';
679 |     }
680 | }
681 | ```
682 | 
683 | ## Methoden
684 | 
685 | ### Konstruktor
686 | 
687 | ```php
688 | public function __construct(
689 |     int $start = -1,          // Start-Kategorie ID (-1 für Root)
690 |     int $depth = 4,           // Maximale Tiefe
691 |     bool $ignoreOfflines = true, // Offline-Kategorien ignorieren
692 |     $depthSaved = 0,          // Gespeicherte Tiefe
693 |     int $level = 0            // Aktuelles Level
694 | )
695 | ```
696 | 
697 | Erstellt eine neue Instanz der NavigationArray-Klasse.
698 | 
699 | *   `$start` (`int`, optional): Die ID der Startkategorie. Verwenden Sie `-1` für die YRewrite Mount-ID oder die Root-Kategorie. Standard: `-1`.
700 | *   `$depth` (`int`, optional): Die maximale Tiefe der Navigation. Standard: `4`.
701 | *   `$ignoreOfflines` (`bool`, optional): Gibt an, ob Offline-Kategorien ignoriert werden sollen. Standard: `true`.
702 | *   `$depthSaved` (`int`, optional): Gespeicherte Tiefe, wird intern verwendet. Standard: `0`.
703 | *   `$level` (`int`, optional): Aktuelles Level, wird intern verwendet. Standard: `0`.
704 | 
705 | ### Statische Methoden
706 | 
707 | #### `create()`
708 | 
709 | ```php
710 | public static function create(): self
711 | ```
712 | 
713 | Factory-Methode zum einfachen Erstellen einer neuen Instanz.
714 | 
715 | *   Rückgabewert: Eine neue Instanz von `BuildArray` (`self`).
716 | 
717 | ### Hauptmethoden
718 | 
719 | #### `generate()`
720 | 
721 | ```php
722 | public function generate(): array
723 | ```
724 | 
725 | Generiert das Navigations-Array mit allen Kategorien und Unterkategorien basierend auf den konfigurierten Einstellungen.
726 | 
727 | *   Rückgabewert: Das generierte Navigations-Array (`array`).
728 | 
729 | #### `toJson()`
730 | 
731 | ```php
732 | public function toJson(): string
733 | ```
734 | 
735 | Generiert das Navigations-Array und gibt es als JSON-formatierte Zeichenkette zurück.
736 | 
737 | *   Rückgabewert: Das generierte Navigations-Array als JSON-String (`string`).
738 | 
739 | ### Setter-Methoden
740 | 
741 | #### `setExcludedCategories()`
742 | 
743 | ```php
744 | public function setExcludedCategories(int|array $excludedCategories): self
745 | ```
746 | 
747 | Legt fest, welche Kategorien von der Navigation ausgeschlossen werden sollen.
748 | 
749 | *   `$excludedCategories` (`int` oder `array` von `int`): Eine einzelne Kategorie-ID oder ein Array von Kategorie-IDs.
750 | *   Rückgabewert: Die aktuelle Instanz von `BuildArray` (`self`).
751 | 
752 | #### `setStart()`
753 | 
754 | ```php
755 | public function setStart(int|array $start): self
756 | ```
757 | 
758 | Setzt die Start-Kategorie(n) für die Navigation.
759 | 
760 | *   `$start` (`int` oder `array` von `int`): Die ID der Startkategorie oder ein Array von Kategorie-IDs. Verwenden Sie `-1` für die YRewrite Mount-ID oder die Root-Kategorie, `0` für die Root-Kategorie oder eine positive Zahl für eine spezifische Kategorie-ID.
761 | *   Rückgabewert: Die aktuelle Instanz von `BuildArray` (`self`).
762 | 
763 | #### `setDepth()`
764 | 
765 | ```php
766 | public function setDepth(int $depth): self
767 | ```
768 | 
769 | Legt die maximale Tiefe der Navigation fest.
770 | 
771 | *   `$depth` (`int`): Die maximale Tiefe der Navigation.
772 | *   Rückgabewert: Die aktuelle Instanz von `BuildArray` (`self`).
773 | 
774 | #### `setIgnore()`
775 | 
776 | ```php
777 | public function setIgnore(int $ignore): self
778 | ```
779 | 
780 | Legt fest, ob Offline-Kategorien ignoriert werden sollen.
781 | 
782 | *   `$ignore` (`int`): `true` (1) oder `false` (0) um Offline-Kategorien zu ignorieren.
783 | *   Rückgabewert: Die aktuelle Instanz von `BuildArray` (`self`).
784 | 
785 | #### `setLevel()`
786 | 
787 | ```php
788 | public function setLevel(int $lvl): self
789 | ```
790 | 
791 | Setzt das aktuelle Level in der Navigation.
792 | 
793 | *   `$lvl` (`int`): Das aktuelle Level der Navigation.
794 | *   Rückgabewert: Die aktuelle Instanz von `BuildArray` (`self`).
795 | 
796 | ### Callback-Methoden
797 | 
798 | #### `setCategoryFilterCallback()`
799 | 
800 | ```php
801 | public function setCategoryFilterCallback(callable $callback): self
802 | ```
803 | 
804 | Setzt eine Callback-Funktion zum Filtern von Kategorien.
805 | 
806 | *   `$callback` (`callable`): Eine Funktion, die ein `rex_category` Objekt als Parameter erhält und `true` (für die Aufnahme der Kategorie) oder `false` (für deren Ausschluss) zurückgibt.
807 | *   Rückgabewert: Die aktuelle Instanz von `BuildArray` (`self`).
808 | 
809 | #### `setCustomDataCallback()`
810 | 
811 | ```php
812 | public function setCustomDataCallback(callable $callback): self
813 | ```
814 | 
815 | Setzt eine Callback-Funktion zum Hinzufügen benutzerdefinierter Daten.
816 | 
817 | *   `$callback` (`callable`): Eine Funktion, die ein `rex_category` Objekt als Parameter erhält und ein `array` mit zusätzlichen Daten zurückgibt.
818 | *   Rückgabewert: Die aktuelle Instanz von `BuildArray` (`self`).
819 | 
820 | ### Verwendung von `toJson()`
821 | 
822 | ```php
823 | <?php
824 | use FriendsOfRedaxo\NavigationArray\BuildArray;
825 | // Grundlegende Verwendung
826 | $nav = BuildArray::create()->setDepth(3);
827 | $jsonString = $nav->toJson();
828 | 
829 | // Mit allen Optionen
830 | $nav = BuildArray::create()
831 |     ->setStart(5)             // Startet bei Kategorie ID 5
832 |     ->setDepth(2)            // Zwei Ebenen tief
833 |     ->setIgnore(true)        // Ignoriert Offline-Kategorien
834 |     ->setExcludedCategories([10, 15]) // Schließt Kategorien aus
835 |     ->toJson();              // Gibt JSON zurück
836 | 
837 | // JSON in Variable speichern und ausgeben
838 | $jsonNavigation = $nav->toJson();
839 | echo $jsonNavigation;
840 | 
841 | // Direkt als AJAX Response verwenden
842 | header('Content-Type: application/json');
843 | echo BuildArray::create()
844 |     ->setDepth(3)
845 |     ->toJson();
846 | 
847 | // JSON decodieren für weitere Verarbeitung
848 | $navigationArray = json_decode($nav->toJson(), true);
849 | ```
850 | 
851 | Das generierte JSON sieht etwa so aus:
852 | 
853 | ```json
854 | [
855 |     {
856 |         "catId": 1,
857 |         "parentId": 0,
858 |         "level": 0,
859 |         "catName": "Home",
860 |         "url": "/",
861 |         "hasChildren": true,
862 |         "children": [
863 |             {
864 |                 "catId": 5,
865 |                 "parentId": 1,
866 |                 "level": 1,
867 |                 "catName": "Über uns",
868 |                 "url": "/ueber-uns/",
869 |                 "hasChildren": false,
870 |                 "children": [],
871 |                 "path": [1, 5],
872 |                 "active": false,
873 |                 "current": false
874 |             }
875 |         ],
876 |         "path": [1],
877 |         "active": true,
878 |         "current": false
879 |     }
880 | ]
881 | ```
882 | 
883 | ## Autor
884 | 
885 | **Friends Of REDAXO**
886 | 
887 | -   <http://www.redaxo.org>
888 | -   <https://github.com/FriendsOfREDAXO>
889 | 
890 | **Projektleitung**
891 | 
892 | [Thomas Skerbis](https://github.com/skerbis)
893 | 


--------------------------------------------------------------------------------