PHP OPP Einsteiger - Method createUniqueKey

[Meister1900]

Das ist eh der komplett falsche Ansatz den du hier verfolgst, wenn es dir wirklich um die Erstellung von Joomla 4 Module oder Komponenten geht.
Um an die bestehende Datenbankverbindung zu kommen reicht einfach ein:

use Joomla\CMS\Factory;

// Get a db connection.
$db = Factory::getDbo(); 

https://docs.joomla.org/J4.x:Selecti...g_JDatabase/de

[knuffiwuffi]

Meister1900

Ja, das wäre der Ansatz für Joomla 4.

Wie bereits gesagt, möchte ich mich tiefer in PHP/PDO/OOP/MVC einarbeiten und zunächst Stand Alone Skripte schreiben (als Übung), die nur das nötigste aus Joomla verwenden.

Joomla 4 Module: leider gibt es wenige gute Tutorials bezüglich Joomla 4 Module (bis auf Hello World).

Die gute Nachricht ist, daß ich meine ersten Klassen erfolgreich erstellt, und dabei einiges gelernt habe.

[tomBuilder]

Bitte poste doch mal deine klasse. bis dato hast du lediglich eine function in eine klasse gepackt, soweit ich das verfolgt habe.
da du dich in das thema OOP einarbeiten willst, bist du auch sicher offen für weitere konstruktive kritik knuffiwuffi

[knuffiwuffi]

Gerne...bitte seid nachsichtig mit mir. Ich bin erst 2 Tage auf OOP unterwegs.

Und die Datenbankverbindung ist bewußt nicht in einem __construct(), auch wenn mir dazu geraten wurde.

database.class.php

class Database
{

    private $database_host;
    private $database_user;
    private $database_password;
    private $database_name;

    public function pdoConnect()
    {

        try
        {

            // joomla 4 database credetials
            require_once '../../configuration.php';    
            $credentials = new JConfig();

            // database connection
            $database_host = $credentials->host;
            $database_user = $credentials->user;
            $database_password = $credentials->password;
            $database_name = $credentials->db;

            $connection = new PDO("mysql:host=$database_host;dbname=$database_name;charset=utf8mb4", $database_user, $database_password);
            $connection->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);

        }
        catch(PDOException $error)
        {

            echo "ERROR" . $error->getMessage();
            die();

        }

        return $connection;        

    }

} 

toolbox.class.php

class Toolbox
{

    public function generateUniqueString($pdo, $length, $table, $column)
    {

        /**
        * creates a unique string of given length
        * which will be checked against the database
        * with given table and column
        *
        * @param integer $length number of characters for random string
        * @param string $table what table to check
        * @param string $column what column to check
        *
        * @return string unique string
        */

        $loops_limit = 10;
        $loops_cnt = 0;

        do
        {

            // generate random string
            $bytes = openssl_random_pseudo_bytes($length);
            // change binary to hexadecimal
            $hex = bin2hex($bytes);
            // string with 2 * $length
            $string = $hex;
            // shuffle string
            $string = str_shuffle($string);
            // shorten string
            $string = substr($string, 0, $length);

            /* prepared statement */
            $sql = "SELECT COUNT(id) AS rows_cnt FROM $table WHERE $column = :string";
            $stmt = $pdo->prepare($sql);
            $stmt->bindParam('string', $string, PDO::PARAM_STR);
            $stmt->execute();
            $result = $stmt->fetchAll();

            $rows_cnt = $result[0]['rows_cnt'];

            // loops                                
            $loops_cnt++;

        }
        while ($rows_cnt > 0 && $loops_cnt < $loops_limit);

        if($loops_cnt >= $loops_limit)
        {

            echo "ERROR: it was not possible to generate a unique string (tried $loops_limit times)";
            die();

        }

        return $string;

    }

} 

// database
$connection = new Database();
$pdo = $connection->pdoConnect();

// toolbox
$toolbox = new Toolbox();
$unique_string = $toolbox->generateUniqueString($pdo, 11,$table="", $column=""); // wird für die Erzeugung eines unique url alias verwendet und ggf. noch für andere unique strings.

echo "string: " . $unique_string;
echo "<br>"; 

[tomBuilder]

wie du meinst...

du baust die verbindung zur DB mit try auf, und catch mit echo/die

da eine ausnahem im normalen programmablauf nicht vorkommt (!!)
kannst du auch gleich die exception durchrutschen lassen, dann sieht man wenigstens wo was wann warum geworfen wurde (stacktrace)

um das ganze etwas modularer zu gestaleten würde ich:

