Forum PHP.pl

Product:

[PHP] pobierz, plaintext 
<?php
 
class Product
{
 
    private string $productName;
    private string $sku;
    private float $price;
    private string $productType;
    public function __construct()
    {
        $this->productName = isset($_POST['name']) ? (string) $_POST['name'] : null;
        $this->sku = isset($_POST['sku']) ? (string) $_POST['sku'] : null;
        $this->price = isset($_POST['price']) ? (float) $_POST['price'] : null;
        $this->productType = isset($_POST['productType']) ? (string) $_POST['productType'] : null;
    }
 
    function ensureNoEmpytValues()
    {
        if (empty($this->productName) || empty($this->sku) || empty($this->price) || empty($this->productType))
            return false;
        return true;
    }
}
[PHP] pobierz, plaintext 

Oraz ProductAdd:

[PHP] pobierz, plaintext 
<?php
 
namespace nameOne;
use Product;
 
class ProductAdd extends Product
{
    private DB $db;
 
    public function __construct(DB $db){
        $this->db = $db;
        // parent::__construct();
    }
 
    public function listProperties()
    {
        $properties = $this->getDistinctProperties();
        return $properties;
    }
 
    private function getDistinctProperties()
    {
        // $db = new DB();
        $this->db->query("SELECT DISTINCT type FROM property ORDER BY type ASC");
        $results = $this->db->resultSet();
        return $results;
    }
 
    public function listFullProperties()
    {
        $properties = $this->getFullProperties();
        return $properties;
    }
    private function getFullProperties()
    {
        // $db = new DB();
        $this->db->query("SELECT * FROM property ORDER BY type ASC");
        $results = $this->db->resultSet();
        return $results;
    }
 
    public function groupFullProperties(): array
    {
        $properties = array();
        foreach ($this->getFullProperties() as $row) {
            $property = $row['property'];
 
            $newProperty = $row['type'];
            if (!isset($properties[$newProperty])) {
                $properties[$newProperty] = array();
            }
            $properties[$newProperty][] = [
                'id' => $row['id'],
                'property' => $property,
                'label' => $row['label'],
                'description' => $row['description']
 
            ];
 
        }
        return $properties;
    }
 
    public function checkExistingSKU(string $skuToCheck)
    {
        // $db = new DB();
        $this->db->query("SELECT sku FROM product WHERE sku = :sku");
        $this->db->bind(':sku', $skuToCheck);
 
        if ($this->db->single()) {
            return true;
        }
        return false;
    }
 
 
    public function insertNewProduct()
    {
 
        /* to na razie jest zakomentowane żebym w ogóle widział jakie są błędy*/
        // if ($this->ensureNoEmpytValues() === false)
        //     return false;
 
 
 
 
        $sku = $this->sku;
        $productName = $this->productName;
        $price = $this->price;
        $selectedType = $this->productType;
 
 
 
        $properties = $this->groupFullProperties();
 
 
        foreach ($properties[$selectedType] as $propertyData) {
            $postIndex = $propertyData['property'];
            if (empty($_POST[$postIndex]))
                return false;
        }
        $queryInsertProduct = "INSERT INTO `product` (`id`, `sku`, `name`, `price`, `type`) VALUES (null, :sku, :productName , :price, :selectedType)";
        $this->db->query($queryInsertProduct);
        $this->db->bind(':sku', $sku);
        $this->db->bind(':productName', $productName);
        $this->db->bind(':price', $price);
        $this->db->bind(':selectedType', $selectedType);
 
        $this->db->execute();
 
        $lastProductId = $this->db->lastInsertId();
 
        foreach ($properties[$selectedType] as $propertyData) {
 
            $propertyId = (int) $propertyData['id'];
            $productValue = $_POST[(string) $propertyData['property']];
 
            $queryInsertProductProperty = "INSERT INTO `product_property` (`id`, `product_id`, `property_id`, `value`) VALUES (null,  $lastProductId , $propertyId, :productValue )";
            $this->db->query($queryInsertProductProperty);
            $this->db->bind(':productValue', $productValue);
 
            $this->db->execute();
        }
 
 
    }
 
}
 
?>
[PHP] pobierz, plaintext 

Przyczepia się że nie wie co to jest:
$sku = $this->sku;
$productName = $this->productName;
$price = $this->price;
$selectedType = $this->productType;

Jak w product zmienię na public to za to przyczepia się że Product::$sku must not be accessed before initialization

Ten post edytował sadistic_son 12.01.2023, 15:26:52

Niestety to samo co wczesniej -Fatal error: Uncaught TypeError: Cannot assign null to property Product::$productName of type string in
Jak tylko wejdę na stronę to konstruktor ProductAdd próbuje przypisać $_POST które nie zostało wysłane

[PHP] pobierz, plaintext 
namespace nameOne;
use Product;
 
class ProductAdd extends Product
{
    private DB $db;
 
    public function __construct(DB $db){
        $this->db = $db;
        parent::__construct();
    }
 
 
//Product
class Product
{
 
