namespace Drupal\custom_entity\Entity;
 
use Drupal\Core\Entity\ContentEntityBase;
use Drupal\Core\Entity\EntityTypeInterface;
use Drupal\Core\Field\BaseFieldDefinition;
 
/**
 * Defines the custom Ticket entity.
 *
 * @ContentEntityType(
 *   id = "custom_ticket",
 *   label = @Translation("Ticket"),
 *   base_table = "custom_ticket",
 *   entity_keys = {
 *     "id" = "id",
 *     "uuid" = "uuid",
 *     "label" = "title",
 *     "langcode" = "langcode",
 *   },
 *   handlers = {
 *     "view_builder" = "Drupal\Core\Entity\EntityViewBuilder",
 *     "storage" = "Drupal\Core\Entity\Sql\SqlContentEntityStorage",
 *   }
 * )
 */
class Ticket extends ContentEntityBase {
 
  /**
   * Defines the structure of the entity properties (fields).
   */
  public static function baseFieldDefinitions(EntityTypeInterface $entity_type) {
    $fields = parent::baseFieldDefinitions($entity_type);
 
    // Add custom fields mapping directly to the DB table schema
    $fields['title'] = BaseFieldDefinition::create('string')
      ->setLabel(t('Ticket Title'))
      ->setRequired(TRUE)
      ->setSetting('max_length', 255)
      ->setDisplayOptions('view', [
        'label' => 'hidden',
        'type' => 'string',
        'weight' => -5,
      ])
      ->setDisplayOptions('form', [
        'type' => 'string_textfield',
        'weight' => -5,
      ]);
 
    $fields['status'] = BaseFieldDefinition::create('boolean')
      ->setLabel(t('Resolved Status'))
      ->setDefaultValue(FALSE);
 
    return $fields;
  }
}

// Get the entity query factory
$query = \Drupal::entityQuery('node')
  ->condition('status', 1)                          // Published nodes
  ->condition('type', 'article')                    // Mapped to article bundle
  ->condition('field_tags.entity.name', 'Security') // Related term condition
  ->sort('created', 'DESC')                         // Order by created date
  ->range(0, 10)                                    // Limit results to 10
  ->accessCheck(TRUE);                              // Apply node access checks (Required)
 
$nids = $query->execute();

use Drupal\node\Entity\Node;
 
// 1. CREATE
$node = Node::create([
  'type' => 'article',
  'title' => 'Programmatic Drupal Article',
  'body' => [
    'value' => '<p>Written programmatically via the Entity API.</p>',
    'format' => 'basic_html',
  ],
  'uid' => 1,
]);
$node->save(); // Persists to database
 
// 2. READ
$nid = $node->id();
$loaded_node = Node::load($nid);
$title = $loaded_node->label(); // "Programmatic Drupal Article"
 
// 3. UPDATE
$loaded_node->setTitle('Updated Article Title');
$loaded_node->set('field_subtitle', 'Custom subtitle value');
$loaded_node->save(); // Saves changes as new revision or updates existing row
 
// 4. DELETE
$loaded_node->delete(); // Removes all database row entries cleanly

name: 'Custom Portal Services'
type: module
description: 'Extends routing, configuration forms, blocks, and services for custom portals.'
package: Custom
core_version_requirement: ^9.5 || ^10 || ^11
dependencies:
  - drupal:node
  - drupal:datetime

# Admin Configuration Route
custom_portal.admin_settings:
  path: '/admin/config/services/portal-settings'
  defaults:
    _form: '\Drupal\custom_portal\Form\PortalSettingsForm'
    _title: 'Portal Application Settings'
  requirements:
    _permission: 'administer site configuration'
 
# Dynamic REST-style Page Route
custom_portal.user_status:
  path: '/portal/user/{uid}/status'
  defaults:
    _controller: '\Drupal\custom_portal\Controller\UserPortalController::renderStatus'
    _title: 'User Portal Dashboard'
  requirements:
    _permission: 'access content'
    uid: '\d+' # Regex to restrict parameter to integer values

services:
  custom_portal.calculator:
    class: Drupal\custom_portal\Service\PortalCalculator
    arguments: ['@database', '@current_user']

