Concrete CMS CRUD Package

<?php
namespace ConcretePackageCustomCrud;

use ConcreteCorePackagePackage;
use ConcreteCorePageSingle;

class Controller extends Package
{
    protected $pkgHandle = 'custom_crud';
    protected $appVersionRequired = '9.0.0';
    protected $pkgVersion = '1.0.0';

    public function getPackageName()
    {
        return t('Custom CRUD Package');
    }

    public function getPackageDescription()
    {
        return t('A package to perform basic CRUD operations.');
    }

    public function install()
    {
        $pkg = parent::install();

        // Install single pages
        Single::add('/dashboard/crud', $pkg);
        Single::add('/dashboard/crud/add', $pkg);
        Single::add('/dashboard/crud/edit', $pkg);

        // Run database schema
        $this->installDatabase();
    }
}

<?xml version="1.0"?>
<schema>
    <table name="Items">
        <field name="id" type="I" size="11">
            <key />
            <autoincrement />
        </field>
        <field name="name" type="C" size="255" />
        <field name="description" type="X2" />
    </table>
</schema>

<?php
namespace ConcretePackageCustomCrudControllerSinglePageDashboard;

use ConcreteCorePageControllerDashboardPageController;
use ConcreteCoreSupportFacadeApplication;
use ConcreteCoreDatabaseConnectionConnection;

class Crud extends DashboardPageController
{
    public function view()
    {
        $db = $this->app->make(Connection::class);
        $items = $db->fetchAll("SELECT * FROM Items");
        $this->set('items', $items);
    }
}

<?php defined('C5_EXECUTE') or die("Access Denied."); ?>
<h2>Item List</h2>
<a href="<?= URL::to('/dashboard/crud/add') ?>" class="btn btn-primary mb-3">Add New Item</a>
<table class="table">
    <thead>
        <tr><th>ID</th><th>Name</th><th>Description</th><th>Action</th></tr>
    </thead>
    <tbody>
        <?php foreach ($items as $item): ?>
        <tr>
            <td><?= $item['id'] ?></td>
            <td><?= h($item['name']) ?></td>
            <td><?= h($item['description']) ?></td>
            <td>
                <a href="<?= URL::to('/dashboard/crud/edit', $item['id']) ?>" class="btn btn-sm btn-secondary">Edit</a>
            </td>
        </tr>
        <?php endforeach; ?>
    </tbody>
</table>

cd /path/to/concrete
./vendor/bin/concrete5 c5:package-install custom_crud

<?php
namespace ConcretePackageCustomCrudControllerSinglePageDashboardCrud;

use ConcreteCorePageControllerDashboardPageController;
use ConcreteCoreHttpRequest;
use ConcreteCoreDatabaseConnectionConnection;
use ConcreteCoreRoutingRedirect;

class Add extends DashboardPageController
{
    public function view()
    {
        // Just show the form
    }

    public function submit()
    {
        $request = $this->app->make(Request::class);
        $db = $this->app->make(Connection::class);

        $name = $request->request->get('name');
        $description = $request->request->get('description');

        if ($name && $description) {
            $db->insert('Items', [
                'name' => $name,
                'description' => $description,
            ]);
            $this->flash('success', 'Item added successfully.');
            return Redirect::to('/dashboard/crud');
        } else {
            $this->set('error', 'All fields are required.');
        }
    }
}

<?php defined('C5_EXECUTE') or die("Access Denied."); ?>
<h2>Add New Item</h2>

<?php if (isset($error)): ?>
    <div class="alert alert-danger"><?= $error ?></div>
<?php endif; ?>

<form method="post" action="<?= $view->action('submit') ?>">
    <div class="form-group">
        <label for="name">Name</label>
        <input type="text" name="name" class="form-control" required />
    </div>

    <div class="form-group">
        <label for="description">Description</label>
        <textarea name="description" class="form-control" rows="5" required></textarea>
    </div>

    <button type="submit" class="btn btn-success mt-2">Save</button>
</form>

<table name="Items">
    <field name="id" type="I" size="11">
        <key />
        <autoincrement />
    </field>
    <field name="name" type="C" size="255" />
    <field name="description" type="X2" />
</table>

packages/
└── custom_crud/
    ├── controller.php
    ├── db.xml
    ├── controllers/
    │   └── single_page/
    │       └── dashboard/
    │           └── crud/
    │               ├── add.php
    │               └── edit.php
    └── single_pages/
        └── dashboard/
            └── crud/
                ├── view.php
                ├── add.php
                └── edit.php

<?php
namespace ConcretePackageCustomCrud;

use ConcreteCorePackagePackage;
use ConcreteCorePageSingle;

class Controller extends Package
{
    protected $pkgHandle = 'custom_crud';
    protected $appVersionRequired = '9.0.0';
    protected $pkgVersion = '1.0.0';

    public function getPackageName()
    {
        return t('Custom CRUD Package');
    }

    public function getPackageDescription()
    {
        return t('Basic CRUD operations in dashboard.');
    }

    public function install()
    {
        $pkg = parent::install();

        Single::add('/dashboard/crud', $pkg);
        Single::add('/dashboard/crud/add', $pkg);
        Single::add('/dashboard/crud/edit', $pkg);

        $this->installDatabase();
    }
}

<?xml version="1.0"?>
<schema>
    <table name="Items">
        <field name="id" type="I">
            <key />
            <autoincrement />
        </field>
        <field name="name" type="C" size="255" />
        <field name="description" type="X2" />
    </table>
</schema>

<?php
namespace ConcretePackageCustomCrudControllerSinglePageDashboardCrud;

use ConcreteCorePageControllerDashboardPageController;
use ConcreteCoreHttpRequest;
use ConcreteCoreDatabaseConnectionConnection;
use ConcreteCoreRoutingRedirect;

class Add extends DashboardPageController
{
    public function view() {}

    public function submit()
    {
        $req = $this->app->make(Request::class);
        $db = $this->app->make(Connection::class);

        $name = $req->request->get('name');
        $desc = $req->request->get('description');

        if ($name && $desc) {
            $db->insert('Items', ['name' => $name, 'description' => $desc]);
            $this->flash('success', 'Item added successfully.');
            return Redirect::to('/dashboard/crud');
        }

        $this->set('error', 'Both fields are required.');
    }
}

<?php
namespace ConcretePackageCustomCrudControllerSinglePageDashboardCrud;

use ConcreteCorePageControllerDashboardPageController;
use ConcreteCoreHttpRequest;
use ConcreteCoreDatabaseConnectionConnection;
use ConcreteCoreRoutingRedirect;

class Edit extends DashboardPageController
{
    public function view($id = null)
    {
        $db = $this->app->make(Connection::class);
        $item = $db->fetchAssociative('SELECT * FROM Items WHERE id = ?', [$id]);

        if (!$item) {
            $this->flash('error', 'Item not found.');
            return $this->redirect('/dashboard/crud');
        }

        $this->set('item', $item);
    }

    public function submit($id)
    {
        $req = $this->app->make(Request::class);
        $db = $this->app->make(Connection::class);

        $name = $req->request->get('name');
        $desc = $req->request->get('description');

        if ($name && $desc) {
            $db->update('Items', ['name' => $name, 'description' => $desc], ['id' => $id]);
            $this->flash('success', 'Item updated.');
            return Redirect::to('/dashboard/crud');
        }

        $this->set('error', 'Both fields are required.');
        $this->view($id);
    }
}

<?php defined('C5_EXECUTE') or die("Access Denied."); ?>
<h2>Items</h2>

<a class="btn btn-primary mb-3" href="<?= URL::to('/dashboard/crud/add') ?>">Add New</a>

<?php if (isset($success)) : ?>
    <div class="alert alert-success"><?= $success ?></div>
<?php endif; ?>

<table class="table table-striped">
    <thead>
        <tr><th>ID</th><th>Name</th><th>Description</th><th>Actions</th></tr>
    </thead>
    <tbody>
        <?php foreach ($items as $item): ?>
        <tr>
            <td><?= $item['id'] ?></td>
            <td><?= h($item['name']) ?></td>
            <td><?= h($item['description']) ?></td>
            <td>
                <a href="<?= URL::to('/dashboard/crud/edit', $item['id']) ?>" class="btn btn-sm btn-secondary">Edit</a>
            </td>
        </tr>
        <?php endforeach; ?>
    </tbody>
</table>

<?php defined('C5_EXECUTE') or die("Access Denied."); ?>
<h2>Add Item</h2>

<?php if (isset($error)) : ?>
    <div class="alert alert-danger"><?= $error ?></div>
<?php endif; ?>

<form method="post" action="<?= $view->action('submit') ?>">
    <div class="form-group">
        <label>Name</label>
        <input type="text" name="name" class="form-control" required>
    </div>
    <div class="form-group">
        <label>Description</label>
        <textarea name="description" class="form-control" rows="5" required></textarea>
    </div>
    <button class="btn btn-success mt-2" type="submit">Save</button>
</form>

<?php defined('C5_EXECUTE') or die("Access Denied."); ?>
<h2>Edit Item</h2>

<?php if (isset($error)) : ?>
    <div class="alert alert-danger"><?= $error ?></div>
<?php endif; ?>

<form method="post" action="<?= $view->action('submit', $item['id']) ?>">
    <div class="form-group">
        <label>Name</label>
        <input type="text" name="name" value="<?= h($item['name']) ?>" class="form-control" required>
    </div>
    <div class="form-group">
        <label>Description</label>
        <textarea name="description" class="form-control" rows="5" required><?= h($item['description']) ?></textarea>
    </div>
    <button class="btn btn-primary mt-2" type="submit">Update</button>
</form>

./vendor/bin/concrete5 c5:package-install custom_crud

/packages/custom_crud/
├── controller.php
├── db.xml
├── controllers/single_page/dashboard/crud.php
└── single_pages/dashboard/crud/
    ├── view.php
    └── form.php

<?php
namespace ConcretePackageCustomCrudControllerSinglePageDashboard;

use ConcreteCorePageControllerDashboardPageController;
use ConcreteCoreDatabaseConnectionConnection;
use ConcreteCoreHttpRequest;
use ConcreteCoreRoutingRedirect;

class Crud extends DashboardPageController
{
    public function view()
    {
        $db = $this->app->make(Connection::class);
        $items = $db->fetchAll('SELECT * FROM Items ORDER BY id DESC');
        $this->set('items', $items);
    }

    public function add()
    {
        $this->set('action', 'add');
        $this->set('item', ['name' => '', 'description' => '']);
    }

    public function submit()
    {
        $req = $this->app->make(Request::class);
        $db = $this->app->make(Connection::class);

        $name = $req->request->get('name');
        $desc = $req->request->get('description');
        $id = $req->request->get('id'); // optional

        if ($name && $desc) {
            if ($id) {
                $db->update('Items', ['name' => $name, 'description' => $desc], ['id' => $id]);
                $this->flash('success', 'Item updated.');
            } else {
                $db->insert('Items', ['name' => $name, 'description' => $desc]);
                $this->flash('success', 'Item added.');
            }
            return Redirect::to('/dashboard/crud');
        }

        $this->set('error', 'Both fields are required.');
        $this->set('action', $id ? 'edit' : 'add');
        $this->set('item', ['id' => $id, 'name' => $name, 'description' => $desc]);
        $this->render('/dashboard/crud/form');
    }

    public function edit($id = null)
    {
        $db = $this->app->make(Connection::class);
        $item = $db->fetchAssociative('SELECT * FROM Items WHERE id = ?', [$id]);

        if (!$item) {
            $this->flash('error', 'Item not found.');
            return $this->redirect('/dashboard/crud');
        }

        $this->set('action', 'edit');
        $this->set('item', $item);
        $this->render('/dashboard/crud/form');
    }
}

<?php defined('C5_EXECUTE') or die("Access Denied."); ?>
<h2>Items</h2>

<a class="btn btn-primary mb-3" href="<?= URL::to('/dashboard/crud/add') ?>">Add New</a>

<table class="table table-striped">
    <thead>
        <tr><th>ID</th><th>Name</th><th>Description</th><th>Actions</th></tr>
    </thead>
    <tbody>
        <?php foreach ($items as $item): ?>
        <tr>
            <td><?= $item['id'] ?></td>
            <td><?= h($item['name']) ?></td>
            <td><?= h($item['description']) ?></td>
            <td>
                <a href="<?= URL::to('/dashboard/crud/edit', $item['id']) ?>" class="btn btn-sm btn-secondary">Edit</a>
            </td>
        </tr>
        <?php endforeach; ?>
    </tbody>
</table>

<?php defined('C5_EXECUTE') or die("Access Denied."); ?>

<h2><?= $action === 'edit' ? 'Edit' : 'Add' ?> Item</h2>

<?php if (isset($error)) : ?>
    <div class="alert alert-danger"><?= $error ?></div>
