Permit to Inject GlpiAsset

CHANGELOG.md

@@ -10,6 +10,7 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 ### Added
 
 - Add Transifex translations link to README
+- Permit to Inject GlpiAsset
 
 ## [2.16.0] - 2026-10-05
 

front/info.form.php

@@ -28,8 +28,6 @@
  * -------------------------------------------------------------------------
  */
 
-Session::checkLoginUser();
-
 /* Update mappings */
 if (isset($_POST["update"])) {
     $model = new PluginDatainjectionModel();

front/model.form.php

@@ -28,8 +28,6 @@
  * -------------------------------------------------------------------------
  */
 
-Session::checkLoginUser();
-
 $_GET["id"] ??= "";
 
 $_GET["withtemplate"] ??= "";

front/model.php

@@ -28,7 +28,6 @@
  * -------------------------------------------------------------------------
  */
 
-Session::checkLoginUser();
 
 Html::header(
     PluginDatainjectionModel::getTypeName(),

front/popup.php

@@ -28,8 +28,6 @@
  * -------------------------------------------------------------------------
  */
 
-Session::checkLoginUser();
-
 switch ($_GET["popup"]) {
     case "preview":
         $models_id = (int) ($_GET['models_id'] ?? 0);

inc/commoninjectionlib.class.php

@@ -27,11 +27,12 @@
  * @link      https://github.com/pluginsGLPI/datainjection
  * -------------------------------------------------------------------------
  */
-
+use Glpi\Asset\Asset;
 use Glpi\DBAL\QueryExpression;
 use Glpi\DBAL\QuerySubQuery;
 use Glpi\Exception\Http\HttpException;
 use Glpi\Features\AssignableItem;
+use GlpiPlugin\Datainjection\Glpi\Asset\AssetInjection;
 
 use function Safe\preg_match;
 use function Safe\preg_replace;
@@ -356,6 +357,15 @@ public static function getItemtypeByInjection($injectionClassName)
     public static function getItemtypeByInjectionClass($injectionClass)
     {
 
+        if ($injectionClass instanceof AssetInjection) {
+            // Custom assets all share the "glpi_assets_assets" table, whose canonical
+            // itemtype is the *abstract* Glpi\Asset\Asset. Resolving through the table
+            // (getItemTypeForTable) is therefore unreliable and can return that abstract
+            // class, which is not instantiable. The injection class already knows its
+            // concrete custom-asset itemtype, so use it directly.
+            return $injectionClass::getVirtualType();
+        }
+
         return Toolbox::ucfirst(getItemTypeForTable($injectionClass->getTable()));
     }
 
@@ -365,7 +375,10 @@ public static function getItemtypeByInjectionClass($injectionClass)
     *
     * @param string $itemtype  the itemtype
     *
-    * @return PluginDatainjectionInjectionInterface the injection class instance
+    * Every injection class both implements the interface and extends CommonDBTM,
+    * so the returned instance exposes the CommonDBTM API (getTable(), ...) too.
+    *
+    * @return PluginDatainjectionInjectionInterface&CommonDBTM the injection class instance
     */
     public static function getInjectionClassInstance($itemtype)
     {
@@ -377,7 +390,15 @@ public static function getInjectionClassInstance($itemtype)
             $injectionClass = ucfirst($itemtype) . 'Injection';
         }
 
-        if (!is_a($injectionClass, PluginDatainjectionInjectionInterface::class, true)) {
+        if (!class_exists($injectionClass)) {
+            plugin_datainjection_creationInjectableAssets();
+        }
+
+
+        if (
+            !is_a($injectionClass, PluginDatainjectionInjectionInterface::class, true)
+            || !is_a($injectionClass, CommonDBTM::class, true)
+        ) {
             throw new HttpException(500, 'Class ' . $injectionClass . ' is not a valid class');
         }
 
@@ -626,7 +647,8 @@ private function getFieldValue(
 
             case 'dropdown':
             case 'relation':
-                $tmptype = getItemTypeForTable($searchOption['table']);
+                // Custom dropdowns share one table: their itemtype cannot be resolved from it
+                $tmptype = $searchOption['dropdown_itemtype'] ?? getItemTypeForTable($searchOption['table']);
                 if (!is_a($tmptype, CommonDBTM::class, true)) {
                     return;
                 }
@@ -2145,6 +2167,10 @@ private function dataAlreadyInDB($injectionClass, $itemtype)
                         }
                     }
 
+                    if ($injectionClass instanceof Asset && method_exists($injectionClass, 'getAssetDefinitionID')) {
+                        $where['assets_assetdefinitions_id'] = $injectionClass->getAssetDefinitionID();
+                    }
+
                     //Add additional parameters specific to this itemtype (or function checkPresent exists)
                     if (method_exists($injectionClass, 'checkPresent')) {
                         $extra = $injectionClass->checkPresent($this->values, $options);
@@ -2447,8 +2473,13 @@ public static function addToSearchOptions(
         );
 
         $main_itemtype = self::getItemtypeByInjectionClass($injectionClass);
+        $main_table    = getTableForItemType($main_itemtype);
         foreach ($type_searchOptions as &$value) {
-            $value_itemtype = getItemTypeForTable($value['table']);
+            $value_itemtype = $value['table'] === $main_table
+                // Custom assets share a table resolved to the abstract Glpi\Asset\Asset,
+                // whose getTypeName() needs a concrete definition
+                ? $main_itemtype
+                : getItemTypeForTable($value['table']);
             $value_itemtype_name_singular = $value_itemtype::getTypeName(1);
             $value_itemtype_name_plural   = $value_itemtype::getTypeName(Session::getPluralNumber());
             if (

inc/info.class.php

@@ -359,7 +359,7 @@ public static function showAdditionalInformation(
                 }
 
                 Dropdown::show(
-                    getItemTypeForTable($option['table']),
+                    $option['dropdown_itemtype'] ?? getItemTypeForTable($option['table']),
                     ['name'  => $name,
                         'value' => $value,
                     ],

inc/injectiontype.class.php

@@ -28,6 +28,7 @@
  * -------------------------------------------------------------------------
  */
 use Glpi\Exception\Http\HttpException;
+use GlpiPlugin\Datainjection\Glpi\Asset\AssetInjection;
 
 use function Safe\json_decode;
 use function Safe\json_encode;
@@ -80,6 +81,11 @@ public static function getItemtypes($only_primary = false)
                     }
 
                     $name .= call_user_func([$type, 'getTypeName']);
+
+                    if ($instance instanceof AssetInjection) {
+                        $typename = $instance->getVirtualType();
+                    }
+
                     $values[$typename] = $name;
                 }
             }
@@ -396,7 +402,7 @@ public static function getUsedMappingsOrInfos($options = [])
                 foreach ($options as $option) {
                     if (
                         isset($option['table'])
-                        && ($option['table'] == getItemTypeForTable($data['itemtype']))
+                        && ($option['table'] == $injectionClass->getTable())
                         && ($option['linkfield'] == $data['value'])
                         && ($option['displaytype'] != 'multiline_text')
                         && ($mapping_or_info['value'] != $data['value'])

phpstan.neon

@@ -9,6 +9,7 @@ parameters:
         - ajax
         - front
         - inc
+        - src
         - hook.php
         - setup.php
     scanDirectories:

setup.php

@@ -28,8 +28,13 @@
  * -------------------------------------------------------------------------
  */
 
+use Glpi\Asset\AssetDefinition;
+use Glpi\Asset\AssetDefinitionManager;
+use GlpiPlugin\Datainjection\Glpi\Asset\Capacity\IsInjectableCapacity;
+
 use function Safe\define;
 use function Safe\mkdir;
+use function Safe\preg_match;
 
 define('PLUGIN_DATAINJECTION_VERSION', '2.16.0');
 
@@ -48,6 +53,10 @@ function plugin_init_datainjection()
     /** @var array $CFG_GLPI */
     /** @var array $INJECTABLE_TYPES */
     global $PLUGIN_HOOKS, $CFG_GLPI, $INJECTABLE_TYPES;
+    $CFG_GLPI['injectable_types'] ??= [];
+
+    $asset_definition_manager = AssetDefinitionManager::getInstance();
+    $asset_definition_manager->registerCapacity(new IsInjectableCapacity());
 
     $PLUGIN_HOOKS['csrf_compliant']['datainjection'] = true;
     $PLUGIN_HOOKS['migratetypes']['datainjection'] = 'plugin_datainjection_migratetypes_datainjection';
@@ -85,6 +94,7 @@ function plugin_init_datainjection()
         $PLUGIN_HOOKS['add_javascript']['datainjection'] = 'js/datainjection.js';
 
         $INJECTABLE_TYPES = [];
+
     }
 }
 
@@ -114,8 +124,8 @@ function plugin_version_datainjection()
 function getTypesToInject(): void
 {
     /** @var array $INJECTABLE_TYPES */
-    /** @var array $PLUGIN_HOOKS */
-    global $INJECTABLE_TYPES,$PLUGIN_HOOKS;
+    /** @var array $CFG_GLPI */
+    global $INJECTABLE_TYPES,$CFG_GLPI;
 
     if (count($INJECTABLE_TYPES)) {
         // already populated
@@ -218,6 +228,112 @@ function getTypesToInject(): void
     ];
     //Add plugins
     Plugin::doHook('plugin_datainjection_populate');
+
+    // Register injectable assets dynamically
+    plugin_datainjection_registerInjectableAssets();
+
+    plugin_datainjection_creationInjectableAssets();
+}
+
+
+/**
+ * Register injection classes for each injectable asset definition
+ */
+function plugin_datainjection_registerInjectableAssets(): void
+{
+    /** @var array $INJECTABLE_TYPES */
+    /** @var array $CFG_GLPI */
+    global $INJECTABLE_TYPES, $CFG_GLPI;
+
+    if (!isset($CFG_GLPI['injectable_types']) || empty($CFG_GLPI['injectable_types'])) {
+        return;
+    }
+
+    // For each injectable asset definition, create and register a distinct class
+    foreach ($CFG_GLPI['injectable_types'] as $definition_id => $itemtype) {
+        // Get the asset definition to extract the system name
+
+        $definition = AssetDefinition::getById($definition_id);
+        if ($definition === false || $definition === null) {
+            continue;
+        }
+
+        if ($definition->getAssetClassName() === $itemtype) {
+            // Use the system name to create a nice class name
+            $system_name = ucfirst($definition->fields['system_name']);
+            $injection_class = 'PluginDatainjection' . $system_name . 'AssetInjection';
+            // Only create if not already registered
+            $INJECTABLE_TYPES[$injection_class] ??= 'datainjection';
+        }
+    }
+}
+
+/**
+ * Register injection classes for each injectable asset definition
+ */
+function plugin_datainjection_creationInjectableAssets(): void
+{
+    /** @var array $CFG_GLPI */
+    global $CFG_GLPI;
+
+    if (!isset($CFG_GLPI['injectable_types']) || empty($CFG_GLPI['injectable_types'])) {
+        return;
+    }
+
+
+    // For each injectable asset definition, create and register a distinct class
+    foreach ($CFG_GLPI['injectable_types'] as $definition_id => $itemtype) {
+        $definition = AssetDefinition::getById($definition_id);
+        if ($definition === false) {
+            continue;
+        }
+
+        // Get the asset definition to extract the system name
+        if ($definition->getAssetClassName() === $itemtype) {
+            // Use the system name to create a nice class name
+            $system_name = ucfirst($definition->fields['system_name']);//strtolower()
+            $injection_class = 'PluginDatainjection' . $system_name . 'AssetInjection';
+
+            plugin_datainjection_createAssetInjectionClass($injection_class, $definition_id);
+        }
+    }
+}
+
+/**
+ * Dynamically create an asset injection class
+ */
+function plugin_datainjection_createAssetInjectionClass(string $class_name, int $definition_id): void
+{
+
+    // Check if class already exists
+    if (class_exists($class_name)) {
+        return;
+    }
+
+    // Create the class dynamically (not final, so it can be extended)
+    $code = <<<PHP
+
+use GlpiPlugin\\Datainjection\\Glpi\\Asset\\AssetInjection;
+
+final class $class_name extends AssetInjection implements PluginDatainjectionInjectionInterface
+{
+    // Redeclared: a static property of the parent class would be shared by every definition
+    protected static string \$definition_system_name = '';
+    protected static int \$fixed_asset_definition_id = $definition_id;
+
+    public static function getAssetDefinitionID(): int
+    {
+        return self::\$fixed_asset_definition_id;
+    }
+}
+PHP;
+
+    if (preg_match('/^[A-Za-z][A-Za-z0-9_]*$/', $class_name) === 0) {
+        return;
+    }
+
+    eval($code);
+
 }