<?php
 
namespace Drupal\custom_portal\Service;
 
use Drupal\Core\Database\Connection;
use Drupal\Core\Session\AccountInterface;
 
class PortalCalculator {
  protected $database;
  protected $currentUser;
 
  public function __construct(Connection $database, AccountInterface $currentUser) {
    $this->database = $database;
    $this->currentUser = $currentUser;
  }
 
  public function getUserSubmissionsCount() {
    $query = $this->database->select('node_field_data', 'n')
      ->fields('n', ['nid'])
      ->condition('uid', $this->currentUser->id());
    return count($query->execute()->fetchAll());
  }
}

<?php
 
namespace Drupal\custom_portal\Controller;
 
use Drupal\Core\Controller\ControllerBase;
use Drupal\custom_portal\Service\PortalCalculator;
use Symfony\Component\DependencyInjection\ContainerInterface;
use Symfony\Component\HttpFoundation\JsonResponse;
 
class UserPortalController extends ControllerBase {
  protected $calculator;
 
  // 1. Inject custom services using class constructor
  public function __construct(PortalCalculator $calculator) {
    $this->calculator = $calculator;
  }
 
  // 2. Factory method to load services from the Container
  public static function create(ContainerInterface $container) {
    return new static(
      $container->get('custom_portal.calculator')
    );
  }
 
  // 3. Page render callback method
  public function renderStatus($uid) {
    $count = $this->calculator->getUserSubmissionsCount();
    return new JsonResponse([
      'user_id' => (int) $uid,
      'total_submissions' => $count,
      'message' => $this->t('User has submitted @count articles.', ['@count' => $count]),
    ]);
  }
}

<?php
 
namespace Drupal\custom_portal\Form;
 
use Drupal\Core\Form\ConfigFormBase;
use Drupal\Core\Form\FormStateInterface;
 
class PortalSettingsForm extends ConfigFormBase {
 
  protected function getEditableConfigNames() {
    return ['custom_portal.settings'];
  }
 
  public function getFormId() {
    return 'custom_portal_settings_form';
  }
 
  public function buildForm(array $form, FormStateInterface $form_state) {
    $config = $this->config('custom_portal.settings');
 
    $form['api_endpoint'] = [
      '#type' => 'url',
      '#title' => $this->t('External API Endpoint'),
      '#default_value' => $config->get('api_endpoint') ?? 'https://api.example.com',
      '#required' => TRUE,
    ];
 
    $form['max_items'] = [
      '#type' => 'number',
      '#title' => $this->t('Max Portal Items'),
      '#default_value' => $config->get('max_items') ?? 10,
      '#min' => 1,
    ];
 
    return parent::buildForm($form, $form_state);
  }
 
  public function validateForm(array &$form, FormStateInterface $form_state) {
    if ($form_state->getValue('max_items') > 100) {
      $form_state->setErrorByName('max_items', $this->t('Max portal items cannot exceed 100 due to performance bounds.'));
    }
  }
 
  public function submitForm(array &$form, FormStateInterface $form_state) {
    $this->config('custom_portal.settings')
      ->set('api_endpoint', $form_state->getValue('api_endpoint'))
      ->set('max_items', $form_state->getValue('max_items'))
      ->save();
 
    parent::submitForm($form, $form_state);
  }
}

<?php
 
namespace Drupal\custom_portal\Plugin\Block;
 
use Drupal\Core\Block\BlockBase;
use Drupal\Core\Plugin\ContainerFactoryPluginInterface;
use Symfony\Component\DependencyInjection\ContainerInterface;
use Drupal\custom_portal\Service\PortalCalculator;
 
/**
 * Provides a portal stats dashboard block.
 *
 * @Block(
 *   id = "custom_portal_stat_block",
 *   admin_label = @Translation("Portal Submission Stats Block"),
 *   category = @Translation("Custom Portal")
 * )
 */
class CustomStatBlock extends BlockBase implements ContainerFactoryPluginInterface {
  protected $calculator;
 
  public function __construct(array $configuration, $plugin_id, $plugin_definition, PortalCalculator $calculator) {
    parent::__construct($configuration, $plugin_id, $plugin_definition);
    $this->calculator = $calculator;
  }
 