    protected string $productName;
    protected string $sku;
    protected float $price;
    protected string $productType;
    public function __construct()
    {
        $this->productName = isset($_POST['name']) ? (string) $_POST['name'] : null;
        $this->sku = isset($_POST['sku']) ? (string) $_POST['sku'] : null;
        $this->price = isset($_POST['price']) ? (float) $_POST['price'] : null;
        $this->productType = isset($_POST['productType']) ? (string) $_POST['productType'] : null;
    }
[PHP] pobierz, plaintext 

No tak, przypisywałem null do stringa, to jasne że się nie da.
Uff, dobra, to chociaż jestem na etapie, że funkcjonalności działają. Dziękuję.

No to dalsze poprawianie przede mną, żeby z tego chaosu wyłoniła się jakaś struktura.

Powiedz mi prosze do czego właściwie klasa Product ma służyć? Ja mam nią tylko i wyłacznie (po zrobieniu setter/getter) pobierać i wyświetlać właściwości produktu tam gdzie jest to potrzbne?

Np na szybko (bo robię obiad jedną ręką):

[PHP] pobierz, plaintext 
class Product{
public function setName(string $name): void
{
 $this->name = $name;
}
 
public function getName(): string
{
 return $this->name;
}
}
[PHP] pobierz, plaintext 

i potem jak chcę spradzić np czy jest wysłane formularzem $_POST['name'] to:

[PHP] pobierz, plaintext 
$product = new Product();
if(isset$_POST['save']) && isset($_POST['name'])){
 $product->setName($_POST['name']);
}
[PHP] pobierz, plaintext 

no własnie i co teraz? Brakuje mi tego logicznego zastosowania dla tej klasy. Właściwie to przyznać można że cała ta moja aplikacja to nie zupełnie OOP, tylko po prostu uzycie metod klas jak w programowaniu proceduralnym, tak sądzę.

Ten post edytował sadistic_son 12.01.2023, 15:56:33

Ok, zaczynam chwytać. Nigdzie w żadnych artykułach nie natrafiłem na takie proste pokazanie jak łaczyć znane mi proceduralne programowanie z OOP.
Dobra, a czy klasa nadrzędna w moim wypadku PageDisplay może mieć switch który centralnie robi

[PHP] pobierz, plaintext 
case 'add-product': //w pasku adresu jest add-product
 $product = new Product();
if(isset$_POST['save']) && isset($_POST['name'])){
$product->setName($_POST['name']);
}
.....
.....->nsertNewProduct($product);
[PHP] pobierz, plaintext 

Czy to jest po bożemu, albo chociaż akceptowalne (skoro to przyszły junior pisze)?

ok.
To klasa Product nie ma mieć właściwie żadnych iinych metod oprócz setterów i getterów, tak? Skoro np walidacja czy dane $_POST są wypełnione ma być gdzie indziej.

Ten post edytował sadistic_son 12.01.2023, 16:13:37

Ok, to to mi sporo wyjaśnia. Tego elementu mi chyba brakowało, żeby moc w ogóle zacząć porządkowanie tego chaosu. Dziękuję.

Hej, jakiego typu będa zmienne $dbh, $smt, $param i $value?

[PHP] pobierz, plaintext 
class DB
{
    private $dbh;
    private $stmt;
    private string $host;
    private string $name;
    private string $user;
    private string $pass;    
 
    public function __construct(string $host, string $name, string $user, string $pass) 
    {
        $this->host = $host;
        $this->name = $name;
        $this->user = $user;
        $this->pass = $pass;
        $this->dbh = new \PDO("mysql:host=" . $this->host . ";dbname=" . $this->name, $this->user, $this->pass);
    }
 
    public function query(string $query)
    {
        $this->stmt = $this->dbh->prepare($query);
    }
 
