admin back-office environment (skeleton); admin categories

1 files changed, 219 insertions, 0 deletions

diff --git a/public/app/models/cms/Course_model.php b/public/app/models/cms/Course_model.php
new file mode 100644
index 0000000..4fb49c0
--- /dev/null
+++ b/public/app/models/cms/Course_model.php
@@ -0,0 +1,219 @@
+<?php 
+namespace app\models\cms;
+
+use \Registry;
+
+
+class Course_model {
+    
+	/** get all categories
+     * 
+     * raw table data (simplest SELECT)
+     * 
+     */ 
+	public static function get_categories()
+	{
+        return Registry::use('database')->runQuery(
+		    "SELECT * FROM course",
+            []
+        );
+	}
+
+
+    /** constuct a category_tree
+     * 
+     * returns a tree representation of the categories
+     * 
+     * NOTE:
+     * category_tree() is an expensive method;
+     * it calls 2 other methods implementing recursive algorithms
+     * thus it uses many sources to run (particularly RAM).
+     * Caching the result is strogly recommended.
+     * 
+     */
+    public static function category_tree()
+    {
+        $categories = self::get_categories();          // get all categories
+
+        $tree = self::to_tree($categories);            // format to a tree
+
+        $tree_wParents = self::tree_parents($tree);    // add parents section for each tree-node
+
+        return $tree_wParents;
+    }
+
+
+    /** to_tree
+     * 
+     * constructs a tree from raw-table data;
+     * this is a private method and uses a recursive algorithm
+     * 
+     * @param $dataset (array): flar array of records with id/parent-id pairs
+     * @return $root (array): id of root category
+     * 
+     * (**) each node has 2 parts:
+     * .... .. rec    : all record attributes/data as passed into $dataset
+     * .... .. childs : array of (children) nodes
+     */
+    private static function to_tree($dataset, $root = 0)
+    {
+        $return = [];
+
+        // loop data ; search for direct children of root
+        foreach($dataset as $key => $rec) {
+
+            $child = $rec['id'];
+            $parent = $rec['parent_id'];
+
+            if ($parent == $root) {     // a direct child is found
+
+                unset($dataset[$key]);     // remove item (no need to traverse again)
+
+                // Append the child into result array ; parse its children
+                $return[] = [
+                    'rec' => [          
+                        'id' => $rec['id'],
+                        'label' => $rec['label'],
+                        'parent' => $rec['parent_id']
+                    ],
+                    'childs' => self::to_tree($dataset, $child)     // recursively
+                ];
+            }
+        }
+        return empty($return) ? [] : $return;
+    }
+
+    
+    /** tree_parents
+     * 
+     * adds a section to each tree node with all parents of each node
+     * 
+     * @param $tree (array) : nodes array (each node has `rec` and `childs` sections )
+     * @param $parents (array); DO NOT SET IT (takes values automaticaly)
+     * @return array of nodes with an extra node[parents] section
+     * 
+     */
+    private static function tree_parents($tree, $parents = [])
+    {
+        $tree_with_parents = [];
+
+        foreach($tree as $key => $node) {
+            // parents to be pushed for node's children
+            $push_parents = $parents;           // parents so far
+            $push_parents[] = $node['rec'];     // this record will be a new parent
+
+            $tree_with_parents[$key] = [
+                'rec' => $node['rec'],
+                'parents' => $parents,
+                'childs' => ($node['childs'] == [])
+                    ? []
+                    : self::tree_parents($node['childs'], $push_parents)
+            ];
+        }
+
+        return $tree_with_parents;
+    }
+
+
+    /** all_breadcrumbs
+     * -------------------------------------------------------------------------
+     * 
+     * returns an array of all breadcrumbs
+     * where array-key of each record is category[id]
+     * 
+     * NOTE:
+     * ---
+     * Course_model::all_breadcrumbs returns an indexed super-array;
+     * each array item includes a banch of information: [
+     *    breadcrumb,
+     *    rec: [ id , title ],
+     *    parents: [ [id, title] , ... ]
+     *    childs: [ [id, title] , ... ],
+     *    level
+     * ]
+     * 
+     * Use Cases:
+     * ---
+     * as a super-array, the output can be used in many cases
+     * for example...
+     * into <select-option> form elements
+     * .. while selecting category for a post
+     * .. or editing a category
+     * or directry referring to category's parents/childs
+     * 
+     * Arguments:
+     * ---
+     * @param $tree (array) : category tree (with childs and parents parts)
+     * @param $detimiter (string, optional) : string to split breadcrumb's path-nodes
+     * @param $exception (int, optional) : id of category to exclude (subcategories shall be excluded too)
+     * @param $l (int, not-pass) : depth level of the node; DO NOT SET (takes values automaticaly)
+     * @return array of breadcrumbs
+     * -------------------------------------------------------------------------
+     */
+    static public function breadcrumbs($tree, $delimiter = " / ", $exception = 0, $l = 0)
+    {
+        $all = [];      // results array
+
+        foreach($tree as $node) {       // loop through all nodes
+
+            if (intval($node['rec']['id']) != $exception) {     // if node is not exception
+
+                // construct breadcrumb html of node
+                // --- -- -- - - -
+                $breadcrumb = "";
+                foreach($node['parents'] as $par) {     // first: join path titles
+                    $breadcrumb .= $par['label'] . $delimiter;
+                }
+                $breadcrumb .= $node['rec']['label'];   // last: append title
+
+                // make a new super record
+                // --- -- -- - - -
+                $all[$node['rec']['id']] = [        // set record is as key
+                    'breadcrumb' => $breadcrumb,        // add breadcrump to results
+                    'rec' => $node['rec'],              // + node info 
+                    'parents' => $node['parents'],      // + parents array
+                    'childs' => self::first_level_childs($node),    // + direct childs
+                    'level' => $l                       // + level
+                ];
+
+                // recursively traverse children nodes
+                // --- -- -- - - -
+                if (isset($node['childs']) && $node['childs'] != []) {
+                    $child_breadcrumbs = self::breadcrumbs(
+                        $node['childs'],
+                        $delimiter,
+                        $exception,
+                        $l+1
+                    );
+
+                    $all = $all + $child_breadcrumbs;   // concatenate arrays (keep array-keys)
+                } 
+            }
+
+        }
+        return $all;
+        
+    }
+
+    /** first_level_childs
+     * --- -- -- - - -
+     * used by all_breadcrumbs()
+     */
+    static private function first_level_childs($node)
+    {
+        $childs = [];
+        if ($node['childs'] == []) {
+            return [];
+        }
+        foreach($node['childs'] as $key => $kid) {
+            $childs[] = [
+                'id' => $kid['rec']['id'],
+                'label' => $kid['rec']['label']
+            ];
+        }
+        return $childs;
+    }
+
+
+
+}