  public static function create(ContainerInterface $container, array $configuration, $plugin_id, $plugin_definition) {
    return new static(
      $configuration,
      $plugin_id,
      $plugin_definition,
      $container->get('custom_portal.calculator')
    );
  }
 
  public function build() {
    $submissions = $this->calculator->getUserSubmissionsCount();
    return [
      '#type' => 'container',
      '#attributes' => ['class' => ['portal-stat-wrapper']],
      'markup' => [
        '#markup' => '<div class="stat-count">Total submissions: ' . $submissions . '</div>',
      ],
    ];
  }
 
  // Declare block caching parameters
  public function getCacheContexts() {
    // Block output varies per logged-in user session
    return ['user'];
  }
}

name: 'Developer Reference Theme'
type: theme
description: 'Custom frontend sub-theme built over core stable9 system.'
base theme: stable9
core_version_requirement: ^9.5 || ^10 || ^11
 
libraries:
  - custom_theme/global-styling
  - custom_theme/tailwind-build
 
regions:
  header: 'Site Header'
  navigation: 'Primary Navigation Menu'
  highlighted: 'Highlighted Messages'
  content: 'Main Page Content'
  sidebar_first: 'Sidebar Navigation Area'
  footer: 'Site Footer'

global-styling:
  css:
    theme:
      css/base-variables.css: {}
      css/typography.css: {}
  js:
    js/interactive-menu.js: {}
  dependencies:
    - core/drupal
    - core/jquery
 
tailwind-build:
  css:
    theme:
      dist/output.css: { minified: true }

<?php
 
/**
 * Implements hook_preprocess_page().
 */
function custom_theme_preprocess_page(&$variables) {
  // 1. Inject variables globally into page.html.twig
  $variables['current_year'] = date('Y');
  $variables['is_front_page'] = \Drupal::service('path.matcher')->isFrontPage();
 
  // 2. Load custom libraries on demand
  if ($variables['is_front_page']) {
    $variables['#attached']['library'][] = 'custom_theme/homepage-animations';
  }
}
 
/**
 * Implements hook_preprocess_node().
 */
function custom_theme_preprocess_node(&$variables) {
  $node = $variables['node'];
  // Add responsive wrapper classes to all nodes
  $variables['attributes']['class'][] = 'node-rendering-wrapper';
  
  // Inject reading time estimate
  $body = $node->get('body')->value;
  $word_count = str_word_count(strip_tags($body));
  $variables['read_time'] = ceil($word_count / 200) . ' min read';
}