    public function bind($param, $value, $type = null)
    {
        if (is_null($type)) {
            switch (true) {
                case is_int($value):
                    $type = \PDO::PARAM_INT;
                    break;
                case is_bool($value):
                    $type = \PDO::PARAM_BOOL;
                    break;
                case is_null($value):
                    $type = \PDO::PARAM_NULL;
                    break;
                default:
                    $type = \PDO::PARAM_STR;
            }
        }
        $this->stmt->bindValue($param, $value, $type);
    }
[PHP] pobierz, plaintext 

dbh to object, tak? A co z $value która raz może być int, raz string itd? Jak mam ją typować w deklaracji metody bind ? Oraz jaki typ danych zwrócą mi tutaj poszczególne metody?

Ten post edytował sadistic_son 13.01.2023, 10:00:30

Ja już nie jestem młodym 30 parolatkiem, więc mam nieco utrudniony kontakt z bazą Zwłaszcza to zauważyłem po covidzie rok temu (serio) i nie chce minąć. chyba już tak zostanie na stałe

a $type to też będzie string?
a $stmt ?


A taka funkcja jak poniżej, która nic nie zwraca, to powinna być :void ?

[PHP] pobierz, plaintext 
   public function execute()
//czy tak?   public function execute(): void
    {
        $this->stmt->execute();
    }
[PHP] pobierz, plaintext 

Albo tutaj:

[PHP] pobierz, plaintext 
    public function resultSet()
    {
        $this->execute();
        return $this->stmt->fetchAll(\PDO::FETCH_ASSOC);
    }
[PHP] pobierz, plaintext 

Co to mi zwraca? Object? Czyli jak powinna wyglądać pierwsza linijka?

[PHP] pobierz, plaintext 
//tak?
    public function resultSet(): object
[PHP] pobierz, plaintext 

Ten post edytował sadistic_son 13.01.2023, 10:16:17

Tak, wewnątrz metody przypisuję rózne wartości. Ale przecież wywołując metodę bind podaję parametry w formie $this->db->bind(':sku', $sku); więc w tym przypadku $type na wejściu będzie null. Innym razem mogę go podać i wtedy będzie stringiem, tak? Czyli powinno być public function bind(string $param, mixed $value, mixed $type = null) . Czy jednak błądzę?

Widzę w manualu że w takim przypadku $type = \PDO::PARAM_INT; to type to "PDO::PARAM_INT (int) Represents the SQL INTEGER data type.". Jednak moje pytanie dotyczyło typu wejściowego, byłem nieprecyzyjny.


No ok, ok, to będzie array.

Ten post edytował sadistic_son 13.01.2023, 10:34:57

To z sku to tylko przykład wywołania metody bind.
W definicji mam:

[PHP] pobierz, plaintext 
public function bind(string $param, mixed $value, $type = null): void
[PHP] pobierz, plaintext 

A wywołuje ją np w taki sposób (tutaj nie podając $type w parametrze):

[PHP] pobierz, plaintext 
        $queryInsertProduct = "INSERT INTO `product` (`id`, `sku`, `name`, `price`, `type`) VALUES (null, :sku, :productName , :price, :selectedType)";
        $this->db->query($queryInsertProduct);
        $this->db->bind(':sku', $sku);
        $this->db->bind(':productName', $productName);
        $this->db->bind(':price', $price);
        $this->db->bind(':selectedType', $selectedType);
[PHP] pobierz, plaintext 

Stąd moje pytanie jaki typ danych będzie mieć $type w definicji metody bind (na wejściu), skoro raz jest na wejściu null (jak powyżej), innym razem mogę mu podać PARAM_INT. Wg mnie na wejściu będzie to mixed. public function bind(string $param, mixed $value, mixed $type = null) Tak?

Ten post edytował sadistic_son 13.01.2023, 10:50:50

O, i teraz się zrozumieliśmy. Dzięki za odpowiedź

Nastepne pytanie, jeśli mogę.

Zabrałem się za naprawę klasy Product oraz usunięcie jej dziedziczenia np z ProductAdd.
W Product pozbyłem się konstruktora aby posługiwać się setterami i getterami. Wygląda ona teraz tak (kawałek):

[PHP] pobierz, plaintext 
class Product
{
 
    private string $productName;
    private string $sku;
    private float $price;
    private string $productType;
    // public function __construct()
    // {
    //     $this->productName = isset($_POST['name']) ? (string) $_POST['name'] : '';
    //     $this->sku = isset($_POST['sku']) ? (string) $_POST['sku'] : '';
    //     $this->price = isset($_POST['price']) ? (float) $_POST['price'] : 0;
    //     $this->productType = isset($_POST['productType']) ? (string) $_POST['productType'] : '';
    // }
 
    public function setProductName(string $productName): void
    {
        $this->productName = $productName;
    }
 
    public function getProductName(): string
    {
        return $this->productName;
    }
 
//itd dla pozostałych zmiennych
[PHP] pobierz, plaintext 

Teraz chcę się posłużyć tą klasą. Gdy miałem konstruktor to było jasne dla mnie:

[PHP] pobierz, plaintext 
$product = new Product();
$productObject->insertNewProduct($product);
 
 
// gdzie indziej tworzenie metody insertNewProduct($product):
    public function insertNewProduct(Product $product)
    {
        $sku = $product->sku;
        $productName = $product->productName;
        $price = $product->price;
        $selectedType = $product->productType;
[PHP] pobierz, plaintext 

To działało. Teraz natomiast pozbyłem się konstruktora i porobiłem settery i gettery i zastanawiam się jak powinno wyglądac wywołanie metody insertNewProduct przy użyciu Product.

[PHP] pobierz, plaintext 
                        $product = new Product();
                        $product->setProductName($_POST['name']);
                        $product->setSku($_POST['sku']);
                        $product->setPrice($_POST['price']);
                        $product->setProductType($_POST['productType']);
                        $productObject->insertNewProduct($product);
//czy tak?
//dobrze kombinuję?
[PHP] pobierz, plaintext 

No i deklaracja metody:

[PHP] pobierz, plaintext 
    public function insertNewProduct(Product $product)
    {
        $sku = $product->getSku();
[PHP] pobierz, plaintext 

EDIT: Tzn, że to działa to wiem. Moje pytanie to - czy robię to zgodnie ze sztuką, lub chociaż niedaleko jej.

Ten post edytował sadistic_son 13.01.2023, 11:07:11