<?php endif; ?>

<form method="post" action="<?= $view->action('submit') ?>">
    <?php if (!empty($item['id'])): ?>
        <input type="hidden" name="id" value="<?= $item['id'] ?>" />
    <?php endif; ?>
    <div class="form-group">
        <label>Name</label>
        <input type="text" name="name" value="<?= h($item['name']) ?>" class="form-control" required>
    </div>
    <div class="form-group">
        <label>Description</label>
        <textarea name="description" class="form-control" rows="5" required><?= h($item['description']) ?></textarea>
    </div>
    <button type="submit" class="btn btn-success mt-2"><?= $action === 'edit' ? 'Update' : 'Save' ?></button>
</form>

<?php
namespace ConcretePackageShoppingFeedManager;

defined('C5_EXECUTE') or die('Access Denied.');

use ConcreteCorePackagePackage;
use ConcreteCoreDatabaseConnectionConnection;
use ConcreteCorePagePage;
use ConcreteCorePageSingle;
use Route;

class Controller extends Package
{
    protected $pkgHandle = 'shopping_feed_manager';
    protected $appVersionRequired = '9.0.0';
    protected $pkgVersion = '1.0';

    public function getPackageDescription()
    {
        return t("Google Merchant Shopping Feed package for ConcreteCMS");
    }

    public function getPackageName()
    {
        return t("Shopping Feed Manager");
    }

    public function install()
    {
        $pkg = parent::install();

        // Create dashboard pages (only those needed as "views")
        $pages = [
            '/dashboard/shopping_feed' => ['Shopping Feed', 'Shopping Feed Tools'],
            '/dashboard/shopping_feed/feeds' => ['Manage Feeds', 'List and manage feeds'],
            '/dashboard/shopping_feed/add' => ['Add Feed', 'Add a feed config'],
            '/dashboard/shopping_feed/form' => ['Feed Form', 'Used for both create and edit'],
        ];

        foreach ($pages as $path => [$name, $desc]) {
            $page = Page::getByPath($path);
            if ($page->isError()) {
                $page = Single::add($path, $pkg);
            }
            if (is_object($page) && !$page->isError()) {
                $page->update(['cName' => $name, 'cDescription' => $desc]);
            }
        }

        $this->createTables();
    }

    public function on_start()
    {
        // Controller for unified CRUD handling
        $ctrl = 'ConcretePackageShoppingFeedManagerControllerDashboardShoppingFeedFeed';

        Route::register('/dashboard/shopping_feed/create', "{$ctrl}::create");
        Route::register('/dashboard/shopping_feed/edit/{id}', "{$ctrl}::edit");
        Route::register('/dashboard/shopping_feed/update/{id}', "{$ctrl}::update");
        Route::register('/dashboard/shopping_feed/delete/{id}', "{$ctrl}::delete");

        // Public feed endpoint
        Route::register('/google-merchant-feed/{url}', 'ConcretePackageShoppingFeedManagerControllerMerchantFeed::generateXml');
    }