// joomla 4 database credetials
require_once '../../configuration.php';
$credentials = new JConfig();

class Database{
public function pdoConnect($credentials){
machen
}
}
//
// zu
generateUniqueString($pdo, $length, $table, $columun){}
generateUniqueStringNotFoundInSpezificDbTableAndCo loum()
//da weiss ich wenigstens was das ding alles macht 

wenn du alles so fest miteinander verdrahtest, wird es immer schwerer einzelen teile zu ändern.



schon mal an sowas gedacht :

https://mysqlcode.com/mysql-uuid/

[knuffiwuffi]

tomBuilder

Danke für deinen Input.

Werde die Ratschläge natürlich überdenken und ggf. Anpassungen vornehmen.

Mein erster Versuch ist nicht in Stein gemeißelt,

Am Anfang ist es schön, wenn überhaupt etwas funktioniert.

Dennoch ist es natürlich wichtig, schon am Anfang in die richtige Richtung zu gehen.

Der PDO Tip z.B. war u.a. sehr gut und auch schnell umgesetzt.

UUID() wurde ja auch schon angesprochen und dein Link dazu sieht gut aus.

Werde ich mir anschauen.

[knuffiwuffi]

Ok. SELECT UUID(); ist natürlich um einiges einfacher, auch wenn die Länge des Strings sich nur bedingt kürzen lässt. Aber dafür Unique

Danke an die beiden Ratschlaggeber.

class Toolbox
{

    public function generateUniversalUniqueIdentifier($pdo)
    {    
        /* prepared statement */
        $sql = "SELECT UUID() AS uuid";
        $stmt = $pdo->prepare($sql);
        $stmt->execute();
        $result = $stmt->fetchAll();

        $uuid = $result[0]['uuid'];

        $uuid = str_replace('-', '', $uuid);

        return $uuid;
    }

} 

// toolbox
$toolbox = new Toolbox();
$uuid = $toolbox->generateUniversalUniqueIdentifier($pdo);

echo "universal unique identifier: " . $uuid;
echo "<br>"; 

[tomBuilder]

und dann mal das anschauen ?
https://www.php.net/manual/de/function.uniqid.php

ziel ist es jetzt, eine schnistelle zu deffinieren, welch eine eindeuting id zurück gibt, welche der drei möglichnkeiten genutzt wird, lässt sich bspw- über eine config steuern ....

[knuffiwuffi]

Und auch der letzte Link war hilfreich, woraufhin ich folgendes erstellt habe. Damit sollte ich eigentlich einen eindeutigen identifier erhalten, solange in der Datenbanktabelle die 'id' Spalte vorhanden ist.

Ich könnte natürlich anstelle SELECT COUNT(id) auch SELECT COUNT($column) schreiben, um auf Nummer sicher zu gehen.

Toolbox.class.php

class Toolbox
{

    function generateUniversalUniqueIdentifierWithLengthAndDatabaseCheck($pdo, $length, $table, $column)
    {
        $loops_limit = 10;
        $loops_cnt = 0;

        do
        {
            if (function_exists("random_bytes"))
            {
                $bytes = random_bytes(ceil($length / 2));
            }
            elseif (function_exists("openssl_random_pseudo_bytes"))
            {
                $bytes = openssl_random_pseudo_bytes(ceil($length / 2));
            }
            else
            {
                echo "ERROR: no cryptographically secure random function available.";
                die();
            }

            $identifier = substr(bin2hex($bytes), 0, $length);

            /* prepared statement */
            $sql = "SELECT COUNT(id) AS rows_cnt FROM $table WHERE $column = :identifier";
            $stmt = $pdo->prepare($sql);
            $stmt->bindParam('identifier', $identifier, PDO::PARAM_STR);
            $stmt->execute();
            $result = $stmt->fetchAll();

            $rows_cnt = $result[0]['rows_cnt'];

            // loops
            $loops_cnt++;

        }
        while ($rows_cnt > 0 && $loops_cnt < $loops_limit);

        if($loops_cnt >= $loops_limit)
        {
            echo "ERROR: it was not possible to generate a universal unique identifier of length $length.";
            die();
        }
        return $identifier;
    }

} 

test.script.php

// reporting
error_reporting(E_ALL);
ini_set('display_errors', 1);

for ($x = 0; $x <= 10; $x++) {
    // toolbox
    $toolbox = new Toolbox();
    $identifier = $toolbox->generateUniversalUniqueIdentifierWithLengthAndDatabaseCheck($pdo, 6, $table = '', $column = '');

    echo "universal unique identifier: " . $identifier;
    echo "<br>";
}