מחזור חיי בקשה

העמוד הזה עוקב אחרי בקשה אחת מרגע שהיא מגיעה לשרת ועד שהדפדפן מקבל HTML. הוא נכתב מקריאת הקוד עצמו, ולכן אפשר לסמוך עליו כשמשהו "לא מתנהג כמו שחשבתי": ברוב המקרים התשובה נמצאת באחד מהשלבים כאן. מפת העל נמצאת ב-סקירת ארכיטקטורה.

הליבה יושבת ב-api/core/ בריפו ונפרסת ל-system/core/ באתר. כל נתיב בעמוד שאינו מתחיל ב-/ הוא יחסי לתיקיית הליבה (לדוגמה collections/ROUTER.php). כתובות שמתחילות ב-/system/<name> הן כתובות URL של קונטרולרי מערכת, לא תיקייה. {admin} בכתובות הוא CONFIG::$admin_url.

התמונה כולה#

 Request
   |
   v
 [0] Apache .htaccess
       static file / cached js, css, scss on disk ----> served by Apache, PHP never runs
       everything else ------------------------------> index.php
   |
   v
 [1] index.php          ob_start(gzip) -> system/config.php -> real core path -> core.php
   |
   v
 [2] core.php
       require collections/*.php
       CONFIG::preinit()          base_path, protocol, models and cache folders
       MISC::cli_check()          only when PHP runs from the command line
       CONFIG::init()             DB platforms table -> platform for this host
       application/includes/init.php   (site hook, optional)
       cache_engine::cache_php_check() --- fresh page file? ---> echo + exit
       MISC::init_security()      SQL-looking $_GET is rejected
       CronLogger::start_capture()
       require Smarty
   |
   v
 [3] PAGE::load($_SERVER['REQUEST_URI'])
       PAGE::reset, PARAMS::init, SEO::init
       ROUTER::parse_friendly_url      URL -> $_GET (module / pname / id / sys_controller)
       client: domain check, ROUTER::redirections (301), application/includes/*.php
       admin : forms + AdminModule libraries, application/admin/includes/*.php
       LANGS::init_words, PAGE::trigger("SYSTEM_LOADED")
       client: MODULE::get_html(...)    controller method -> app_html
       admin : AdminModule::get_html()  ADMINMODULE_<panel> -> app_html   (or login screen)
       PAGE::output()                   theme + head/body assets -> full HTML
   |
   v
 [4] core.php again
       MASK::out(html)
       client + opted in: cache_engine::cache_all_page_save
       echo PAGE::parse_page(html)      PAGE::$parse_page_func hook
       CronLogger::finish_capture, STORAGE::FtpClose, DB::close_connection

שלב 0: Apache ו-.htaccess#

קובץ .htaccess שיושב בשורש האתר הוא של האתר ולא של הליבה, והוא עושה שלושה דברים:

1. מגיש ישירות קבצי JS ו-CSS שכבר נוצרו במטמון (cache/<SERVER_NAME>/...) וקבצי SCSS שכבר קומפלו. כשהקובץ קיים, PHP לא רץ בכלל. כשהוא לא קיים, הכתובת *.scss.css ו-minify/*.js|css נשלחות ל-index.php כדי שהקונטרולר minify ייצור אותן.
2. מבצע הפניות 301 מ-www ל-ללא www ומ-http ל-https, וחוסם גישה לקבצי .chc בתיקיית המטמון.
3. שולח כל כתובת אחרת ל-index.php (ה-front controller), כל עוד היא לא קובץ אמיתי ולא אחת מהתיקיות שהוחרגו:

RewriteCond $1 !^(\.well-known)
RewriteCond $1 !^(firebase-messaging-sw\.js)
RewriteCond %{REQUEST_FILENAME} !-f
RewriteCond $1 !^(index\.php|cache|application/views|application/views_mobile|system/js|system/libraries|system/css|media|themes)
RewriteRule ^(.*)$ /index.php?%{QUERY_STRING} [L]

שלב 1: index.php#

הקובץ index.php בשורש האתר קצר, ובנוי כך (בגרסת פרודקשן מומלץ להשמיט את שורת display_errors):

<?php

error_reporting(E_ALL);   // בפרודקשן אל תדליקו display_errors

ob_start("ob_gzhandler");

require_once("system/config.php");

// נתיב הליבה: יחסי ב-CONFIG_USER ("system/core" או "../shared/system/core"), כאן הוא נהיה מוחלט
$ex = explode("../", CONFIG_USER::$core_path);
$realPath = dirname(__FILE__);
if (CONFIG_USER::$core_path != "system/core") for ($i = 0; $i < (count($ex)); $i++) $realPath = dirname($realPath);
CONFIG_USER::$core_path = $realPath . "/" . $ex[(count($ex) - 1)];

require_once(CONFIG_USER::$core_path . "/core.php");

• ob_start("ob_gzhandler") דוחס את כל הפלט, כולל עמודי JSON.
• system/config.php מגדיר את המחלקה CONFIG_USER (גישה למסד, admin_url, default_module, תיקיות מטמון ועוד; הפירוט ב-קונפיגורציה).
• הנתיב לליבה יחסי: אתר שמשתף ליבה עם אתרים אחרים מצביע ל-../shared/system/core. CONFIG::preinit() יודעת את תיקיית האתר מהקובץ הראשי שהתחיל את הבקשה (index.php), ולא מנתיב הליבה.

שלב 2: core.php שורה אחר שורה#

core.php הוא כל מה שרץ ברמה העליונה, ולכן כדאי להכיר אותו בסדרו:

foreach (glob($file_location . "/collections/*.php") as $filename) require_once($filename);

(1) טעינת ה-collections. כל קובץ בתיקיית collections/ נטען, בסדר אלפביתי. בקבצים עצמם יש הגדרות מחלקות בלבד, אין להם תופעות לוואי בטעינה. אין autoloader ואין namespaces (ראו ה-Collections ו-מוסכמות ושמות).

CONFIG::preinit();

(2) CONFIG::preinit(). קובעת אזור זמן (Asia/Jerusalem), את CONFIG::$protocol (https אם $_SERVER["HTTPS"] דולק, ובשורת פקודה תמיד https), את CONFIG::$base_path מהקובץ שהתחיל את הריצה, ואת הנתיבים המוחלטים של models_folder ושל cache_folder.

MISC::cli_check();

(3) MISC::cli_check(). בריצה משורת פקודה קוראת את הארגומנטים כ-key=value ומכניסה אותם ל-$_GET; הארגומנט url= הופך ל-REQUEST_URI. בבקשת HTTP רגילה היא לא עושה כלום. פרטים ב"נתיב ה-CLI" למטה.

CONFIG::init();

(4) CONFIG::init(). קוראת את טבלת CRM_platforms (ממטמון של 30 יום), ובוחרת את הפלטפורמה לפי SERVER_NAME. אם הדומיין לא נמצא, היא מחפשת אותו בעמודה allowed_domains של כל פלטפורמה, ואם גם שם אין, לוקחת את הפלטפורמה הראשונה בטבלה. משם נקבעים CONFIG::$site_url, CONFIG::$lang (שהוא מזהה הפלטפורמה) ו-MISC::$GLOBALS["lang"]. הפירוט ב-פלטפורמות ורב-לשוניות.

if (file_exists(CONFIG::$base_path . "/application/includes/init.php")) require_once(...);

(5) application/includes/init.php. קובץ הקרס הראשון של האתר. הוא רץ אחרי שהפלטפורמה והמסד זמינים ולפני כל דבר אחר, כולל בדיקת מטמון העמודים, ולכן מתאים למשהו שחייב לרוץ בכל בקשה.

cache_engine::cache_php_check();

(6) בדיקת מטמון עמודים. אם CONFIG_USER::$allow_cache דולק, הפונקציה מנרמלת את REQUEST_URI (מסירה פרמטרי מעקב כמו utm_* ו-gclid, כדי שגלישה עם פרמטר כזה תשתמש באותו קובץ מטמון), ומחפשת קובץ cache/<host>/pages/<url>.html.gz (או pages_mobile למכשיר נייד). זמן התפוגה הוא זמן השינוי של הקובץ: הוא נחשב טרי כשה-mtime שלו עדיין בעתיד. אם יש עמוד טרי הוא מוגש (הדחוס נשלח כמו שהוא כשהדפדפן מקבל gzip), ו-exit מסיים את הבקשה. ב-hit כזה הניתוב, הקונטרולרים, Smarty והתבניות לא נטענים בכלל. אם PAGE::$parse_page_func מוגדר, העמוד עובר דרכו גם ב-hit. הנושא כולו ב-מטמון עמודים מלא.

MISC::init_security();

(7) סינון בסיסי של קלט. עוברת על הקלט של הבקשה. מפתח או ערך ב-$_GET שנראים כשאילתת SQL לפי היוריסטיקה (ביטוי כמו select * או union all, או צבר של מילות SQL כמו select, where, and, or באותה מחרוזת) מפיל את הבקשה ב-die("SECURITY ERROR1"). זו רשת ביטחון גסה ולא תחליף ל-DB::escape ו-prepared statements, ולעיתים היא חוסמת קלט לגיטימי, למשל חיפוש חופשי בעל ניסוח SQL-י. אל תסתמכו עליה לשום קלט: כל ערך שמגיע לשאילתה גולמית עובר DB::escape. ראו CSRF, XSS ו-SQLi.

CronLogger::start_capture();
require_once(CONFIG::$core_path . "/addons/Smarty/libs/Smarty.class.php");
class_alias('\Smarty\Smarty', 'Smarty');

(8) לוג cron ו-Smarty. CronLogger פותחת buffer רק כשהבקשה היא ריצת cron מאומתת (טוקן ו-id של שורת לוג). Smarty נטען כאן, ורק אחרי בדיקת המטמון. אם CONFIG::$storage_remote == "s3", נטענת גם ספריית AWS.

$outpout = PAGE::load($_SERVER['REQUEST_URI']);

(9) PAGE::load. הלב: ניתוב, קונטרולר, תצוגה ופלט. מפורט בשלב הבא. התוצאה היא מחרוזת ה-HTML המלאה (המשתנה נקרא בקוד $outpout, כך באמת).

$outpout = MASK::out($outpout);

if (CONFIG::$system_type == "client" && CONFIG::$allow_cache == true && PAGE::$cache_this_page === true)
    cache_engine::cache_all_page_save($outpout, cache_engine::get_page_url());

echo PAGE::parse_page($outpout);

(10) סיום. מצב הסוואה מחליף נתיבים ציבוריים בשמות ניטרליים, לפני השמירה במטמון, כך שהמטמון מכיל כבר HTML מוסווה. העמוד נשמר רק אם הוא בצד הלקוח, המטמון מופעל בהגדרות, וקונטרולר ביקש במפורש לשמור אותו (PAGE::$cache_this_page, שהקריאה cache_engine::cache_all_page($hours) מדליקה). ברירת המחדל היא לא לשמור. אחר כך PAGE::parse_page מריץ את ה-hook של האתר (PAGE::$parse_page_func) אם הוגדר; הוא רץ על כל תשובה, גם על עמוד שהוגש מהמטמון, כי הוא מופעל אחרי השמירה. לבסוף נסגרים לוג ה-cron, חיבור ה-FTP וחיבור המסד.

שלב 3: PAGE::load, הרצף המלא#

הפונקציה PAGE::load($url, $isMobile = null) רצה בסדר קבוע:

1. PAGE::reset(): איפוס מצב העמוד (ראו האזהרה למעלה). PARAMS::init() טוען את טבלת CRM_params, ו-SEO::init() מאפס את שדות ה-SEO.
2. ROUTER::parse_friendly_url($url): הופך כתובת לערכי $_GET ומכריע אם הבקשה היא admin או client (CONFIG::$system_type). ראו "ROUTER" למטה.
3. בצד הלקוח: בדיקת דומיין. אם SERVER_NAME אינו הדומיין של הפלטפורמה ולא מופיע ב-allowed_domains, התשובה היא die("URL ERROR"). הבקרה מוחרגת לבקשות minify ו-Tools, ולריצה משורת פקודה (ignore_domain_check).
4. בצד הלקוח: ROUTER::redirections() ואחריה FILES::include_dir("application/includes"), שטוען כל קובץ *.php שבתיקייה, ממוין לפי שם קובץ, עם require_once. זה המקום של האתר לרשום אירועים ולהוסיף נכסים. בצד הניהול הנטען הוא application/admin/includes (ראו "נתיב הניהול").
5. כל קובצי system/js/*.js נרשמים כנכסים, כש-system/js/system.js בראש העמוד והשאר בסופו. אפשר לבטל על ידי PAGE::$include_system_js = false בקובץ include.
6. בצד הלקוח: טעינת CRM_minify_files ו-CRM_minify_groups (מטמון של 30 יום) ורישום קבוצות הנכסים שמתאימות ל-theme. הרישום הזה קורה לפני שה-theme ברירת המחדל נקבע בשלב 8. קבוצה שמוגבלת ל-theme מסוים תיכלל רק אם הקוד כבר קרא ל-PAGE::set_theme (למשל מקובץ include), ועל קבוצות בלי הגבלה זה לא משפיע. ראו צינור הנכסים.
7. LANGS::init_words() טוען את מילות הממשק של השפה, ואז PAGE::trigger("SYSTEM_LOADED"). מכאן אפשר לדעת שהמערכת, השפה והנכסים מוכנים.
8. בצד הלקוח: אם אף אחד לא בחר theme, נבחר deftheme של הפלטפורמה. אם $_GET["sys_controller"] קיים, מופעל MODULE::get_html(controller, pname, true) (קונטרולר מערכת), אחרת MODULE::get_html(module, pname). התוצאה נשמרת ב-MISC::$GLOBALS["app_html"].
9. PAGE::output() מרכיב את העמוד.

ROUTER: מהכתובת ל-$_GET#

ROUTER::parse_friendly_url היא רצף בדיקות לפי סדר, והראשונה שמתאימה מנצחת (רוב הבדיקות מסתיימות ב-return או die). הסדר חשוב כי הוא קובע מי "תופס" כתובת:

דוגמאות לכתובות שאחרי ה-SEO:

ניהול. תבניות ה-admin הן {admin} לבדו, {admin}/<panel>, {admin}/<panel>/<page>, {admin}/<panel>/<page>/<id> ו-{admin}/<panel>/<מספר>, וכולן מציבות system_type = "admin". אם מוגדרת הגבלת מדינות לניהול, הניתוב בודק את מדינת הגולש לפי IP ומפנה לדף הבית אם היא לא ברשימה, חוץ מקריאה פנימית מהשרת עצמו וכתובות התשתית של Wizzo.

SEO. שורת CRM_seoUrl רגילה (regularexp = 0) מתאימה כש-sysname שווה לכתובת (גם מפוענחת). שורה עם regularexp = 1 היא ביטוי רגולרי מלא כולל מפרידים ב-sysname, וה-pageurl שלה משתמש ב-$1, $2 להחלפות. הנתיב שהתקבל נכנס מחדש לתבניות המערכת והמודולים. אם pageurl מכיל ?, הפרמטרים שאחריו מתמזגים אל $_GET. פרטים ב-כתובות ידידותיות וב-ניתוב. הטבלה נשמרת במטמון בשם seoUrl_tbl.

הפניות. ROUTER::redirections() רצה אחרי הניתוב ומחפשת את הכתובת (בלי לוכסנים בקצוות, ובלי מחרוזת שאילתה) בטבלת CRM_redirections לפי url_from. אם נמצאה, נשלחת תשובת 301 עם Location והמחרוזת המקורית מתווספת. ההפניות מתבצעות רק בצד הלקוח, ולכן אינן משפיעות על הניהול (ראו הפניות 301).

דיבוג. מנהל מחובר, או בקשה מהשרת עצמו, יכול להוסיף ?__router_trace=1 לכל כתובת ולקבל בתחתית הדף את כל ההחלטות. ראו דיבוג ניתוב.

MODULE::get_html: מ-$_GET למתודה#

public static function get_html($module, $page = "index", $is_system = false)

הפונקציה מקבלת את שם המודול ואת שם המתודה ("" הופך ל-index) ופועלת בשני מצבים:

קונטרולר מערכת ($is_system = true): הקובץ הוא core/controllers/<name>.php, בלי בדיקה ב-CRM_modules.

קונטרולר אתר: קודם MISC::get_modules_tbl() (שורות CRM_modules לפי moduleName, ממטמון modules_lang<id> של 7 ימים). המודול חייב להופיע וה-active שלו חייב להיות 1. רק אז:

1. MODULE::get($module) עושה require_once ל-application/controllers/<module>.php (אם הקובץ קיים), ובודק ש-class_exists($module). כל כשל מחזיר false ונגמר ב-404.
2. new $module() יוצר את המחלקה. הקונסטרקטור רץ גם אם המתודה המבוקשת לא קיימת, כך שתופעות לוואי שלו (הפניה, header, $_GET["pmode"] = "empg") קורות בכל מקרה.
3. אם is_callable([$mdl, $page]), נקראת המתודה ($pg_content = $mdl->$page()), והתוצאה עוברת דרך $mdl->wrapper($pg_content) (ברירת המחדל מחזירה אותה כמות שהיא; אפשר לדרוס במחלקת בסיס משותפת).
4. כל מתודה ציבורית נחשבת "callable", גם כזו שהקונטרולר ירש. ראו האזהרה בעמוד העמוד הראשון שלך.

מה שהמתודה מחזירה קובע את ההמשך:

אם המודול לא פעיל אבל קובץ הקונטרולר קיים, ומנהל מחובר, הליבה מדפיסה טופס "Click here" להפעלה ומסיימת. בכל מקרה אחר התוצאה היא "ERRORPAGE".

עזרי הקונטרולר: view, system_view, load#

כל קונטרולר יורש מ-wz_controller (בשמו הישן bgl_controller):

function view($tpl, $vars = array())        // application/views/<tpl>.tpl
function system_view($tpl, $vars = array()) // core/views/<tpl>.tpl

שתיהן קוראות ל-FILES::html_template(path, vars). אם CONFIG_USER::$use_smarty הוא true, נוצר מופע Smarty, כל המשתנים ב-$vars מוצמדים אליו, וגם המערך MISC::$GLOBALS כמשתנה $GLOBALS בתבנית. תיקיות הקומפילציה והמטמון של Smarty הן cache/Smarty/templates_c/ ו-cache/Smarty/cache/ יחסית לתיקיית העבודה של התהליך, שהיא שורש האתר תחת Apache. אין כאן קישור לתבניות הניידות (views_mobile): הקריאה לתיקייה מוחלפת בקוד כהערה ואינה פעילה.

הטוען $this->load (המחלקה wz_loader) עושה שני דברים:

$this->load->model("shop");        // require CONFIG::$models_folder . "/shop.php"; $this->shop = new shop
$this->load->library("forms");     // require core/libraries/forms.php (או את כל הקבצים אם זו תיקייה)

המודל נטען מתיקיית models של האתר ומוצמד לקונטרולר כמאפיין בשם המחלקה. ספרייה נטענת מתיקיית libraries של הליבה בלבד. הקונטרולר משתמש ב-__get ו-__set קסומים, ולכן שגיאת כתיב במאפיין ($this->shpo->x()) מחזירה null ולא שגיאה, ופירושה "Call to a member function on null".

Theme ו-PAGE::output#

PAGE::output() מתחילה בבדיקת $_GET["pmode"]:

• pmode=empg או pmode=inner: בלי theme ובלי מעטפת HTML. הפונקציה שולחת כותרות scripts ו-scripts_ver עם רשימת הנכסים שנרשמו (כדי שה-JS בצד הלקוח יטען אותם), והפלט הוא app_html בלבד. זה הנתיב של AJAX, JSON וחלונות פנימיים.
• אחרת: אם נקבע theme, נטען themes/<name>/index.php (לניהול: מהליבה, themes/admin_login ו-themes/admin_panel), ונוצרת המחלקה TEMPLATE_<name> (יורשת מ-bgl_theme שיורש מ-bgl_controller). get_html() שלה קורא ל-index() שרושם נכסים ומשתנים, ואחר כך מרנדר את themes/<name>/index.tpl עם content (תוכן העמוד) ו-pgClass. בלי theme, התוכן הוא app_html עצמו.

אחר כך מורכב ה-HTML לפי סדר קבוע:

1. <!DOCTYPE html><html lang="he" dir="..."> (הכיוון מ-CRM_platforms.direction; ה-lang קבוע ל-he).
2. בתוך <head>: תגיות SEO (SEO::tags_summary()), <base href>, נכסי CSS וה-JS של האזור head, תגיות meta של האזור, robots, favicon, ובצד הלקוח גם JSON-LD מסוג WebPage וסקריפטים מטבלת CRM_scripts (אזור head).
3. <body class="...">, ואחריו נכסים, סקריפטים ותגיות meta של האזור body_start.
4. תוכן ה-theme. כל תגית <script> שבתוכו שאין עליה nominify מוצאת מהמקום שבו כתבתם אותה ומוצבת בסוף ה-body, אחרי נכסי body_end, כשהקוד הפנימי עובר כיווץ JShrink.
5. נכסי body_end, סקריפטים של CRM_scripts מאזור body_end, ואם קיים system/system_tags.json, גם סקריפט ה-tag manager.
6. </body></html>, ובסוף PAGE::minify_html().

404, 503 ושגיאות#

כש-MODULE::get_html מקבלת "ERRORPAGE" (או שהמודול לא נמצא), נקראת MODULE::errorpage():

1. אם היו שגיאות מסד נתונים בבקשה הזו (DB::had_error()), התשובה היא 503 עם Retry-After ועמוד קבוע. הסיבה: שגיאת מסד מרוקנת את רשימת המודולים והופכת עמודים תקינים ל"לא נמצאו", ו-404 מוחק אותם מגוגל, בעוד 503 נחשב זמני.
2. אחרת, ROUTER::parse_friendly_url("404") נקראת מחדש: היא שולחת HTTP/1.1 404, מציבה PAGE::$is_404 = true ומנתבת לשורת CRM_seoUrl שה-sysname שלה הוא 404.
3. אם ה-sysname 404 מצביע על מודול פעיל, המתודה שלו מורצת והתוצאה היא העמוד. PAGE::$cache_this_page נכבה כך שה-404 לא נשמר.
4. אחרת, התשובה היא <h1>404 - Page not found</h1>.

נתיב הניהול#

כש-ROUTER מציבה system_type = "admin", PAGE::load עושה במקום הצעדים של צד הלקוח:

1. טוענת את ספריות הניהול (forms, market_service, AdminModule, panel_table), מאתחלת את ריבוי השפות של הניהול, טוענת את agent_tools ומריצה את כל application/admin/includes/*.php. אלה קבצים שבהם האתר רושם כלי MCP בעזרת AGENT_TOOLS::add_tool (כתיבת כלי MCP). כאן אין ROUTER::redirections() ואין application/includes.
2. ADMIN::is_admin() בודק התחברות. לא מחובר: ה-theme הוא admin_login, מסך התחברות מבוסס Vue, שמתקשר עם קונטרולר המערכת /system/admin_login?action=.... מחובר: ה-theme הוא admin_panel, ו-AdminModule מוצא את הפאנל.
3. AdminModule::GetPageContent מזהה פאנל וקובץ: קודם admin/<module>.php בליבה, ורק אם אינו קיים, application/admin/<module>.php של האתר. קובץ ליבה בשם זהה מגבה את פאנל האתר. המחלקה היא ADMINMODULE_<module>, והמתודה ברירת המחדל index.
4. הרשאות: הפאנל חייב להיות רשום ב-CRM_adminPanel_panels (לפי panel_name), למשתמש חייבת להיות הרשאה אליו, ופאנל שמסומן perm_developer דורש מפתח. מחלקה שמגדירה את המאפיין skip_permission_check פטורה מבדיקת ההרשאה לפאנל. פאנלים של שירותי השוק מגיעים מ-system/market_settings.json. ראו התחברות, סשנים ו-WIZZO ID ו-הרשאות וקבוצות.
5. אם המתודה חסרה, או שהפאנל לא קיים או חסום, נשלחת תשובת 404 והפניה ל-/404. בקשה של לקוח תכנותי (עם כותרת AI-...) מקבלת במקום זה JSON עם הסיבה.
6. התוצאה עוברת דרך Wrapper() של הפאנל ונכנסת ל-theme admin_panel.

המסגרת עצמה, panel_table, Form ושאר הכלים, ב-סקירת פאנל הניהול וב-בניית פאנל. בצד הניהול, CONFIG::$system_type הוא admin, ולכן תוצאת העמוד אינה נשמרת במטמון ו-MASK אינו מחליף נתיבים.

נתיב ה-CLI וה-cron#

הליבה יודעת לרוץ משורת פקודה: php index.php url=<path> key=value ... (חייבים להריץ מתיקיית האתר, כי חלק מהנתיבים בליבה יחסיים לתיקיית העבודה). MISC::cli_check() (שלב 3 ב-core.php) מעבדת את הארגומנטים:

• url=... נכנס ל-$_SERVER["REQUEST_URI"], וכל key=value אחר ל-$_GET.
• אין SERVER_NAME בשורת פקודה, ולכן CONFIG::init() בוחרת את הפלטפורמה הראשונה בטבלה, ואחר כך SERVER_NAME ו-HTTP_HOST מוגדרים לדומיין שלה. CONFIG::$ignore_domain_check נקבע ל-true, כך שבדיקת הדומיין מוחרגת.
• משם הבקשה ממשיכה כמו בקשה רגילה, כולל ניתוב ומודולים.

כך עובדים ה-cron ושירותי רקע: controllers/cron_runner.php רץ בקצב קבוע, בוחר משימות שהגיע זמנן מטבלת CRM_cron_tasks, ולכל אחת קורא ל-MISC::ping($url, $params) שמפעיל תהליך PHP מנותק ברקע (nohup php index.php url=... &). לכל ריצה נפתחת שורת לוג בסטטוס running, ו-CronLogger (שמופעל ב-core.php כשהבקשה מכילה את הטוקן ואת מזהה הלוג) תופס את הפלט ושומר אותו. הקריאה ל-cron_runner דורשת טוקן תקף (tk, מושווה ל-cron_runner_token). פירוט מלא ב-מנהל משימות (Cron).

AJAX ו-JSON#

קונטרולר שמחזיר נתונים ולא עמוד פועל לפי אותו דפוס בכל הליבה:

class orders_api extends wz_controller
{
    function __construct()
    {
        parent::__construct();
        $_GET["pmode"] = "empg";                       // בלי theme ובלי מעטפת HTML
    }

    function list()
    {
        if (!ADMIN::is_admin()) { http_response_code(403); die; }

        header("Content-Type: application/json; charset=utf-8");
        echo json_encode(["ok" => true, "items" => []], JSON_UNESCAPED_UNICODE);
        die;                                           // עוקף minify_html, parse_page ושמירה במטמון
    }
}

הכללים:

• pmode=empg נקבע לפני שהקונטרולר מחזיר תוכן, ובדרך כלל בקונסטרקטור. pmode=inner דומה, וקיים לחלונות פנימיים בניהול. שניהם משמיטים את ה-theme.
• echo ואחריו die הוא הדפוס הבטוח ל-JSON: כך הפלט לא עובר דרך minify_html, לא דרך parse_page ולא נשמר במטמון. קונטרולרים כמו core_ping ו-Tools של הליבה עובדים כך. סוג התוכן (Content-Type) אינו נקבע אוטומטית.
• 404 מחזירים בעזרת "ERRORPAGE", ואם רוצים סטטוס אחר שולחים אותו בעצמכם לפני die.
• אימות והרשאה הם באחריות הקונטרולר. אין בדיקת הרשאה מרכזית על קונטרולר רגיל או על קונטרולר מערכת. כל קונטרולר מערכת נגיש לכל מי שמבקש את הכתובת, ולכן הקוד שלו חייב לבדוק לבד (ADMIN::is_admin(), טוקן). ראו קונטרולרי מערכת, JSON API של טפסים וטבלאות ו-CSRF, XSS ו-SQLi.
• בקשות ניהול אסינכרוניות (טפסים, טבלאות) מצרפות pmode=empg לכתובת, והפאנלים מחזירים JSON או קטעי HTML.

נקודות חיבור מרוכזות#

אירועים שהליבה יורה: SYSTEM_LOADED (בסוף PAGE::load לפני הקונטרולר), delete.cache (בניקוי מטמון), storage.update ו-words_update. כל ה-API ב-PAGE: נכסים, מטא ואירועים וב-PAGE (רפרנס).

מלכודות לסיכום#

• קובץ קונטרולר בלי שורה ב-CRM_modules הוא 404, ושורה שנוספה ישירות למסד לא נראית עד שמנקים את המטמון (7 ימים). ראו העמוד הראשון שלך.
• PAGE::bind ב-init.php נמחק על ידי PAGE::reset.
• כל מתודה ציבורית היא כתובת, כולל view, system_view ו-wrapper שהקונטרולר יורש, ולכן מתודות עזר צריכות להיות private או protected.
• הקונסטרקטור רץ לפני בדיקת המתודה: אותה בקשה ל-404 יכולה להפעיל את התופעות שלו.
• $_GET מוחלף בניתוב; עריכה שלו לפני PAGE::load (למשל ב-init.php) אינה שורדת.
• שמות שמורים בניתוב (p, minify, assets, system, poosh-sw.js ועוד) לא יגיעו למודול שלכם.
• תשובת JSON שחוזרת ב-return עוברת minify_html; השתמשו ב-echo ו-die.
• סקריפט inline בתבנית מועבר לסוף העמוד, אלא אם סומן nominify.
• נתיבים יחסיים לתיקיית העבודה (Smarty, system/js, application/admin/includes) מחייבים להריץ CLI משורש האתר.
• דומיין שאינו רשום מקבל URL ERROR, ובשורת פקודה נבחרת הפלטפורמה הראשונה בטבלה.
• שגיאת מסד בזמן ניתוב נראית כ-503, לא 404.

להמשך: ניתוב, קונטרולרים של אתר, קונטרולרי מערכת, ערכות נושא, מטמון עמודים מלא ו-ROUTER ו-MODULE (רפרנס).