    protected function createTables()
    {
        /** @var Connection $db */
        $db = $this->app->make(Connection::class);

        $db->executeQuery("
            CREATE TABLE IF NOT EXISTS shoppingfeedconfiguration (
                id INT AUTO_INCREMENT PRIMARY KEY,
                url VARCHAR(255) UNIQUE NOT NULL,
                name VARCHAR(355) NOT NULL,
                settings TEXT NULL,
                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
                updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
                INDEX idx_name (name)
            )
        ");

        $db->executeQuery("
            CREATE TABLE IF NOT EXISTS shoppingfeedlog (
                id INT AUTO_INCREMENT PRIMARY KEY,
                feed_id INT NOT NULL,
                updated_at DATETIME NOT NULL,
                status VARCHAR(50),
                error_message TEXT,
                INDEX idx_feed (feed_id),
                INDEX idx_status (status),
                INDEX idx_updated_at (updated_at),
                FOREIGN KEY (feed_id) REFERENCES shoppingfeedconfiguration(id) ON DELETE CASCADE
            )
        ");
    }
}

packages/
└── shopping_feed_manager/
    ├── controller.php                      <-- Main package controller
    ├── db.xml                              <-- Database schema
    ├── src/
    │   └── Controller/
    │       └── MerchantFeed.php           <-- For public XML endpoint (/google-merchant-feed/{url})
    ├── controllers/
    │   └── dashboard/
    │       └── shopping_feed/
    │           └── feed.php               <-- Single controller handling all CRUD logic
    └── single_pages/
        └── dashboard/
            └── shopping_feed/
                ├── index.php              <-- Optional homepage
                ├── feeds.php              <-- List view
                ├── add.php                <-- Add feed form (or just redirect to form)
                └── form.php               <-- Shared form for add/edit

packages/shopping_feed_manager/single_pages/dashboard/shopping_feed/form.php

<?php defined('C5_EXECUTE') or die("Access Denied."); ?>

<?php
$formAction = isset($item['id']) ? $view->url('/dashboard/shopping_feed/update/' . $item['id']) : $view->url('/dashboard/shopping_feed/create');
$formTitle = isset($item['id']) ? 'Edit Feed' : 'Add New Feed';
?>

<h2><?= $formTitle ?></h2>

<?php if (isset($error)) : ?>
    <div class="alert alert-danger"><?= $error ?></div>
<?php endif; ?>

<form method="post" action="<?= $formAction ?>">
    <div class="form-group">
        <label for="url">Feed URL <span class="text-danger">*</span></label>
        <input type="text" name="url" id="url" value="<?= h($item['url'] ?? '') ?>" class="form-control" required>
    </div>

    <div class="form-group">
        <label for="name">Feed Name <span class="text-danger">*</span></label>
        <input type="text" name="name" id="name" value="<?= h($item['name'] ?? '') ?>" class="form-control" required>
    </div>

    <div class="form-group">
        <label for="settings">Feed Settings (JSON or XML)</label>
        <textarea name="settings" id="settings" rows="6" class="form-control"><?= h($item['settings'] ?? '') ?></textarea>
    </div>

    <button type="submit" class="btn btn-success mt-3">
        <?= isset($item['id']) ? 'Update Feed' : 'Create Feed' ?>
    </button>

    <a href="<?= URL::to('/dashboard/shopping_feed/feeds') ?>" class="btn btn-secondary mt-3">Cancel</a>
</form>

ConcreteCoreNavigationItemItem::__construct(): Argument #2 ($name) must be of type string, null given

$page = Page::getByPath($path);
if ($page->isError()) {
    $page = Single::add($path, $pkg);
}
if (is_object($page) && !$page->isError()) {
    $page->update(['cName' => $name, 'cDescription' => $desc]);
}

UPDATE Pages
JOIN PagePaths ON Pages.cID = PagePaths.cID
SET Pages.cName = 'Feed Form', Pages.cDescription = 'Used for both create and edit'
WHERE PagePaths.cPath = '/dashboard/shopping_feed/form';

public function on_start()
{
    $pages = [
        '/dashboard/shopping_feed' => ['Shopping Feed', 'Shopping Feed Tools'],
        '/dashboard/shopping_feed/feeds' => ['Manage Feeds', 'List and manage feeds'],
        '/dashboard/shopping_feed/add' => ['Add Feed', 'Add a feed config'],
        '/dashboard/shopping_feed/form' => ['Feed Form', 'Used for both create and edit'],
    ];

    foreach ($pages as $path => [$name, $desc]) {
        $page = Page::getByPath($path);
        if (is_object($page) && !$page->isError()) {
            $page->update(['cName' => $name, 'cDescription' => $desc]);
        }
    }

    // ... your Route::register lines
}

./vendor/bin/concrete5 c5:router:list

+---------------------------------------------+--------------------------+-----------------------------+
| Route                                       | Controller                | Action                      |
+---------------------------------------------+--------------------------+-----------------------------+
| /dashboard/shopping_feed/create            | ShoppingFeedFeed         | create                      |
| /dashboard/shopping_feed/edit/{id}         | ShoppingFeedFeed         | edit                        |
| /google-merchant-feed/{url}                | MerchantFeed              | generateXml                 |
| ...                                         | ...                      | ...                         |
+---------------------------------------------+--------------------------+-----------------------------+

use ConcreteCoreRoutingRouteList;

$app = ConcreteCoreSupportFacadeApplication::getFacadeApplication();
/** @var RouteList $router */
$router = $app->make(RouteList::class);
$routes = $router->getRoutes();

foreach ($routes as $route) {
    echo $route->getPath() . " → " . $route->getAction()['controller'] . "n";
}

./vendor/bin/concrete c5:router:list

+-------------------------------+----------+---------------------------------------------+
| Path                          | Method   | Callback                                    |
+-------------------------------+----------+---------------------------------------------+
| /dashboard/shopping_feed      | GET      | ConcreteControllerDashboardShoppingFeed  |
| /dashboard/shopping_feed/add  | GET      | Custom Package Controller                   |
| /google-merchant-feed/{url}   | GET      | MerchantFeed::generateXml                   |
+-------------------------------+----------+---------------------------------------------+

php vendor/bin/concrete c5:router:list

./vendor/bin/concrete c5:router:list

cd /var/www/html
./vendor/bin/concrete c5:router:list

/var/www/html/concrete/vendor/bin

/var/www/html

cd /var/www/html
./vendor/bin/concrete c5:router:list

ls -l /var/www/html/vendor/bin/concrete

ConcreteCoreNavigationItemItem::__construct(): Argument #2 ($name) must be of type string, null given

Route::register('/dashboard/shopping_feed/create', Feed::class . '::create');

/dashboard/shopping_feed/create

/shopping_feed/create

Route::register('/shopping_feed/create', Feed::class . '::create');

Single::add('/dashboard/shopping_feed/create', $pkg);

$page = Page::getByPath('/dashboard/shopping_feed/create');
if (is_object($page) && !$page->isError()) {
    $page->update(['cName' => 'Create Feed']);
}

<form method="post" action="<?= $view->url('/dashboard/shopping_feed/create') ?>">

class Feed extends DashboardPageController {
    public function create() { ... }
}

<form method="post" action="<?= $view->url('/dashboard/shopping_feed/create') ?>">

<form method="post" action="<?= URL::to('/shopping_feed/create') ?>">

Route::register('/dashboard/shopping_feed/create', '...Feed::create');

Route::register('/shopping_feed/create', '...Feed::create');

Route::register('/shopping_feed/update/{id}', '...Feed::update');
Route::register('/shopping_feed/delete/{id}', '...Feed::delete');

/dashboard/shopping_feed/create

Route::register('/dashboard/shopping_feed/create', ...);

Route::register('/shopping_feed/create', Feed::class . '::create');
Route::register('/shopping_feed/update/{id}', Feed::class . '::update');
Route::register('/shopping_feed/delete/{id}', Feed::class . '::delete');

<form method="post" action="<?= URL::to('/shopping_feed/create') ?>">

$page = Page::getByPath('/dashboard/shopping_feed/create');
if ($page->isError()) {
    $page = Single::add('/dashboard/shopping_feed/create', $pkg);
}
$page->update(['cName' => 'Create Feed']);

<?php
namespace ConcretePackageShoppingFeedManager;

use ConcreteCorePackagePackage;
use ConcreteCorePagePage;
use ConcreteCorePageSingle;
use ConcreteCoreDatabaseConnectionConnection;
use Route;

defined('C5_EXECUTE') or die('Access Denied.');

class Controller extends Package
{
    protected $pkgHandle = 'shopping_feed_manager';
    protected $appVersionRequired = '9.0.0';
    protected $pkgVersion = '1.0';

    public function getPackageDescription()
    {
        return t("Google Merchant Shopping Feed package for ConcreteCMS");
    }

    public function getPackageName()
    {
        return t("Shopping Feed Manager");
    }

    public function install()
    {
        $pkg = parent::install();

        // Only add pages that should appear in the dashboard UI
        $pages = [
            '/dashboard/shopping_feed' => ['Shopping Feed', 'Shopping Feed Tools'],
            '/dashboard/shopping_feed/feeds' => ['Manage Feeds', 'List and manage feeds'],
            '/dashboard/shopping_feed/add' => ['Add Feed', 'Add a feed config'],
            '/dashboard/shopping_feed/form' => ['Feed Form', 'Used for both create and edit'],
        ];

        foreach ($pages as $path => [$name, $desc]) {
            $page = Page::getByPath($path);
            if ($page->isError()) {
                $page = Single::add($path, $pkg);
            }
            if (is_object($page) && !$page->isError()) {
                $page->update(['cName' => $name, 'cDescription' => $desc]);
            }
        }

        $this->createTables();
    }

    public function on_start()
    {
        $ctrl = 'Concrete\Package\ShoppingFeedManager\Controller\Dashboard\ShoppingFeed\Feed';

        // ✅ These are logic routes and should NOT be inside /dashboard
        Route::register('/shopping_feed/create', "$ctrl::create");
        Route::register('/shopping_feed/update/{id}', "$ctrl::update");
        Route::register('/shopping_feed/delete/{id}', "$ctrl::delete");

        // ✅ This is okay because edit is rendered as a view in dashboard
        Route::register('/dashboard/shopping_feed/edit/{id}', "$ctrl::edit");

        // Public route for merchant feed
        Route::register('/google-merchant-feed/{url}', 'Concrete\Package\ShoppingFeedManager\Controller\MerchantFeed::generateXml');
    }

    protected function createTables()
    {
        $db = $this->app->make(Connection::class);

        $db->executeQuery("CREATE TABLE IF NOT EXISTS shoppingfeedconfiguration (
            id INT AUTO_INCREMENT PRIMARY KEY,
            url VARCHAR(255) UNIQUE NOT NULL,
            name VARCHAR(355) NOT NULL,
            settings TEXT NULL,
            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
            updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
            INDEX idx_name (name)
        )");

        $db->executeQuery("CREATE TABLE IF NOT EXISTS shoppingfeedlog (
            id INT AUTO_INCREMENT PRIMARY KEY,
            feed_id INT NOT NULL,
            updated_at DATETIME NOT NULL,
            status VARCHAR(50),
            error_message TEXT,
            INDEX idx_feed (feed_id),
            INDEX idx_status (status),
            INDEX idx_updated_at (updated_at),
            FOREIGN KEY (feed_id) REFERENCES shoppingfeedconfiguration(id) ON DELETE CASCADE
        )");
    }
}

<form method="post" action="<?= URL::to('/shopping_feed/create') ?>">

<form method="post" action="<?= URL::to('/shopping_feed/update/' . $item['id']) ?>">

ConcreteCoreNavigationItemItem::__construct(): Argument #2 ($name) must be of type string, null given

SELECT pp.cPath, p.cID, p.cName 
FROM PagePaths pp
JOIN Pages p ON pp.cID = p.cID
WHERE pp.cPath LIKE '/dashboard/shopping_feed%' AND (p.cName IS NULL OR p.cName = '');

UPDATE Pages
SET cName = 'Create Feed'
WHERE cID = [PUT_THE_CID_HERE];

./vendor/bin/concrete c5:clear-cache

./vendor/bin/concrete c5:router:list | grep shopping_feed

SELECT cID, cPath FROM PagePaths WHERE cPath LIKE '/dashboard/shopping_feed%' AND cID IN (
    SELECT cID FROM Pages WHERE cName IS NULL
);

$page = Page::getByPath('/dashboard/shopping_feed/create');
if ($page->isError()) {
    $page = Single::add('/dashboard/shopping_feed/create', $pkg);
}
if (is_object($page) && !$page->isError()) {
    $page->update(['cName' => 'Create Feed', 'cDescription' => 'Creates feed entries']);
}

use ConcreteCoreRoutingRouter;
$router = Core::make(Router::class);
foreach ($router->getRoutes() as $route) {
    echo $route->getPath() . ' => ' . ($route->getAction()['controller'] ?? 'closure') . PHP_EOL;
}

SELECT pp.cPath, p.cID, p.cName 
FROM PagePaths pp
JOIN Pages p ON pp.cID = p.cID
WHERE pp.cPath LIKE '/dashboard/shopping_feed%' AND (p.cName IS NULL OR p.cName = '');

UPDATE Pages 
SET cName = 'Create Feed', cDescription = 'Creates feed entries' 
WHERE cID = [PUT_THE_cID_HERE];

DELETE FROM PagePaths WHERE cPath = '/dashboard/shopping_feed/create';
DELETE FROM Pages WHERE cID = [the same cID];

./vendor/bin/concrete c5:clear-cache

UPDATE Pages SET cName = 'Shopping Feed', cDescription = 'Shopping Feed Tools' WHERE cID = 308;
UPDATE Pages SET cName = 'Manage Feeds', cDescription = 'List and manage feeds' WHERE cID = 309;
UPDATE Pages SET cName = 'Add Feed', cDescription = 'Add a feed config' WHERE cID = 310;
UPDATE Pages SET cName = 'Feed Form', cDescription = 'Used for both create and edit' WHERE cID = 311;

./vendor/bin/concrete c5:clear-cache

// In Feed.php
public function create() {
    // insert feed logic
}

Route::register('/shopping_feed/create', Feed::class . '::create');

<form method="post" action="<?= URL::to('/shopping_feed/create') ?>">

<form method="post" action="<?= $view->url('/dashboard/shopping_feed/create') ?>"> <!-- 🚫 WRONG -->

public function create() {
    file_put_contents(DIR_APPLICATION . '/logs/create_debug.log', 'Form hit: ' . json_encode($_POST));

    // your logic
}

tail -f application/logs/create_debug.log

<?= URL::to('/shopping_feed/create') ?>

packages/simple_feed_crud/
├── controller.php
├── db.xml
├── controllers/
│   └── dashboard/
│       └── feeds.php
├── single_pages/
│   └── dashboard/
│       └── feeds/
│           ├── view.php
│           ├── add.php
│           └── edit.php

<?php
namespace ConcretePackageSimpleFeedCrud;

use ConcreteCorePackagePackage;
use ConcreteCorePageSingle;
use ConcreteCoreDatabaseConnectionConnection;
use Page;

class Controller extends Package
{
    protected $pkgHandle = 'simple_feed_crud';
    protected $appVersionRequired = '9.0.0';
    protected $pkgVersion = '1.0';

    public function getPackageName() { return t("Simple Feed CRUD"); }
    public function getPackageDescription() { return t("A basic CRUD interface for feeds."); }

    public function install()
    {
        $pkg = parent::install();

        // Add dashboard pages
        foreach (['/dashboard/feeds', '/dashboard/feeds/add', '/dashboard/feeds/edit'] as $path) {
            if (Page::getByPath($path)->isError()) {
                Single::add($path, $pkg);
            }
        }

        $this->installDatabase();
    }
}

<?xml version="1.0"?>
<schema>
    <table name="feeds">
        <field name="id" type="I"><key /><autoincrement /></field>
        <field name="name" type="C" size="255" />
        <field name="url" type="C" size="255" />
        <field name="created_at" type="T" />
    </table>
</schema>

<?php
namespace ConcretePackageSimpleFeedCrudControllerDashboard;

use ConcreteCorePageControllerDashboardPageController;
use ConcreteCoreDatabaseConnectionConnection;
use ConcreteCoreHttpRequest;
use ConcreteCoreRoutingRedirect;

class Feeds extends DashboardPageController
{
    public function view()
    {
        $db = $this->app->make(Connection::class);
        $this->set('feeds', $db->fetchAll("SELECT * FROM feeds ORDER BY id DESC"));
    }

    public function add()
    {
        $this->render('/dashboard/feeds/add');
    }

    public function save()
    {
        $req = $this->app->make(Request::class);
        $db = $this->app->make(Connection::class);

        $name = $req->request->get('name');
        $url = $req->request->get('url');

        if ($name && $url) {
            $db->insert('feeds', ['name' => $name, 'url' => $url, 'created_at' => date('Y-m-d H:i:s')]);
            $this->flash('success', 'Feed added.');
            return Redirect::to('/dashboard/feeds');
        }

        $this->set('error', 'All fields are required.');
        $this->render('/dashboard/feeds/add');
    }

    public function edit($id = null)
    {
        $db = $this->app->make(Connection::class);
        $feed = $db->fetchAssociative("SELECT * FROM feeds WHERE id = ?", [$id]);

        if (!$feed) {
            return Redirect::to('/dashboard/feeds');
        }

        $this->set('feed', $feed);
        $this->render('/dashboard/feeds/edit');
    }

    public function update($id)
    {
        $req = $this->app->make(Request::class);
        $db = $this->app->make(Connection::class);

        $name = $req->request->get('name');
        $url = $req->request->get('url');

        if ($name && $url) {
            $db->update('feeds', ['name' => $name, 'url' => $url], ['id' => $id]);
            $this->flash('success', 'Feed updated.');
            return Redirect::to('/dashboard/feeds');
        }

        $this->set('error', 'All fields are required.');
        $this->edit($id);
    }
}

<h2>All Feeds</h2>
<a href="<?= URL::to('/dashboard/feeds/add') ?>" class="btn btn-primary mb-3">Add Feed</a>
<table class="table">
    <thead><tr><th>ID</th><th>Name</th><th>URL</th><th>Created</th><th></th></tr></thead>
    <tbody>
        <?php foreach ($feeds as $f): ?>
            <tr>
                <td><?= $f['id'] ?></td>
                <td><?= h($f['name']) ?></td>
                <td><?= h($f['url']) ?></td>
                <td><?= $f['created_at'] ?></td>
                <td><a class="btn btn-sm btn-secondary" href="<?= URL::to('/dashboard/feeds/edit', $f['id']) ?>">Edit</a></td>
            </tr>
        <?php endforeach; ?>
    </tbody>
</table>

<h2>Add Feed</h2>
<?php if (isset($error)) echo "<div class='alert alert-danger'>$error</div>"; ?>
<form method="post" action="<?= $view->action('save') ?>">
    <div class="form-group">
        <label>Name</label>
        <input class="form-control" name="name" required>
    </div>
    <div class="form-group">
        <label>URL</label>
        <input class="form-control" name="url" required>
    </div>
    <button class="btn btn-success mt-2">Save</button>
</form>

<h2>Edit Feed</h2>
<?php if (isset($error)) echo "<div class='alert alert-danger'>$error</div>"; ?>
<form method="post" action="<?= $view->action('update', $feed['id']) ?>">
    <div class="form-group">
        <label>Name</label>
        <input class="form-control" name="name" value="<?= h($feed['name']) ?>" required>
    </div>
    <div class="form-group">
        <label>URL</label>
        <input class="form-control" name="url" value="<?= h($feed['url']) ?>" required>
    </div>
    <button class="btn btn-primary mt-2">Update</button>
</form>

Single::add('/dashboard/shopping_feed/view', $pkg);

$page = Page::getByPath('/dashboard/shopping_feed/view');
if ($page->isError()) {
    $page = Single::add('/dashboard/shopping_feed/view', $pkg);
}

if (is_object($page) && !$page->isError()) {
    $page->update([
        'cName' => 'Feed List',
        'cDescription' => 'List all shopping feeds',
    ]);
}

/dashboard/shopping_feed/add
/dashboard/shopping_feed/form
/dashboard/shopping_feed/feeds

$page1 = Page::getByPath('/dashboard/shopping_feed/view');
if ($page1->isError()) {
    $page1 = Single::add('/dashboard/shopping_feed/view', $pkg);
}
if (is_object($page1) && !$page1->isError()) {
    $page1->update([
        'cName' => 'Feed List',
        'cDescription' => 'View all feed configurations',
    ]);
}

$page2 = Page::getByPath('/dashboard/shopping_feed/tracklog');
if ($page2->isError()) {
    $page2 = Single::add('/dashboard/shopping_feed/tracklog', $pkg);
}
if (is_object($page2) && !$page2->isError()) {
    $page2->update([
        'cName' => 'Track Log',
        'cDescription' => 'Log history for feed updates',
    ]);
}

./vendor/bin/concrete c5:package-update shopping_feed_manager

public function upgrade()
{
    parent::upgrade();

    $this->addDashboardPages();
}

protected function addDashboardPages()
{
    $pages = [
        '/dashboard/shopping_feed' => ['Shopping Feed', 'Shopping Feed Tools'],
        '/dashboard/shopping_feed/view' => ['Manage Feeds', 'List and manage feeds'],
        '/dashboard/shopping_feed/tracklog' => ['Tracking Log', 'View tracking log'],
    ];

    foreach ($pages as $path => [$name, $desc]) {
        $page = Page::getByPath($path);
        if ($page->isError()) {
            $page = Single::add($path, $this);
        }
        if (is_object($page) && !$page->isError()) {
            $page->update(['cName' => $name, 'cDescription' => $desc]);
        }
    }
}

public function install()
{
    $pkg = parent::install();
    $this->addDashboardPages();
    $this->createTables();
}

protected $pkgVersion = '1.1'; // e.g. from 1.0 to 1.1

./vendor/bin/concrete c5:package-update shopping_feed_manager

Single::add('/dashboard/shopping_feed/add', $pkg);

$page = Page::getByPath('/dashboard/shopping_feed/add');
if ($page->isError()) {
    $page = Single::add('/dashboard/shopping_feed/add', $pkg);
}
if (is_object($page) && !$page->isError()) {
    $page->update(['cName' => 'Add Feed', 'cDescription' => 'Hidden form for adding feed']);
    $page->setAttribute('exclude_nav', true); // 🚫 hides from sidebar
}

$visiblePages = [
    '/dashboard/shopping_feed' => ['Shopping Feed', 'Main page'],
    '/dashboard/shopping_feed/view' => ['Manage Feeds', 'List feeds'],
];

$hiddenPages = [
    '/dashboard/shopping_feed/add' => ['Add Feed', 'Hidden form'],
];

foreach ($visiblePages as $path => [$name, $desc]) {
    $page = Page::getByPath($path);
    if ($page->isError()) {
        $page = Single::add($path, $this);
    }
    if (is_object($page) && !$page->isError()) {
        $page->update(['cName' => $name, 'cDescription' => $desc]);
    }
}

foreach ($hiddenPages as $path => [$name, $desc]) {
    $page = Page::getByPath($path);
    if ($page->isError()) {
        $page = Single::add($path, $this);
    }
    if (is_object($page) && !$page->isError()) {
        $page->update(['cName' => $name, 'cDescription' => $desc]);
        $page->setAttribute('exclude_nav', true); // hide from menu
    }
}

<?php
namespace ConcretePackageShoppingFeedManagerControllerDashboardShoppingFeed;

use ConcreteCorePageControllerDashboardPageController;
use ConcreteCoreDatabaseConnectionConnection;
use ConcreteCoreHttpRequest;
use ConcreteCoreRoutingRedirect;

class Edit extends DashboardPageController
{
    public function view($id = null)
    {
        $db = $this->app->make(Connection::class);
        $feed = $db->fetchAssociative("SELECT * FROM shoppingfeedconfiguration WHERE id = ?", [$id]);

        if (!$feed) {
            $this->flash('error', 'Feed not found.');
            return $this->redirect('/dashboard/shopping_feed/view');
        }

        $this->set('feed', $feed);
    }

    public function submit($id)
    {
        $req = $this->app->make(Request::class);
        $db = $this->app->make(Connection::class);

        $url = $req->request->get('url');
        $name = $req->request->get('name');
        $settings = $req->request->get('settings');

        if ($url && $name) {
            $db->update('shoppingfeedconfiguration', compact('url', 'name', 'settings'), ['id' => $id]);
            $this->flash('success', 'Feed updated successfully.');
            return Redirect::to('/dashboard/shopping_feed/view');
        }

        $this->set('error', 'All fields are required.');
        $this->view($id); // reload form with values
    }
}

<?php defined('C5_EXECUTE') or die("Access Denied."); ?>
<h2>Edit Feed</h2>

<?php if (isset($error)): ?>
    <div class="alert alert-danger"><?= $error ?></div>
<?php endif; ?>

<form method="post" action="<?= $view->action('submit', $feed['id']) ?>">
    <div class="form-group">
        <label for="url">Feed URL</label>
        <input type="text" name="url" value="<?= h($feed['url']) ?>" class="form-control" required>
    </div>

    <div class="form-group">
        <label for="name">Feed Name</label>
        <input type="text" name="name" value="<?= h($feed['name']) ?>" class="form-control" required>
    </div>

    <div class="form-group">
        <label for="settings">Feed Settings</label>
        <textarea name="settings" class="form-control" rows="6"><?= h($feed['settings']) ?></textarea>
    </div>

    <button type="submit" class="btn btn-primary mt-2">Update Feed</button>
    <a href="<?= URL::to('/dashboard/shopping_feed/view') ?>" class="btn btn-secondary mt-2">Cancel</a>
</form>

'/dashboard/shopping_feed/edit' => ['Edit Feed', 'Edit an existing feed'],

/dashboard/shopping_feed/edit/3

Route::register('/dashboard/shopping_feed/edit/{id}', 
    'Concrete\Package\ShoppingFeedManager\Controller\Dashboard\ShoppingFeed\Edit::view');
Route::register('/dashboard/shopping_feed/edit/submit/{id}', 
    'Concrete\Package\ShoppingFeedManager\Controller\Dashboard\ShoppingFeed\Edit::submit');

<form method="post" action="<?= URL::to('/dashboard/shopping_feed/edit/submit/' . $feed['id']) ?>">

use ConcreteCoreEncryptionEncryptionService;

$encrypter = $this->app->make(EncryptionService::class);
$encryptedID = $encrypter->encrypt($feed['id']);

$url = URL::to('/dashboard/shopping_feed/edit/' . urlencode($encryptedID));

public function view($encryptedId = null)
{
    $encrypter = $this->app->make(EncryptionService::class);

    try {
        $id = $encrypter->decrypt(urldecode($encryptedId));
    } catch (Exception $e) {
        $this->flash('error', 'Invalid feed ID.');
        return $this->redirect('/dashboard/shopping_feed/view');
    }

    $db = $this->app->make(Connection::class);
    $feed = $db->fetchAssociative("SELECT * FROM shoppingfeedconfiguration WHERE id = ?", [$id]);

    if (!$feed) {
        $this->flash('error', 'Feed not found.');
        return $this->redirect('/dashboard/shopping_feed/view');
    }

    $this->set('feed', $feed);
}

<?php
$encrypter = Core::make(EncryptionService::class);
$encId = urlencode($encrypter->encrypt($f['id']));
?>
<a class="btn btn-sm btn-secondary" href="<?= URL::to('/dashboard/shopping_feed/edit/' . $encId) ?>">Edit</a>

Call to a member function encrypt() on null

$encrypter = app(ConcreteCoreEncryptionEncryptionService::class);

<?php
$encId = urlencode($encrypter->encrypt($f['id']));
?>
<a class="btn btn-sm btn-secondary" href="<?= URL::to('/dashboard/shopping_feed/edit/' . $encId) ?>">Edit</a>

$this->url('/dashboard/shopping_feed/edit', $feed['id'])

<?php
$encrypter = app(ConcreteCoreEncryptionEncryptionService::class);
?>

<?php foreach ($feeds as $feed): 
    $encId = urlencode($encrypter->encrypt($feed['id']));
?>
<tr>
    <td><?= $feed['id'] ?></td>
    <td><?= h($feed['url']) ?></td>
    <td><?= h($feed['name']) ?></td>
    <td><?= h($feed['created_at']) ?></td>
    <td>
        <a href="<?= $this->url('/dashboard/shopping_feed/edit', $encId) ?>" class="btn btn-sm btn-secondary">Edit</a>
        <a href="<?= $this->url('/dashboard/shopping_feed/delete', $encId) ?>" class="btn btn-sm btn-danger" onclick="return confirm('Are you sure?')">Delete</a>
    </td>
</tr>
<?php endforeach; ?>

use ConcreteCoreEncryptionEncryptionService;

public function view($encryptedId = null)
{
    $encrypter = $this->app->make(EncryptionService::class);

    try {
        $id = $encrypter->decrypt(urldecode($encryptedId));
    } catch (Exception $e) {
        $this->flash('error', 'Invalid or tampered link.');
        return $this->redirect('/dashboard/shopping_feed/view');
    }

    // continue with fetching $id
}

Target class [ConcreteCoreEncryptionEncryptionService] does not exist.

use ConcreteCoreEncryptionEncryptionService;
$encrypter = app(EncryptionService::class);

use ConcreteCoreSupportFacadeEncryption;
$encrypter = Encryption::getFacadeRoot();

<?php
use ConcreteCoreSupportFacadeEncryption;

$encrypter = Encryption::getFacadeRoot();
?>

<?php foreach ($feeds as $feed): 
    $encId = urlencode($encrypter->encrypt($feed['id']));
?>
<tr>
    <td><?= $feed['id'] ?></td>
    <td><?= h($feed['url']) ?></td>
    <td><?= h($feed['name']) ?></td>
    <td><?= h($feed['created_at']) ?></td>
    <td>
        <a href="<?= $this->url('/dashboard/shopping_feed/edit', $encId) ?>" class="btn btn-sm btn-secondary">Edit</a>
        <a href="<?= $this->url('/dashboard/shopping_feed/delete', $encId) ?>" class="btn btn-sm btn-danger" onclick="return confirm('Are you sure?')">Delete</a>
    </td>
</tr>
<?php endforeach; ?>

use ConcreteCoreSupportFacadeEncryption;

$id = Encryption::decrypt(urldecode($encryptedId));

use ConcreteCoreUtilityServiceEncryption;

use ConcreteCoreUtilityServiceEncryption;

$encrypter = $this->app->make(Encryption::class);
$id = $encrypter->decrypt(urldecode($encryptedId));

<?php
use ConcreteCoreUtilityServiceEncryption;

$encrypter = Core::make(Encryption::class);
?>

$encId = urlencode($encrypter->encrypt($feed['id']));

use Route;

Route::register(
    '/dashboard/shopping_feed/delete_json/{id}',
    'Concrete\Package\ShoppingFeedManager\Controller\Dashboard\ShoppingFeed\Delete::delete'
);

<?php
namespace ConcretePackageShoppingFeedManagerControllerDashboardShoppingFeed;

use ConcreteCoreControllerAbstractController;
use ConcreteCoreHttpResponseFactoryInterface;
use ConcreteCoreUtilityServiceEncryption;
use ConcreteCoreDatabaseConnectionConnection;

class Delete extends AbstractController
{
    public function delete($encId)
    {
        try {
            $encryption = $this->app->make(Encryption::class);
            $id = $encryption->decrypt(urldecode($encId));

            $db = $this->app->make(Connection::class);
            $db->delete('shoppingfeedconfiguration', ['id' => $id]);

            return $this->app->make(ResponseFactoryInterface::class)
                ->json(['success' => true, 'message' => 'Feed deleted']);
        } catch (Exception $e) {
            return $this->app->make(ResponseFactoryInterface::class)
                ->json(['success' => false, 'message' => 'Invalid ID'], 400);
        }
    }
}

<script>
function deleteFeed(id, button) {
    if (!confirm("Are you sure you want to delete this feed?")) return;

    fetch('/dashboard/shopping_feed/delete_json/' + id, {
        method: 'POST',
        headers: {
            'X-Requested-With': 'XMLHttpRequest',
            'Accept': 'application/json'
        }
    })
    .then(res => res.json())
    .then(data => {
        if (data.success) {
            // Remove row
            const row = button.closest('tr');
            row.parentNode.removeChild(row);
        } else {
            alert('Error: ' + data.message);
        }
    })
    .catch(err => alert('Request failed.'));
}
</script>

<?php
use ConcreteCoreUtilityServiceEncryption;
$encrypter = Core::make(Encryption::class);
$encId = urlencode($encrypter->encrypt($feed['id']));
?>
<a href="javascript:void(0);" class="btn btn-sm btn-danger"
   onclick="deleteFeed('<?= $encId ?>', this)">
   Delete
</a>

shopping_feed_manager/
├── css/
│   └── admin.css
├── js/
│   └── admin.js

table.table td {
    vertical-align: middle;
}
.btn-sm {
    padding: 0.3rem 0.6rem;
}

document.addEventListener('DOMContentLoaded', function () {
    console.log('Shopping Feed Manager JS loaded.');
});

use ConcreteCoreAssetAssetList;
use ConcreteCoreAssetAsset;

public function on_start()
{
    // Routes...
    Route::register('/dashboard/shopping_feed/delete_json/{id}', '...');

    // Register assets
    $al = AssetList::getInstance();
    $al->register('javascript', 'sfm-admin-js', 'js/admin.js', [], $this);
    $al->register('css', 'sfm-admin-css', 'css/admin.css', [], $this);
}

<?php
View::getInstance()->requireAsset('javascript', 'sfm-admin-js');
View::getInstance()->requireAsset('css', 'sfm-admin-css');
?>

public function on_start()
{
    $this->requireAsset('javascript', 'sfm-admin-js');
    $this->requireAsset('css', 'sfm-admin-css');
}

shopping_feed_manager/
├── css/
│   └── admin.css
├── js/
│   └── admin.js

use ConcreteCoreAssetAssetList;

public function on_start()
{
    $al = AssetList::getInstance();

    // Register assets globally with a unique handle
    $al->register('javascript', 'sfm-admin-js', 'js/admin.js', [], $this);
    $al->register('css', 'sfm-admin-css', 'css/admin.css', [], $this);

    // Auto-load these assets on all dashboard pages
    $al->requireAsset('javascript', 'sfm-admin-js');
    $al->requireAsset('css', 'sfm-admin-css');
}

$request = Request::getInstance();
$path = $request->getPathInfo();

if (strpos($path, '/dashboard/shopping_feed') === 0) {
    $al = AssetList::getInstance();
    $al->register('javascript', 'sfm-admin-js', 'js/admin.js', [], $this);
    $al->register('css', 'sfm-admin-css', 'css/admin.css', [], $this);
    $al->requireAsset('javascript', 'sfm-admin-js');
    $al->requireAsset('css', 'sfm-admin-css');
}

use ConcreteCoreAssetAssetList;

public function on_start()
{
    $al = AssetList::getInstance();

    // Register assets
    $al->register('javascript', 'sfm-admin-js', 'js/admin.js', [], $this);
    $al->register('css', 'sfm-admin-css', 'css/admin.css', [], $this);
}

public function on_start()
{
    $this->requireAsset('javascript', 'sfm-admin-js');
    $this->requireAsset('css', 'sfm-admin-css');
}

use ConcreteCoreAssetAssetList;
use ConcreteCoreHttpRequest;

public function on_start()
{
    $al = AssetList::getInstance();

    $al->register('javascript', 'sfm-admin-js', 'js/admin.js', [], $this);
    $al->register('css', 'sfm-admin-css', 'css/admin.css', [], $this);

    $req = $this->app->make(Request::class);
    $path = $req->getPath();

    if (str_starts_with($path, '/dashboard/shopping_feed')) {
        // manually output in header from view/controller
        View::getInstance()->requireAsset('javascript', 'sfm-admin-js');
        View::getInstance()->requireAsset('css', 'sfm-admin-css');
    }
}

ConcreteCoreHttpRequest

use ConcreteCoreHttpRequest;

$request = $this->app->make(Request::class);
$path = $request->getPathInfo(); // or ->getPath() if you prefer

use ConcreteCoreAssetAssetList;
use ConcreteCoreHttpRequest;

public function on_start()
{
    $al = AssetList::getInstance();

    $al->register('javascript', 'sfm-admin-js', 'js/admin.js', [], $this);
    $al->register('css', 'sfm-admin-css', 'css/admin.css', [], $this);

    $request = $this->app->make(Request::class);
    $path = $request->getPathInfo();

    if (strpos($path, '/dashboard/shopping_feed') === 0) {
        View::getInstance()->requireAsset('javascript', 'sfm-admin-js');
        View::getInstance()->requireAsset('css', 'sfm-admin-css');
    }
}

use ConcreteCoreAssetAssetList;

public function on_start()
{
    $al = AssetList::getInstance();

    // Register external React + ReactDOM from CDN
    $al->register(
        'javascript',
        'react',
        'https://unpkg.com/react@18/umd/react.development.js',
        ['local' => false]
    );
    $al->register(
        'javascript',
        'react-dom',
        'https://unpkg.com/react-dom@18/umd/react-dom.development.js',
        ['local' => false]
    );

    // Optionally register your own JS that depends on React
    $al->register(
        'javascript',
        'my-react-ui',
        'js/react-ui.js',
        ['position' => 'footer', 'depends' => ['react', 'react-dom']],
        $this
    );
}

public function on_start()
{
    $this->requireAsset('javascript', 'react');
    $this->requireAsset('javascript', 'react-dom');
    $this->requireAsset('javascript', 'my-react-ui'); // your component file
}

document.addEventListener("DOMContentLoaded", function () {
    const container = document.getElementById("react-root");
    if (container) {
        const element = React.createElement('h2', null, 'Hello from React!');
        ReactDOM.render(element, container);
    }
});

<div id="react-root"></div>

/dashboard/shopping_feed/delete_json/{encryptedId}

<td>
    <div id="react-delete-<?= $feed['id'] ?>"
         data-id="<?= urlencode($encrypter->encrypt($feed['id'])) ?>">
    </div>
</td>

<?php foreach ($feeds as $feed): 
    $encId = urlencode($encrypter->encrypt($feed['id']));
?>
<tr>
    ...
    <td>
        <div id="react-delete-<?= $feed['id'] ?>"
             data-id="<?= $encId ?>">
        </div>
    </td>
</tr>
<?php endforeach; ?>

document.addEventListener("DOMContentLoaded", function () {
    class DeleteButton extends React.Component {
        constructor(props) {
            super(props);
            this.state = { loading: false };
        }

        handleDelete = () => {
            if (!confirm("Are you sure?")) return;

            this.setState({ loading: true });

            fetch(`/dashboard/shopping_feed/delete_json/${this.props.id}`, {
                method: 'POST',
                headers: {
                    'X-Requested-With': 'XMLHttpRequest',
                    'Accept': 'application/json'
                }
            })
            .then(res => res.json())
            .then(data => {
                if (data.success) {
                    // Remove table row
                    const row = this.container.closest('tr');
                    row?.remove();
                } else {
                    alert('Error: ' + data.message);
                }
            })
            .catch(() => alert('Request failed.'))
            .finally(() => this.setState({ loading: false }));
        }

        render() {
            return (
                <button className="btn btn-sm btn-danger" onClick={this.handleDelete} disabled={this.state.loading}>
                    {this.state.loading ? 'Deleting...' : 'Delete'}
                </button>
            );
        }

        componentDidMount() {
            this.container = document.getElementById(`react-delete-${this.props.rawId}`);
        }
    }

    // Mount delete buttons
    document.querySelectorAll('[id^="react-delete-"]').forEach(div => {
        const id = div.dataset.id;
        const rawId = div.id.replace("react-delete-", "");
        ReactDOM.render(<DeleteButton id={id} rawId={rawId} />, div);
    });
});

$al->register(
    'javascript',
    'my-react-ui',
    'js/react-ui.js',
    ['position' => 'footer', 'depends' => ['react', 'react-dom']],
    $this
);

$this->requireAsset('javascript', 'react');
$this->requireAsset('javascript', 'react-dom');
$this->requireAsset('javascript', 'my-react-ui');

<script>
function Hello() {
        return <h1>Hello World!</h1>;
      }

      const container = document.getElementById('react-root');
      const root = ReactDOM.createRoot(container);
      root.render(<Hello />)
</script>

<script src="https://unpkg.com/react@18/umd/react.development.js" crossorigin></script>
<script src="https://unpkg.com/react-dom@18/umd/react-dom.development.js" crossorigin></script>
<script src="https://unpkg.com/@babel/standalone/babel.min.js"></script>

<script type="text/babel">
  function Hello() {
    return <h1>Hello from React with Babel!</h1>;
  }

  const container = document.getElementById('react-root');
  const root = ReactDOM.createRoot(container);
  root.render(<Hello />);
</script>

<div id="react-root">
    <div class="ccm-dashboard-header-buttons">
        <a href="<?= $this->url('/dashboard/shopping_feed/add') ?>" class="btn btn-primary">
            <i class="fas fa-plus"></i> Add Feed
        </a>
    </div>

    <h2>Shopping Feed Manager</h2>

    <?php if (!empty($feeds)) : ?>
        <!-- your existing table here -->
    <?php else: ?>
        <div class="alert alert-info">No feeds found yet.</div>
    <?php endif; ?>
</div>

<!-- Include React + Babel -->
<script src="https://unpkg.com/react@18/umd/react.development.js" crossorigin></script>
<script src="https://unpkg.com/react-dom@18/umd/react-dom.development.js" crossorigin></script>
<script src="https://unpkg.com/@babel/standalone/babel.min.js"></script>

<!-- Your Babel JSX code -->
<script type="text/babel">
  function Hello() {
    return <h1>Hello from React with Babel!</h1>;
  }

  const container = document.getElementById('react-root');
  const root = ReactDOM.createRoot(container);
  root.render(<Hello />);
</script>

<?php
namespace ConcretePackageShoppingFeedManagerControllerDashboardShoppingFeed;

use ConcreteCoreControllerAbstractController;
use ConcreteCoreDatabaseConnectionConnection;
use ConcreteCoreHttpResponseFactoryInterface;

class FeedApi extends AbstractController
{
    public function view()
    {
        $db = $this->app->make(Connection::class);
        $feeds = $db->fetchAll("SELECT id, url, name, created_at FROM shoppingfeedconfiguration");

        return $this->app->make(ResponseFactoryInterface::class)
            ->json($feeds);
    }
}

use Route;

public function on_start()
{
    Route::register(
        '/dashboard/shopping_feed/api/feeds',
        'Concrete\Package\ShoppingFeedManager\Controller\Dashboard\ShoppingFeed\FeedApi::view'
    );
}

<div id="react-feed-table"></div>

<script src="https://unpkg.com/react@18/umd/react.development.js" crossorigin></script>
<script src="https://unpkg.com/react-dom@18/umd/react-dom.development.js" crossorigin></script>
<script src="https://unpkg.com/@babel/standalone/babel.min.js"></script>

<script type="text/babel">
  function FeedTable() {
    const [feeds, setFeeds] = React.useState([]);

    React.useEffect(() => {
      fetch('/dashboard/shopping_feed/api/feeds')
        .then(res => res.json())
        .then(data => setFeeds(data));
    }, []);

    if (feeds.length === 0) {
      return <div class="alert alert-info">No feeds found yet.</div>;
    }

    return (
      <table className="table table-striped table-bordered">
        <thead>
          <tr>
            <th>ID</th>
            <th>Feed URL</th>
            <th>Name</th>
            <th>Created At</th>
          </tr>
        </thead>
        <tbody>
          {feeds.map(feed => (
            <tr key={feed.id}>
              <td>{feed.id}</td>
              <td>{feed.url}</td>
              <td>{feed.name}</td>
              <td>{feed.created_at}</td>
            </tr>
          ))}
        </tbody>
      </table>
    );
  }

  const root = ReactDOM.createRoot(document.getElementById('react-feed-table'));
  root.render(<FeedTable />);
</script>

use ConcreteCoreUtilityServiceEncryption;

public function view()
{
    $db = $this->app->make(Connection::class);
    $feeds = $db->fetchAll("SELECT id, url, name, created_at FROM shoppingfeedconfiguration");

    $encrypter = $this->app->make(Encryption::class);
    foreach ($feeds as &$feed) {
        $feed['encrypted_id'] = urlencode($encrypter->encrypt($feed['id']));
    }

    return $this->app->make(ResponseFactoryInterface::class)->json($feeds);
}

<script type="text/babel">
  function FeedTable() {
    const [feeds, setFeeds] = React.useState([]);

    React.useEffect(() => {
      fetch('/dashboard/shopping_feed/api/feeds')
        .then(res => res.json())
        .then(data => setFeeds(data));
    }, []);

    function deleteFeed(encId) {
      if (!confirm('Are you sure you want to delete this feed?')) return;

      fetch(`/dashboard/shopping_feed/delete_json/${encId}`, {
        method: 'POST',
        headers: {
          'X-Requested-With': 'XMLHttpRequest',
          'Accept': 'application/json'
        }
      })
      .then(res => res.json())
      .then(data => {
        if (data.success) {
          setFeeds(prev => prev.filter(f => f.encrypted_id !== encId));
        } else {
          alert('Error: ' + data.message);
        }
      })
      .catch(() => alert('Request failed.'));
    }

    if (feeds.length === 0) {
      return <div className="alert alert-info">No feeds found yet.</div>;
    }

    return (
      <table className="table table-striped table-bordered">
        <thead>
          <tr>
            <th>ID</th>
            <th>Feed URL</th>
            <th>Name</th>
            <th>Created At</th>
            <th>Actions</th>
          </tr>
        </thead>
        <tbody>
          {feeds.map(feed => (
            <tr key={feed.id}>
              <td>{feed.id}</td>
              <td>{feed.url}</td>
              <td>{feed.name}</td>
              <td>{feed.created_at}</td>
              <td>
                <button className="btn btn-sm btn-danger"
                  onClick={() => deleteFeed(feed.encrypted_id)}>
                  Delete
                </button>
              </td>
            </tr>
          ))}
        </tbody>
      </table>
    );
  }

  const root = ReactDOM.createRoot(document.getElementById('react-feed-table'));
  root.render(<FeedTable />);
</script>

Route::register(
    '/dashboard/shopping_feed/delete_json/{id}',
    'Concrete\Package\ShoppingFeedManager\Controller\Dashboard\ShoppingFeed\Delete::delete'
);

<script>
function FeedTable() {
    const [feeds, setFeeds] = React.useState([]);

    React.useEffect(() => {
      fetch('/dashboard/shopping_feed/api/feeds')
        .then(res => res.json())
        .then(data => setFeeds(data));
    }, []);

    if (feeds.length === 0) {
      return <div class="alert alert-info">No feeds found yet.</div>;
    }

    return (
      <table className="table table-striped table-bordered">
        <thead>
          <tr>
            <th>ID</th>
            <th>Feed URL</th>
            <th>Name</th>
            <th>Created At</th>
          </tr>
        </thead>
        <tbody>
          {feeds.map(feed => (
            <tr key={feed.id}>
              <td>{feed.id}</td>
              <td>{feed.url}</td>
              <td>{feed.name}</td>
              <td>{feed.created_at}</td>
            </tr>
          ))}
        </tbody>
      </table>
    );
  }

  const root = ReactDOM.createRoot(document.getElementById('react-feed-table'));
  root.render(<FeedTable />);
</script>

<script type="text/babel">
  const FeedRow = ({ feed }) => {
    return (
      <tr>
        <td>{feed.id}</td>
        <td>{feed.url}</td>
        <td>{feed.name}</td>
        <td>{feed.created_at}</td>
        <td>
          {/* Placeholder for actions */}
          <button className="btn btn-sm btn-secondary">Edit</button>
          <button className="btn btn-sm btn-danger">Delete</button>
        </td>
      </tr>
    );
  };

  const FeedTable = () => {
    const [feeds, setFeeds] = React.useState([]);
    const [loading, setLoading] = React.useState(true);

    React.useEffect(() => {
      fetch('/dashboard/shopping_feed/api/feeds')
        .then(res => res.json())
        .then(data => {
          setFeeds(data);
          setLoading(false);
        })
        .catch(() => {
          setFeeds([]);
          setLoading(false);
        });
    }, []);

    if (loading) {
      return <div className="alert alert-info">Loading feeds...</div>;
    }

    if (feeds.length === 0) {
      return <div className="alert alert-warning">No feeds found.</div>;
    }

    return (
      <table className="table table-striped table-bordered">
        <thead>
          <tr>
            <th>ID</th>
            <th>Feed URL</th>
            <th>Name</th>
            <th>Created At</th>
            <th>Actions</th>
          </tr>
        </thead>
        <tbody>
          {feeds.map(feed => (
            <FeedRow key={feed.id} feed={feed} />
          ))}
        </tbody>
      </table>
    );
  };

  ReactDOM.createRoot(document.getElementById('react-feed-table')).render(<FeedTable />);
</script>

if ($this->request->isXmlHttpRequest()) {
    return $this->app->make(ResponseFactoryInterface::class)
        ->json(['success' => true]);
}

<script type="text/babel">
  const FeedRow = ({ feed }) => (
    <tr>
      <td>{feed.id}</td>
      <td>{feed.url}</td>
      <td>{feed.name}</td>
      <td>{feed.created_at}</td>
    </tr>
  );

  const AddFeedForm = ({ onAdd }) => {
    const [name, setName] = React.useState('');
    const [url, setUrl] = React.useState('');
    const [loading, setLoading] = React.useState(false);
    const [error, setError] = React.useState(null);

    const handleSubmit = (e) => {
      e.preventDefault();
      setLoading(true);
      setError(null);

      fetch('/shopping_feed/create', {
        method: 'POST',
        headers: {
          'Content-Type': 'application/x-www-form-urlencoded',
          'X-Requested-With': 'XMLHttpRequest'
        },
        body: new URLSearchParams({ name, url })
      })
        .then(res => res.json())
        .then(res => {
          if (res.success) {
            onAdd();
            setName('');
            setUrl('');
          } else {
            setError(res.message || 'Failed to add feed');
          }
        })
        .catch(() => setError('Request failed'))
        .finally(() => setLoading(false));
    };

    return (
      <form onSubmit={handleSubmit} className="mb-4">
        <div className="row g-2 align-items-end">
          <div className="col">
            <label>Name</label>
            <input className="form-control" value={name} onChange={e => setName(e.target.value)} required />
          </div>
          <div className="col">
            <label>URL</label>
            <input className="form-control" value={url} onChange={e => setUrl(e.target.value)} required />
          </div>
          <div className="col-auto">
            <button className="btn btn-success" type="submit" disabled={loading}>
              {loading ? 'Adding...' : 'Add Feed'}
            </button>
          </div>
        </div>
        {error && <div className="text-danger mt-2">{error}</div>}
      </form>
    );
  };

  const FeedTable = () => {
    const [feeds, setFeeds] = React.useState([]);
    const [loading, setLoading] = React.useState(true);

    const fetchFeeds = () => {
      setLoading(true);
      fetch('/dashboard/shopping_feed/api/feeds')
        .then(res => res.json())
        .then(data => {
          setFeeds(data);
          setLoading(false);
        })
        .catch(() => {
          setFeeds([]);
          setLoading(false);
        });
    };

    React.useEffect(fetchFeeds, []);

    return (
      <div>
        <AddFeedForm onAdd={fetchFeeds} />

        {loading ? (
          <div className="alert alert-info">Loading feeds...</div>
        ) : feeds.length === 0 ? (
          <div className="alert alert-warning">No feeds found.</div>
        ) : (
          <table className="table table-striped table-bordered">
            <thead>
              <tr>
                <th>ID</th>
                <th>Feed URL</th>
                <th>Name</th>
                <th>Created At</th>
              </tr>
            </thead>
            <tbody>
              {feeds.map(feed => <FeedRow key={feed.id} feed={feed} />)}
            </tbody>
          </table>
        )}
      </div>
    );
  };

  ReactDOM.createRoot(document.getElementById('react-feed-table')).render(<FeedTable />);
</script>

<div id="react-feed-table"></div>

return $this->app->make(ResponseFactoryInterface::class)->json([
    'success' => true,
    'message' => 'Feed created successfully.'
]);

<script type="text/babel">
  const FeedRow = ({ feed, onDelete }) => (
    <tr>
      <td>{feed.id}</td>
      <td>{feed.url}</td>
      <td>{feed.name}</td>
      <td>{feed.created_at}</td>
      <td>
        <button className="btn btn-sm btn-danger" onClick={() => onDelete(feed.encrypted_id)}>
          Delete
        </button>
      </td>
    </tr>
  );

  const FeedTable = () => {
    const [feeds, setFeeds] = React.useState([]);
    const [loading, setLoading] = React.useState(true);
    const [currentPage, setCurrentPage] = React.useState(1);
    const feedsPerPage = 5;

    const fetchFeeds = () => {
      setLoading(true);
      fetch('/dashboard/shopping_feed/api/feeds')
        .then(res => res.json())
        .then(data => {
          setFeeds(data);
          setLoading(false);
        })
        .catch(() => {
          setFeeds([]);
          setLoading(false);
        });
    };

    const deleteFeed = (encId) => {
      if (!confirm("Are you sure?")) return;

      fetch(`/dashboard/shopping_feed/delete_json/${encId}`, {
        method: 'POST',
        headers: {
          'X-Requested-With': 'XMLHttpRequest',
          'Accept': 'application/json'
        }
      })
        .then(res => res.json())
        .then(data => {
          if (data.success) {
            setFeeds(prev => prev.filter(f => f.encrypted_id !== encId));
          } else {
            alert('Error: ' + data.message);
          }
        })
        .catch(() => alert('Delete request failed.'));
    };

    React.useEffect(fetchFeeds, []);

    const totalPages = Math.ceil(feeds.length / feedsPerPage);
    const paginatedFeeds = feeds.slice((currentPage - 1) * feedsPerPage, currentPage * feedsPerPage);

    return (
      <div>
        {loading ? (
          <div className="alert alert-info">Loading feeds...</div>
        ) : feeds.length === 0 ? (
          <div className="alert alert-warning">No feeds found.</div>
        ) : (
          <>
            <table className="table table-striped table-bordered">
              <thead>
                <tr>
                  <th>ID</th>
                  <th>Feed URL</th>
                  <th>Name</th>
                  <th>Created At</th>
                  <th>Actions</th>
                </tr>
              </thead>
              <tbody>
                {paginatedFeeds.map(feed => (
                  <FeedRow key={feed.id} feed={feed} onDelete={deleteFeed} />
                ))}
              </tbody>
            </table>

            <nav>
              <ul className="pagination">
                {Array.from({ length: totalPages }, (_, i) => (
                  <li key={i} className={`page-item ${i + 1 === currentPage ? 'active' : ''}`}>
                    <button className="page-link" onClick={() => setCurrentPage(i + 1)}>
                      {i + 1}
                    </button>
                  </li>
                ))}
              </ul>
            </nav>
          </>
        )}
      </div>
    );
  };

  ReactDOM.createRoot(document.getElementById('react-feed-table')).render(<FeedTable />);
</script>

foreach ($feeds as &$feed) {
    $feed['encrypted_id'] = urlencode($encrypter->encrypt($feed['id']));
}

<div id="react-feed-table"></div>

$feed['encrypted_id'] = urlencode($encrypter->encrypt($feed['id']));

return $this->app->make(ResponseFactoryInterface::class)->json($feeds);

Route::register(
    '/dashboard/shopping_feed/delete_json/{id}',
    'Concrete\Package\ShoppingFeedManager\Controller\Dashboard\ShoppingFeed\Delete::delete'
);

public function delete($id)
{
    $db = $this->app->make(Connection::class);
    $db->delete('shoppingfeedconfiguration', ['id' => $id]);

    return $this->app->make(ResponseFactoryInterface::class)->json([
        'success' => true,
        'message' => 'Feed deleted.'
    ]);
}

const deleteFeed = (id) => {
  if (!confirm("Are you sure?")) return;

  fetch(`/dashboard/shopping_feed/delete_json/${id}`, {
    method: 'POST',
    headers: {
      'X-Requested-With': 'XMLHttpRequest',
      'Accept': 'application/json'
    }
  })
    .then(res => res.json())
    .then(data => {
      if (data.success) {
        setFeeds(prev => prev.filter(f => f.id !== id));
      } else {
        alert('Error: ' + data.message);
      }
    })
    .catch(() => alert('Delete request failed.'));
};

// ...

{paginatedFeeds.map(feed => (
  <FeedRow key={feed.id} feed={feed} onDelete={deleteFeed} />
))}

<button className="btn btn-sm btn-danger" onClick={() => onDelete(feed.id)}>
  Delete
</button>

GET https://concrete-cms.ddev.site/dashboard/shopping_feed/api/feeds 500 (Internal Server Error)
...
Uncaught (in promise) SyntaxError: Unexpected token '<', "<!DOCTYPE "... is not valid JSON

Call to undefined class ...
Class FeedApi not found...
Missing required parameter...

packages/shopping_feed_manager/controllers/dashboard/shopping_feed/feed_api.php

<?php
namespace ConcretePackageShoppingFeedManagerControllerDashboardShoppingFeed;

use ConcreteCoreControllerAbstractController;
use ConcreteCoreDatabaseConnectionConnection;
use ConcreteCoreHttpResponseFactoryInterface;

class FeedApi extends AbstractController
{
    public function view()
    {
        $db = $this->app->make(Connection::class);
        $feeds = $db->fetchAll("SELECT id, url, name, created_at FROM shoppingfeedconfiguration");

        return $this->app->make(ResponseFactoryInterface::class)->json($feeds);
    }
}

use Route;

public function on_start()
{
    Route::register(
        '/dashboard/shopping_feed/api/feeds',
        'Concrete\Package\ShoppingFeedManager\Controller\Dashboard\ShoppingFeed\FeedApi::view'
    );
}

./vendor/bin/concrete c5:clear-cache

[
  {
    "id": 1,
    "name": "Test Feed",
    "url": "https://example.com",
    "created_at": "2025-05-15 12:34:56"
  }
]

Route::register(
    '/dashboard/shopping_feed/api/feeds',
    'Concrete\Package\ShoppingFeedManager\Controller\SinglePage\Dashboard\ShoppingFeed::apiView'
);

Route::register(
    '/dashboard/shopping_feed/delete_json/{id}',
    'Concrete\Package\ShoppingFeedManager\Controller\SinglePage\Dashboard\ShoppingFeed::deleteFeed'
);

$this->app->make(...)

public function apiView()
{
    $db = Core::make(Connection::class);
    $feeds = $db->fetchAll("SELECT id, name, url, created_at FROM shoppingfeedconfiguration");

    return Core::make(ResponseFactoryInterface::class)->json($feeds);
}

public function deleteFeed($id)
{
    $db = Core::make(Connection::class);

    try {
        $db->executeQuery("DELETE FROM shoppingfeedconfiguration WHERE id = ?", [$id]);
        return Core::make(ResponseFactoryInterface::class)
            ->json(['success' => true, 'message' => 'Feed deleted']);
    } catch (Exception $e) {
        return Core::make(ResponseFactoryInterface::class)
            ->json(['success' => false, 'message' => 'Invalid ID'], 400);
    }
}

./vendor/bin/concrete c5:clear-cache

<?php
namespace ConcretePackageShoppingFeedManagerControllerApi;

use ConcreteCoreControllerAbstractController;
use ConcreteCoreDatabaseConnectionConnection;
use ConcreteCoreHttpResponseFactoryInterface;

class FeedApi extends AbstractController
{
    public function view()
    {
        $db = Core::make(Connection::class);
        $feeds = $db->fetchAll("SELECT id, name, url, created_at FROM shoppingfeedconfiguration");

        return Core::make(ResponseFactoryInterface::class)->json($feeds);
    }

    public function delete($id)
    {
        $db = Core::make(Connection::class);

        try {
            $db->executeQuery("DELETE FROM shoppingfeedconfiguration WHERE id = ?", [$id]);
            return Core::make(ResponseFactoryInterface::class)
                ->json(['success' => true]);
        } catch (Exception $e) {
            return Core::make(ResponseFactoryInterface::class)
                ->json(['success' => false, 'message' => 'Invalid ID'], 400);
        }
    }
}

use Route;

public function on_start()
{
    Route::register(
        '/shopping_feed/api/feeds',
        'Concrete\Package\ShoppingFeedManager\Controller\Api\FeedApi::view'
    );

    Route::register(
        '/shopping_feed/api/delete/{id}',
        'Concrete\Package\ShoppingFeedManager\Controller\Api\FeedApi::delete'
    );
}

fetch('/shopping_feed/api/feeds') // instead of /dashboard/...

fetch(`/shopping_feed/api/delete/${id}`, { method: 'POST', ... })

<script>
function FeedTable() {
    const [feeds, setFeeds] = React.useState([]);

    React.useEffect(() => {
      fetch('/shopping_feed/api/feeds')
        .then(res => res.json())
        .then(data => setFeeds(data));
    }, []);

    if (feeds.length === 0) {
      return <div className="alert alert-info">No feeds found yet.</div>;
    }

    return (
      <table className="table table-striped table-bordered">
        <thead>
          <tr>
            <th>ID</th>
            <th>Feed URL</th>
            <th>Name</th>
            <th>Created At</th>
          </tr>
        </thead>
        <tbody>
          {feeds.map(feed => (
            <tr key={feed.id}>
              <td>{feed.id}</td>
              <td>{feed.url}</td>
              <td>{feed.name}</td>
              <td>{feed.created_at}</td>
            </tr>
          ))}
        </tbody>
      </table>
    );
  }
      const container = document.getElementById('react-root');
      const root = ReactDOM.createRoot(container);
      root.render(<FeedTable />)
</script>

<script type="text/babel">
  function FeedTable() {
    const [feeds, setFeeds] = React.useState([]);
    const [loading, setLoading] = React.useState(true);

    React.useEffect(() => {
      fetch('/shopping_feed/api/feeds')
        .then(res => res.json())
        .then(data => {
          setFeeds(data);
          setLoading(false);
        })
        .catch(() => {
          setFeeds([]);
          setLoading(false);
        });
    }, []);

    if (loading) {
      return <div className="alert alert-secondary">Loading feeds...</div>;
    }

    if (feeds.length === 0) {
      return <div className="alert alert-warning">No feeds found yet.</div>;
    }

    return (
      <table className="table table-striped table-bordered">
        <thead>
          <tr>
            <th>ID</th>
            <th>Feed URL</th>
            <th>Name</th>
            <th>Created At</th>
          </tr>
        </thead>
        <tbody>
          {feeds.map(feed => (
            <tr key={feed.id}>
              <td>{feed.id}</td>
              <td>{feed.url}</td>
              <td>{feed.name}</td>
              <td>{feed.created_at}</td>
            </tr>
          ))}
        </tbody>
      </table>
    );
  }

  const container = document.getElementById('react-root');
  const root = ReactDOM.createRoot(container);
  root.render(<FeedTable />);
</script>

<script type="text/babel">
  function FeedTable() {
    const [feeds, setFeeds] = React.useState([]);
    const [loading, setLoading] = React.useState(true);

    React.useEffect(() => {
      fetch('/shopping_feed/api/feeds')
        .then(res => res.json())
        .then(data => {
          setFeeds(data);
          setLoading(false);
        })
        .catch(() => {
          setFeeds([]);
          setLoading(false);
        });
    }, []);

    if (loading) {
      return <div className="alert alert-secondary">Loading feeds...</div>;
    }

    if (feeds.length === 0) {
      return <div className="alert alert-warning">No feeds found yet.</div>;
    }

    return (
      <table className="table table-striped table-bordered">
        <thead>
          <tr>
            <th>ID</th>
            <th>Feed URL</th>
            <th>Name</th>
            <th>Created At</th>
          </tr>
        </thead>
        <tbody>
          {feeds.map(feed => (
            <tr key={feed.id}>
              <td>{feed.id}</td>
              <td>{feed.url}</td>
              <td>{feed.name}</td>
              <td>{feed.created_at}</td>
            </tr>
          ))}
        </tbody>
      </table>
    );
  }

  // ✅ Safe mount
  document.addEventListener("DOMContentLoaded", function () {
    if (typeof React === "undefined" || typeof ReactDOM === "undefined") {
      console.error("React or ReactDOM not loaded.");
      return;
    }

    const container = document.getElementById("react-root");
    if (!container) {
      console.error("Target #react-root not found.");
      return;
    }

    const root = ReactDOM.createRoot(container);
    root.render(<FeedTable />);
  });
</script>

<div id="react-root">
  <noscript>Please enable JavaScript to view the feed list.</noscript>
</div>

<div id="react-root">
  <div class="react-loader alert alert-secondary">Loading feeds, please wait...</div>
</div>

<style>
  .react-loader {
    text-align: center;
    padding: 20px;
  }
</style>

<script type="text/babel">
  function FeedTable() {
    const [feeds, setFeeds] = React.useState([]);
    const [loading, setLoading] = React.useState(true);

    React.useEffect(() => {
      fetch('/shopping_feed/api/feeds')
        .then(res => res.json())
        .then(data => {
          setFeeds(data);
          setLoading(false);
        })
        .catch(() => {
          setFeeds([]);
          setLoading(false);
        });
    }, []);

    if (loading) {
      return <div className="alert alert-secondary">Loading feeds...</div>;
    }

    if (feeds.length === 0) {
      return <div className="alert alert-warning">No feeds found yet.</div>;
    }

    return (
      <table className="table table-striped table-bordered">
        <thead>
          <tr>
            <th>ID</th>
            <th>Feed URL</th>
            <th>Name</th>
            <th>Created At</th>
          </tr>
        </thead>
        <tbody>
          {feeds.map(feed => (
            <tr key={feed.id}>
              <td>{feed.id}</td>
              <td>{feed.url}</td>
              <td>{feed.name}</td>
              <td>{feed.created_at}</td>
            </tr>
          ))}
        </tbody>
      </table>
    );
  }

  document.addEventListener("DOMContentLoaded", function () {
    if (typeof React === "undefined" || typeof ReactDOM === "undefined") {
      console.error("React or ReactDOM not loaded.");
      return;
    }

    const container = document.getElementById("react-root");
    if (!container) {
      console.error("Target #react-root not found.");
      return;
    }

    // 🧼 Remove loader before mounting
    const loader = container.querySelector('.react-loader');
    if (loader) loader.remove();

    const root = ReactDOM.createRoot(container);
    root.render(<FeedTable />);
  });
</script>

<script type="text/babel">
  const FeedRow = ({ feed, onDelete }) => (
    <tr>
      <td>{feed.id}</td>
      <td>{feed.url}</td>
      <td>{feed.name}</td>
      <td>{feed.created_at}</td>
      <td>
        <a className="btn btn-sm btn-secondary me-2" href={`/dashboard/shopping_feed/edit/${feed.id}`}>
          Edit
        </a>
        <button className="btn btn-sm btn-danger" onClick={() => onDelete(feed.id)}>
          Delete
        </button>
      </td>
    </tr>
  );

  const FeedTable = () => {
    const [feeds, setFeeds] = React.useState([]);
    const [loading, setLoading] = React.useState(true);

    const fetchFeeds = () => {
      fetch('/shopping_feed/api/feeds')
        .then(res => res.json())
        .then(data => {
          setFeeds(data);
          setLoading(false);
        })
        .catch(() => {
          setFeeds([]);
          setLoading(false);
        });
    };

    const deleteFeed = (id) => {
      if (!confirm("Are you sure you want to delete this feed?")) return;

      fetch(`/shopping_feed/api/delete/${id}`, {
        method: 'POST',
        headers: {
          'X-Requested-With': 'XMLHttpRequest',
          'Accept': 'application/json'
        }
      })
        .then(res => res.json())
        .then(data => {
          if (data.success) {
            setFeeds(prev => prev.filter(f => f.id !== id));
          } else {
            alert('Error: ' + data.message);
          }
        })
        .catch(() => alert('Delete failed.'));
    };

    React.useEffect(fetchFeeds, []);

    if (loading) {
      return <div className="alert alert-secondary">Loading feeds...</div>;
    }

    if (feeds.length === 0) {
      return <div className="alert alert-warning">No feeds found.</div>;
    }

    return (
      <table className="table table-striped table-bordered">
        <thead>
          <tr>
            <th>ID</th>
            <th>Feed URL</th>
            <th>Name</th>
            <th>Created At</th>
            <th>Actions</th>
          </tr>
        </thead>
        <tbody>
          {feeds.map(feed => (
            <FeedRow key={feed.id} feed={feed} onDelete={deleteFeed} />
          ))}
        </tbody>
      </table>
    );
  };

  document.addEventListener("DOMContentLoaded", function () {
    if (typeof React === "undefined" || typeof ReactDOM === "undefined") {
      console.error("React or ReactDOM not loaded.");
      return;
    }

    const container = document.getElementById("react-root");
    if (!container) {
      console.error("Target #react-root not found.");
      return;
    }

    const loader = container.querySelector('.react-loader');
    if (loader) loader.remove();

    const root = ReactDOM.createRoot(container);
    root.render(<FeedTable />);
  });
</script>

<div id="react-root">
  <div class="react-loader alert alert-info">Loading feeds...</div>
</div>

{feeds.map(feed => (
  <tr key={feed.id}>
    ...
  </tr>
))}

{feeds.length > 0 && feeds.map(feed => (
  <tr key={feed.id}>
    <td>{feed.id}</td>
    <td>{feed.url}</td>
    <td>{feed.name}</td>
    <td>{feed.created_at}</td>
    <td>
      <a href={`/dashboard/shopping_feed/edit/${feed.id}`} className="btn btn-sm btn-secondary me-2">Edit</a>
      <button className="btn btn-sm btn-danger" onClick={() => deleteFeed(feed.id)}>Delete</button>
    </td>
  </tr>
))}

if (feeds.length === 0) return <div>No feeds found</div>

<tbody>
  {feeds.length > 0 ? (
    feeds.map(feed => (
      <tr key={feed.id}>
        <td>{feed.id}</td>
        <td>{feed.url}</td>
        <td>{feed.name}</td>
        <td>{feed.created_at}</td>
        <td>
          <a href={`/dashboard/shopping_feed/edit/${feed.id}`} className="btn btn-sm btn-secondary me-2">Edit</a>
          <button className="btn btn-sm btn-danger" onClick={() => deleteFeed(feed.id)}>Delete</button>
        </td>
      </tr>
    ))
  ) : (
    <tr>
      <td colSpan="5" className="text-center text-muted">No feeds found.</td>
    </tr>
  )}
</tbody>

<table className="table table-striped table-bordered">
  <thead>
    <tr>
      <th>ID</th>
      <th>Feed URL</th>
      <th>Name</th>
      <th>Created At</th>
      <th>Actions</th>
    </tr>
  </thead>
  <tbody>
    {feeds.length > 0 ? (
      feeds.map(feed => (
        <tr key={feed.id}>
          <td>{feed.id}</td>
          <td>{feed.url}</td>
          <td>{feed.name}</td>
          <td>{feed.created_at}</td>
          <td>
            <a href={`/dashboard/shopping_feed/edit/${feed.id}`} className="btn btn-sm btn-secondary me-2">Edit</a>
            <button className="btn btn-sm btn-danger" onClick={() => deleteFeed(feed.id)}>Delete</button>
          </td>
        </tr>
      ))
    ) : (
      <tr>
        <td colSpan="5" className="text-center text-muted">No feeds found.</td>
      </tr>
    )}
  </tbody>
</table>

<?php
namespace ConcretePackageShoppingFeedManagerController;

use ConcreteCoreControllerAbstractController;
use ConcreteCoreDatabaseConnectionConnection;
use SymfonyComponentHttpFoundationResponse;

class MerchantFeed extends AbstractController
{
    public function generateXml($feedSlug = null)
    {
        $db = Core::make(Connection::class);

        // OPTIONAL: if using a custom slug to load feed config
        if ($feedSlug) {
            $config = $db->fetchAssociative("SELECT * FROM shoppingfeedconfiguration WHERE url = ?", [$feedSlug]);
            if (!$config) {
                return new Response("Feed not found", 404);
            }
        }

        // Fetch your feed items
        $products = $db->fetchAll("SELECT * FROM products ORDER BY id DESC");

        // Build XML
        $xml = new SimpleXMLElement('<?xml version="1.0" encoding="UTF-8"?><rss version="2.0"/>');
        $xml->addAttribute('xmlns:g', 'http://base.google.com/ns/1.0');

        $channel = $xml->addChild('channel');
        $channel->addChild('title', 'Your Store Feed');
        $channel->addChild('link', 'https://yourstore.com');
        $channel->addChild('description', 'Product feed for Google Merchant Center');

        foreach ($products as $product) {
            $item = $channel->addChild('item');
            $item->addChild('g:id', $product['id'], 'http://base.google.com/ns/1.0');
            $item->addChild('title', htmlspecialchars($product['name']));
            $item->addChild('description', htmlspecialchars($product['description']));
            $item->addChild('link', htmlspecialchars($product['product_url']));
            $item->addChild('g:image_link', htmlspecialchars($product['image_url']), 'http://base.google.com/ns/1.0');
            $item->addChild('g:availability', 'in stock', 'http://base.google.com/ns/1.0');
            $item->addChild('g:price', $product['price'] . ' INR', 'http://base.google.com/ns/1.0');
            $item->addChild('g:brand', htmlspecialchars($product['brand']), 'http://base.google.com/ns/1.0');
            $item->addChild('g:condition', 'new', 'http://base.google.com/ns/1.0');
        }

        $xmlContent = $xml->asXML();

        return new Response(
            $xmlContent,
            200,
            ['Content-Type' => 'application/xml']
        );
    }
}

Route::register(
    '/google-merchant-feed/{slug}',
    'Concrete\Package\ShoppingFeedManager\Controller\MerchantFeed::generateXml'
);

https://yourdomain.com/google-merchant-feed/default

$sql = "
    SELECT p.*, GROUP_CONCAT(pg.gID) AS group_ids
    FROM CommunityStoreProducts p
    LEFT JOIN CommunityStoreProductGroups pg ON pg.pID = p.id
    WHERE $condition
    GROUP BY p.id
    ORDER BY p.id DESC
";

$products = $db->fetchAll($sql);

foreach ($products as $product) {
    $item = $channel->addChild('item');
    $item->addChild('g:id', $product['id'], 'http://base.google.com/ns/1.0');
    $item->addChild('title', htmlspecialchars($product['name']));
    $item->addChild('description', htmlspecialchars($product['description']));
    $item->addChild('link', htmlspecialchars($product['product_url']));
    $item->addChild('g:image_link', htmlspecialchars($product['image_url']), 'http://base.google.com/ns/1.0');
    $item->addChild('g:availability', 'in stock', 'http://base.google.com/ns/1.0');
    $item->addChild('g:price', $product['price'] . ' INR', 'http://base.google.com/ns/1.0');
    $item->addChild('g:brand', htmlspecialchars($product['brand']), 'http://base.google.com/ns/1.0');
    $item->addChild('g:condition', 'new', 'http://base.google.com/ns/1.0');

    // Optional: Add group IDs as custom tag
    if (!empty($product['group_ids'])) {
        $item->addChild('g:product_group_ids', $product['group_ids'], 'http://base.google.com/ns/1.0');
    }
}

CommunityStoreGroup
- gID
- groupName

$groupIds = implode(',', array_map('intval', $product_groups_selected));

$sql = "
    SELECT p.*
    FROM CommunityStoreProducts p
    INNER JOIN CommunityStoreProductGroups pg ON pg.pID = p.id
    WHERE pg.gID IN ($groupIds)
    GROUP BY p.id
    ORDER BY p.id DESC
";

$products = $db->fetchAll($sql);

$extraConditions = "pg.gID IN ($groupIds)";

if ($selectedMin && $selectedMax) {
    $extraConditions .= " AND p.price BETWEEN $selectedMin AND $selectedMax";
}

$sql = "
    SELECT p.*
    FROM CommunityStoreProducts p
    INNER JOIN CommunityStoreProductGroups pg ON pg.pID = p.id
    WHERE $extraConditions
    GROUP BY p.id
    ORDER BY p.id DESC
";

$baseSelect = "SELECT p.*";
$baseFrom   = "FROM CommunityStoreProducts p";
$joins      = [];
$conditions = ["1=1"];
$params     = [];

// Price range condition
if (!empty($settings['price_range']['min']) && !empty($settings['price_range']['max'])) {
    $conditions[] = "p.price BETWEEN ? AND ?";
    $params[] = (float) $settings['price_range']['min'];
    $params[] = (float) $settings['price_range']['max'];
}

// Product group filter
if (!empty($settings['product_groups'])) {
    $groupIds = array_map('intval', $settings['product_groups']);
    $joins[] = "INNER JOIN CommunityStoreProductGroups pg ON pg.pID = p.id";
    $conditions[] = "pg.gID IN (" . implode(',', $groupIds) . ")";
}

// Product type filter
if (!empty($settings['product_types'])) {
    $productTypes = array_map('intval', $settings['product_types']);
    $conditions[] = "p.pType IN (" . implode(',', $productTypes) . ")";
}

// Build final query
$sql = "
    $baseSelect
    $baseFrom
    " . implode(" ", $joins) . "
    WHERE " . implode(" AND ", $conditions) . "
    GROUP BY p.id
    ORDER BY p.id DESC
";

$products = $db->fetchAll($sql, $params);

use ConcretePackageCommunityStoreSrcCommunityStoreProductProduct;

$product = Product::getByID($productID);

if ($product) {
    $url = $product->getProductLink();
    echo $url;
}

use ConcretePackageCommunityStoreSrcCommunityStoreProductProduct;

$products = Product::getAll();

foreach ($products as $product) {
    $url = $product->getProductLink();
    echo $url;
}

/store/product/sample-product

echo URL::to($product->getProductLink());

echo Core::make('url')->to($product->getProductLink());

$product = Product::getByID($row['pID']);
$url = $product ? $product->getProductLink() : '';

$product->getProductPage();

$page = $product->getProductPage();

if ($page) {
    $url = $page->getCollectionLink(); // returns full front-end URL
    echo $url;
}

$url = $product->getProductPage() ? $product->getProductPage()->getCollectionLink() : '';

use ConcretePackageCommunityStoreSrcCommunityStoreProductProduct;

$products = Product::getAll();

foreach ($products as $product) {
    $url = $product->getProductPage()?->getCollectionLink();

    echo '<a href="' . h($url) . '">' . h($product->getName()) . '</a>';
}

use ConcretePackageCommunityStoreSrcCommunityStoreUtilitiesCalculator;

$currencyCode = Calculator::getCurrencyCode(); // returns 'USD', 'INR', etc.

$currencySymbol = Calculator::getCurrencySymbol(); // returns '₹', '$', etc.

$symbol = Config::get('community_store.symbol');
$code   = Config::get('community_store.currency');

echo 'Currency: ' . Calculator::getCurrencyCode();     // e.g., INR
echo 'Symbol: ' . Calculator::getCurrencySymbol();     // e.g., ₹

use ConcretePackageCommunityStoreSrcCommunityStoreProductProduct;

$product = Product::getByID($productID);

if ($product && $product->getImage()) {
    $image = $product->getImage();
    $imageUrl = $image->getURL();
    echo $imageUrl;
}

$imageUrl = $product->getImageThumb(); // uses default thumbnail

$imageUrl = $product->getImageThumb(600, 600); // width, height

$imageUrl = $product->getImage() ? $product->getImage()->getURL() : '';

<g:image_link><?= h($product->getImage()?->getURL()) ?></g:image_link>

use ConcreteCoreFileFile;

$imageUrl = '';
$imageFID = $product->getImage(); // returns file ID

if ($imageFID) {
    $file = File::getByID($imageFID);
    if ($file && is_object($file)) {
        $imageUrl = $file->getRelativePath(); // or getURL()
    }
}

use ConcreteCoreFileFile;

$imageUrl = ($fid = $product->getImage()) ? File::getByID($fid)?->getRelativePath() : '';

$imageUrl = File::getByID($fid)?->getURL();

use ConcreteCoreFileFile;

$productImage = '';
if ($product->getImage()) {
    $f = File::getByID($product->getImage());
    $productImage = $f ? $f->getURL() : '';
}

echo '<g:image_link>' . h($productImage) . '</g:image_link>';

$image = $product->getImage();
if ($image && is_object($image)) {
    $imageUrl = $image->getURL(); // or getRelativePath()
    echo $imageUrl;
}

use ConcretePackageCommunityStoreSrcCommunityStoreProductProduct;

$product = Product::getByID($productID);

$imageUrl = '';
$image = $product->getImage();

if ($image && method_exists($image, 'getURL')) {
    $imageUrl = $image->getURL();
}

echo $imageUrl;

$product = Product::getByID($row['pID']); // not raw db row

use ConcretePackageCommunityStoreSrcCommunityStoreProductProduct;

$product = Product::getByID($id);

if ($product && ($img = $product->getImage()) && is_object($img)) {
    echo '<g:image_link>' . h($img->getURL()) . '</g:image_link>';
}

$products = $db->fetchAll("SELECT * FROM CommunityStoreProducts");

use ConcreteCoreFileFile;

foreach ($products as $row) {
    $imageUrl = '';

    if (!empty($row['pImage'])) {
        $file = File::getByID($row['pImage']);
        if ($file && is_object($file)) {
            $imageUrl = $file->getURL();
        }
    }

    echo '<g:image_link>' . h($imageUrl) . '</g:image_link>';
}

pImage

$row['pImage']

foreach ($products as $row) {
    $file = ConcreteCoreFileFile::getByID($row['pImage']);
    $imageUrl = $file ? $file->getURL() : '';

    echo '<item>';
    echo '<title>' . h($row['pName']) . '</title>';
    echo '<g:image_link>' . h($imageUrl) . '</g:image_link>';
    echo '</item>';
}

use ConcreteCoreSupportFacadeUrl;

$baseUrl = Url::to('/');
echo $baseUrl; // Outputs: https://yourdomain.com/

$baseUrl = (string) Url::to('/');

$baseUrl = rtrim(Core::make('url/canonical')->getUrl(), '/') . '/';

$imageUrl = $baseUrl . ltrim($file->getRelativePath(), '/');

$imageUrl = $file->getURL(); // Already full absolute URL

$productLink = $productPage->getCollectionLink(); // full URL
$imageUrl = $file->getURL();

echo '<link>' . h($productLink) . '</link>';
echo '<g:image_link>' . h($imageUrl) . '</g:image_link>';

<IfModule mod_rewrite.c>
    RewriteEngine On
    RewriteBase /

    RewriteCond %{REQUEST_FILENAME} !-f
    RewriteCond %{REQUEST_FILENAME} !-d
    RewriteRule ^(.*)$ index.php/$1 [L]
</IfModule>

RewriteBase /

RewriteBase /site/

sudo a2enmod rewrite
sudo systemctl restart apache2

./vendor/bin/concrete c5:clear-cache

$productu->getProductPage();

$page = $productu->getProductPage();

if (!$page) {
    continue; // Skip product with no page
}

foreach ($products as $product) {
    $productu = Product::getByID($product['pID']);
    $page = $productu->getProductPage();

    // Skip products with no page assigned
    if (!$page) {
        continue;
    }

    $url = $page->getCollectionLink();

    // Image
    $imageUrl = '';
    $image = $productu->getImageObj();
    if (is_object($image)) {
        $imageUrl = $image->getURL(); // full URL, no need to prefix with $baseUrl
    }

    $item = $channel->addChild('item');
    $item->addChild('g:id', $product['pID'], 'http://base.google.com/ns/1.0');
    $item->addChild('title', htmlspecialchars($product['pName']));
    $item->addChild('description', htmlspecialchars($product['pDesc']));
    $item->addChild('link', htmlspecialchars($url));
    $item->addChild('g:image_link', htmlspecialchars($imageUrl), 'http://base.google.com/ns/1.0');
    $item->addChild('g:availability', 'in stock', 'http://base.google.com/ns/1.0');
    $item->addChild('g:price', $product['pPrice'] . ' USD', 'http://base.google.com/ns/1.0');
    $item->addChild('g:brand', htmlspecialchars($product['pManufacturer']), 'http://base.google.com/ns/1.0');
    $item->addChild('g:condition', 'new', 'http://base.google.com/ns/1.0');
}

if (!$page) {
    Log::addInfo("Product {$product['pID']} skipped - no product page assigned.");
    continue;
}

$page = $productu->getProductPage();

Page::getByID($product->getPageID());

$page = $productu->getProductPage();

use ConcreteCorePagePage;

$page = Page::getByID($productu->getPageID());
if (!$page || $page->isError()) {
    continue; // skip broken/missing page
}

$url = $page->getCollectionLink(); // this is safe now

use ConcreteCorePagePage;

$productu = Product::getByID($product['pID']);

$page = Page::getByID($productu->getPageID());
if (!$page || $page->isError()) {
    continue;
}

$url = $page->getCollectionLink();