{# Base article card styling wrapper #}
<article{{ attributes.addClass('article-full', 'shadow-lg', 'rounded-lg') }}>
  <header class="mb-6">
    {# Renders node title string #}
    <h1 class="text-3xl font-extrabold text-blue-900">{{ label }}</h1>
    
    <div class="meta-wrapper flex space-x-2 text-sm text-gray-500">
      <span>By: {{ author_name }}</span>
      <span>•</span>
      <span>{{ date }}</span>
      <span>•</span>
      <span class="badge">{{ read_time }}</span>
    </div>
  </header>
 
  {# Render core fields, excluding custom side bars to place manually #}
  <div class="content-body prose max-w-none mb-4">
    {{ content|without('field_sidebar_notes', 'field_related_terms') }}
  </div>
 
  {# Check field existence before rendering wrappers #}
  {% if content.field_sidebar_notes|render %}
    <aside class="sidebar-notes bg-yellow-50 border-l-4 border-yellow-500 p-4 mb-4">
      <h3 class="font-bold mb-2">Author Highlights</h3>
      {{ content.field_sidebar_notes }}
    </aside>
  {% endif %}
 
  <footer class="border-t pt-4">
    {# Renders field tags #}
    {% if content.field_related_terms|render %}
      <div class="tags-list">
        <span class="font-semibold">Tagged:</span>
        {{ content.field_related_terms }}
      </div>
    {% endif %}
  </footer>
</article>

<?php
 
namespace Drupal\custom_portal\EventSubscriber;
 
use Symfony\Component\EventDispatcher\EventSubscriberInterface;
use Symfony\Component\HttpKernel\KernelEvents;
use Symfony\Component\HttpKernel\Event\RequestEvent;
use Drupal\Core\Messenger\MessengerInterface;
 
class UserLoginSubscriber implements EventSubscriberInterface {
  protected $messenger;
 
  public function __construct(MessengerInterface $messenger) {
    $this->messenger = $messenger;
  }
 
  public static function getSubscribedEvents() {
    // Listen to Symfony HTTP Request boot event
    return [
      KernelEvents::REQUEST => ['showUserAlert', 10],
    ];
  }
 
  public function showUserAlert(RequestEvent $event) {
    $request = $event->getRequest();
    // Output a temporary notification to users
    if ($request->query->has('portal_alert')) {
      $this->messenger->addWarning('You are currently viewing a custom user portal dashboard.');
    }
  }
}

<?php
 
use Drupal\Core\Form\FormStateInterface;
use Drupal\node\NodeInterface;
 
/**
 * Implements hook_form_alter().
 * Modifies forms system-wide.
 */
function custom_portal_form_alter(&$form, FormStateInterface $form_state, $form_id) {
  if ($form_id === 'node_article_edit_form') {
    // Alter form properties
    $form['title']['widget'][0]['value']['#description'] = t('Ensure title contains keyword details.');
  }
}
 
/**
 * Implements hook_node_presave().
 * Triggers automatically before a node database entry is created or updated.
 */
function custom_portal_node_presave(NodeInterface $node) {
  if ($node->bundle() === 'article') {
    // Automatically strip script tags from node title to prevent basic injection
    $clean_title = strip_tags($node->getTitle());
    $node->setTitle($clean_title);
  }
}

<?php
 
/**
 * Implements hook_schema().
 * Defines customized database structures.
 */
function custom_portal_schema() {
  $schema['custom_portal_metrics'] = [
    'description' => 'Stores portal access log telemetry metrics.',
    'fields' => [
      'id' => [
        'type' => 'serial',
        'unsigned' => TRUE,
        'not null' => TRUE,
        'description' => 'Primary Key identifier',
      ],
      'uid' => [
        'type' => 'int',
        'unsigned' => TRUE,
        'not null' => TRUE,
        'default' => 0,
      ],
      'page_views' => [
        'type' => 'int',
        'not null' => TRUE,
        'default' => 0,
      ],
    ],
    'primary key' => ['id'],
  ];
  return $schema;
}

$database = \Drupal::database();
 
// Build: SELECT nfd.nid, nfd.title, u.mail FROM node_field_data nfd INNER JOIN users_field_data u ON nfd.uid = u.uid WHERE type = :type LIMIT 10
$query = $database->select('node_field_data', 'nfd');
$query->innerJoin('users_field_data', 'u', 'nfd.uid = u.uid');
 
$query->fields('nfd', ['nid', 'title'])
  ->fields('u', ['mail'])
  ->condition('nfd.type', 'article')
  ->condition('nfd.status', 1)
  ->range(0, 10);
 
$result = $query->execute()->fetchAll();
 
foreach ($result as $row) {
  $title = $row->title;
  $email = $row->mail;
}

$database = \Drupal::database();
 
// 1. INSERT
$database->insert('custom_portal_metrics')
  ->fields([
    'uid' => 12,
    'page_views' => 1,
  ])
  ->execute();
 
// 2. UPDATE
$database->update('custom_portal_metrics')
  ->fields([
    'page_views' => 5,
  ])
  ->condition('uid', 12)
  ->execute();
 
// 3. DELETE
$database->delete('custom_portal_metrics')
  ->condition('uid', 12)
  ->execute();

$connection = \Drupal::database();
 
// Start the transaction transaction boundary
$transaction = $connection->startTransaction();
 
try {
  $connection->insert('custom_portal_metrics')->fields(['uid' => 1, 'page_views' => 1])->execute();
  $connection->insert('another_table')->fields(['uid' => 1, 'logs' => 'Success'])->execute();
}
catch (\Exception $e) {
  // Rollback changes if query failure occurs
  $transaction->rollBack();
  \Drupal::logger('database')->error('Transaction failed: @msg', ['@msg' => $e->getMessage()]);
}

// Mapped config sync folder outside the public web root
$settings['config_sync_directory'] = '../config/sync';

custom_portal.settings:
  type: config_object
  label: 'Custom Portal Settings Settings'
  mapping:
    api_endpoint:
      type: string
      label: 'Api endpoint URL'
    max_items:
      type: integer
      label: 'Max portal limit items'

// Overriding site system details for Staging environment
$config['system.site']['name'] = 'Staging Environment Portal';
$config['custom_portal.settings']['api_endpoint'] = 'https://staging-api.example.com';

export async function getStaticProps() {
  const res = await fetch('https://drupal-backend.example.com/jsonapi/node/article?sort=-created&page[limit]=5');
  const articles = await res.json();
 
  return {
    props: {
      posts: articles.data.map(node => ({
        id: node.id,
        title: node.attributes.title,
        body: node.attributes.body.processed,
      })),
    },
    revalidate: 60, // Revalidate cache hourly
  };
}
 
export default function Home({ posts }) {
  return (
    <div className="container mx-auto p-4">
      <h1 className="text-3xl font-bold mb-4">Latest Articles</h1>
      {posts.map(post => (
        <div key={post.id} className="border-b p-4">
          <h2>{post.title}</h2>
          <div dangerouslySetInnerHTML={{ __html: post.body }} />
        </div>
      ))}
    </div>
  );
}

$build = [
  '#theme' => 'my_custom_template',
  '#content' => $data,
  '#cache' => [
    'contexts' => ['user.roles'],
    'tags' => ['node_list', 'taxonomy_term:5'],
    'max-age' => 86400, // 24 hours in seconds
  ],
];

use Drupal\Core\Cache\Cache;
 
// Clears all custom cached views and pages carrying the list tag
Cache::invalidateTags(['node:article:5', 'custom_dashboard_stats']);

if (extension_loaded('redis')) {
  $settings['redis.connection']['interface'] = 'PhpRedis';
  $settings['redis.connection']['host']      = '127.0.0.1';
  $settings['redis.connection']['port']      = 6379;
  
  // Enable Redis for cache services
  $settings['cache']['default'] = 'cache.backend.redis';
  $container_yamls[] = 'modules/contrib/redis/example.services.yml';
}

namespace Drupal\Tests\custom_portal\Unit;
 
use Drupal\Tests\UnitTestCase;
use Drupal\custom_portal\Helper\MathHelper;
 
class MathHelperTest extends UnitTestCase {
  public function testAddition() {
    $helper = new MathHelper();
    $this->assertEquals(4, $helper->add(2, 2));
  }
}

namespace Drupal\Tests\custom_portal\Kernel;
 
use Drupal\KernelTests\KernelTestBase;
use Drupal\node\Entity\Node;
 
class NodeCrudKernelTest extends KernelTestBase {
  protected static $modules = ['system', 'user', 'node', 'field'];
 
  protected function setUp(): void {
    parent::setUp();
    $this->installSchema('system', ['sequences']);
    $this->installEntitySchema('user');
    $this->installEntitySchema('node');
  }
 
  public function testNodeCreation() {
    $node = Node::create(['type' => 'article', 'title' => 'Test Article']);
    $node->save();
    $this->assertNotEmpty($node->id());
  }
}

namespace Drupal\Tests\custom_portal\Functional;
 
use Drupal\Tests\BrowserTestBase;
 
class PortalRoutingTest extends BrowserTestBase {
  protected static $modules = ['custom_portal', 'node', 'user'];
  protected $defaultTheme = 'stable9';
 
  public function testDashboardRoute() {
    $admin_user = $this->drupalCreateUser(['administer site configuration']);
    $this->drupalLogin($admin_user);
    
    $this->drupalGet('/admin/config/services/portal-settings');
    $this->assertSession()->statusCodeEquals(200);
    $this->assertSession()->pageTextContains('Portal Application Settings');
  }
}

<?php
// Maps domains to directories inside sites/
$sites['portal.example.com'] = 'portal';
$sites['admin.example.com'] = 'admin_portal';