Cześć.
Walczę z kolejnym wymogiem projektu nad którym siedzę.
"Logika MySQL powinna być obsługiwana przez obiekty z właściwościami, zamiast bezpośrednich wartości kolumn. Proszę użyć setters i getters aby to osiągnąć oraz nie zapomnieć użyć ich do zapisu i wyświetlania logiki."
Póki co to nie użyłem setter/getter. Pokażcie proszę na przykładzie mojego poniższego kodu jak to powinno być zastosowane.

Klasa Produkt

[PHP] pobierz, plaintext 
class Product
{
 
    public $productName;
    public $sku;
    public $price;
    public $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 

Kawałek klasy ProductAdd z metodą wrzucającą do bazy:

[PHP] pobierz, plaintext 
<?php
class ProductAdd extends Product
{
    public function insertNewProduct()
    {
 
        if ($this->ensureNoEmpytValues() === false)
            return false;
 
        $db = new DB();
 
        $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)";
        $db->query($queryInsertProduct);
        $db->bind(':sku', $sku);
        $db->bind(':productName', $productName);
        $db->bind(':price', $price);
        $db->bind(':selectedType', $selectedType);
 
        $db->execute();
 
        $lastProductId = $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 )";
            $db->query($queryInsertProductProperty);
            $db->bind(':productValue', $productValue);
 
            $db->execute();
        }
    }
}
[PHP] pobierz, plaintext 

Ja nie wiem na kiedy masz to zrobic, ale warto by bylo bys jednak odszedl na razie od tego projektu i poprostu przelecial glowne rzeczy z OOP, poprawcowal na przykladach tam podanych i dopiero potem majac juz jakas tam wiedze z oop bral sie za ten projekt.
Bo teraz im wiecej do niego dodajesz tym coraz bledow robisz. Z tego co ci mowimy to zapamietujesz w najlepszym wypadku moze polowe, a i to nie zawsze, wiec z kazdym koljneym tematem trzeba ci na nowo mowic to co sie juz mowilo milion razy i troche to powoduje drganie zylki na czole


Ale dobra, wypunktuje pare rzeczy, i wracam do pracy
1) klasa masie nie dobierac do zadnego POST. Klasy nie interesuje czy dane pochodza z POST czy marsa. klasa ma dostac dane jako parametr. W twoim przypadku przekaz tablice w konstruktorze Produkt i sobie ustaw co masz ustawic
Choc wg wymagan co tu napisales to w konstruktorze nic nie przekazujesz tylko uzywasz masz setter/getter
2)
public $productName;
public $sku;
public $price;
public $productType;
Naprawde nie wiesz ze productName to string a price to float i nie mozesz tego ustawic?

3)
ensureNoEmpytValues()
Nie, klasa produkt ma nie robic za walidator. Masz miec validator ktory przyjmie obiekt klasy Product i on stwierdzi czy jest wypelniony czy nie

4) juz ci mowilem, klasa nie wie o zadnych STALYCH w programie. Klasa ma dostac niezbedne dane np. w konstuktorze. Mowie tu o klasie DB ktore magicznie wie ze w programie sa stale z HOSTEM, PASSWORD itp.

5) Nie, klasa insert product pod zadnym pozorem nie dziedziczy po Produkt. Metoda tej klasy dostaje obiekt Produkt i na nim pracuje a nie dziedziczy

6) $db = new DB();
No nie. Obiekt klasy DB masz stworzyc tylko raz, gdzies np w index.php i ten obiekt masz przekazywac do klas, ktore beda go wymagaly. Poczytaj o DI (dependency injection)

7) W ostatnich tematach bylo jeszcze wiecej bledow ale juz nie pamietam


zas to o co pytasz to banalne settery, w kazdym lepszy arcie o tym masz, czyli nie

[PHP] pobierz, plaintext 
    public $productName;
    public $sku;
    public $price;
    public $productType;
[PHP] pobierz, plaintext 

a

[PHP] pobierz, plaintext 
    private string $name;
    public $sku;// co to za typ?
    private float  $price;
    private string $type;
[PHP] pobierz, plaintext 

i metody

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

a potem w kodzie

[PHP] pobierz, plaintext 
$product = new Product();
$product->setName(....);
[PHP] pobierz, plaintext 

i pobranie

[PHP] pobierz, plaintext 
echo $product->getName();
[PHP] pobierz, plaintext 

Na piątek.


Jeśli odejdę od tego projektu, to obecnej pracy nie zmienię przynajmniej do maja, a jak zostanę w niej na dłużej to... Nie chcę myśleć.
Przerobiłem książkę i wydawało mi się to wszystko jasne. Kod z niej rozumiałem, tłumaczenia też. Ogólne zasady OOP też, a przynajmniej tak mi się wydawało. Więc stwierdziłem, że najlepszym trenerem jest praktyka i zacząłem pisać projekt. No i tutaj się okazało, że jednak wydawało mi się, że coś było jasne (póki to czytałem), a w międzyczasie również, że ta książka to szajs - że jest w niej pełno literówek, różnych błędów logicznych, że uczy złych praktyk. Więc nie chcę do niej wracać. Okazało się tez po drodze, że php zmienia się z wersji na wersję bardziej niż sądziłem, a co za tym idzie ciężej zaraz ufać różnym artykułom i samouczkom znalezionym w google, bo rzadko udaje się coś z 2022 dorwać. Stąd moje ciągłe pytania tutaj - odpowiedzi są zawsze aktualne


Dzięki, opisałeś to jasno. Przynajmniej tak mi się wydaje, a głowę mam już napuchniętą o tej godzinie.
Mój projekt już funkcjonalnie działa. Teraz czas na poprawianie błędów w OOP - przebudowywanie klas wedle tego co napisałeś powyżej. Mam nadzieję, że jutro się z tym wyrobię, bo na czwartek zostawiam sobie javascript i wieczorem wysyłam.

No dobra, nie pozostalo w takim razie nic innego jak zyczyc powodzenia
No to mecz nas do tego czwartku, ale nie zapominaj polowy w miedzyczasie

Dzięki.
Uff, no to zabieram się.
JS jednak już dziś męczyłem.


Przeczytałem TO. Obawiam się, że nie zdążę tego opanować tak żeby jeszcze przerobić właściwie cały mój kod do (końca) jutra. Bez DI $db = new DB(); w index.php i po wywaleniu z reszty kodu (wszystkich metod z różnych klas) oczywiście nie działa.
nospor - czy pozostawienie tego tak jak jest, tj. tworzenie nowego obiektu DB(string $db_name_itd) w różnych metodach, gdzie tego potrzebuję to jest taki fatalny błąd i skreśla całą aplikację? Czy jednak da się na to przymknąć oko u kogoś kto na juniora aspiruje?
Czy wystarczy zrobić $db = new DB(); w index.php i potem do każdej metody wymagającej bazy tylko przekazywać $db jako parametr? Tak cię zrozumiałem powyżej.
insertNewUser($db, $userName);

Jesli na juniora to powinno ujsc. Nie mnie jednak nie moge powiedziec jak oni beda na to patrzec.

A dlaczago to jest blad? Bo ile tazy robisz
$db = new DB();
to tyle razy tworzysz nowe polaczenie do bazy danych. Raz pracowalem nad projektem gdzie ludzei tak robili 27 razy w jednym request i tworzylo sie 27 nowych polaczen do bazy danych, tylko dla jednego requst. A szefostwo ciagle narzekalo ze zasoby im zzera i aplikacja wolno dziala....

jesli nie chcesz tego robic jako DI, zrob z tego singleton. 10minut roboty

Przypomnij mi twoja klase DB

Zreszta tu masz szybkie wyjasnienie
https://designpatternsphp.readthedocs.io/pl...ton/README.html

W chwili obecnej moja klasa DB wygląda tak:

[PHP] pobierz, plaintext 
namespace nameOne;
 
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);
    }
 
    public function execute()
    {
        $this->stmt->execute();
    }
 
    public function resultSet()
    {
        $this->execute();
        return $this->stmt->fetchAll(\PDO::FETCH_ASSOC);
    }
 
    public function lastInsertId()
    {
        return $this->dbh->lastInsertId();
    }
 
    public function single()
    {
        $this->execute();
        return $this->stmt->fetch(\PDO::FETCH_ASSOC);
    }
 
    public function rowsAffected()
    {
        return $this->stmt->rowCount();
    }
}
[PHP] pobierz, plaintext 

Nowy obiekt w index.php:

[PHP] pobierz, plaintext 
$db = new DB(DB_HOST, DB_NAME, DB_USER, DB_PASS);
[PHP] pobierz, plaintext 

Generalnie to w index zaciąga config.php przez require. W config natomiast nie mam żadnej klasy, tylko mam podefiniowane stałe do DB oraz include DB.php, Product.php oraz PageDisplay.php (która to dalej zaciąga więcej klas). Teraz na początku ProductList.view.php tworze obiekt $products = new ProductList($db); i tutaj zmienna $db jest nieznana. Coś mi świta sprzed lat, że to przez to że raz używam require a raz include. Jedno z nich chyba do zaciągniętego pliku nie przekazuje zmiennych z zaciągającego pliku. dobrze kombinuję?


Może dla ciebie Dla mnie to będzie 60-90 minut czytania po 3 razy, nastepnie analiza tego kodu przez godzinę, potem wklepywanie do mnie i analizowanie przez kolejne pół dnia co zrobiłem źle, że nie działa. Potem pisanie na forum o pomoc. Łącznie - 2dni...

$products powinno byc przekazane do ProductList.view.php a nie tworzone w ProductList.view.php

A jak tworzysz/owierasz ProductList.view.php ?


Czemu w config tworzysz/zaciagasz DB i Product i PageDisplay?

No i skoro PageDisplay zarzadza caloscia, to $db masz przekazac do PageDisplay, to wtedy rzeczy w PageDisplay beda widziec $db. No to sa podstawy z Zasiegu Zmiennych
https://www.php.net/manual/en/language.variables.scope.php

Tak mi się wydawało rozsądnie na bazie tego co przerobiłem ze wspomnianej nie raz książki, której przerobienia teraz żałuję. A gdzie mam wtedy zaciągać DB i PageDisplay (Product na razie powstało ale nic jeszcze nie robi )? W index.php ?

Zasięg zmiennych to jeszcze ogarniam. Chyba... :| Ale zaraz to się wyjaśnie jak opiszę moją strukturę.

Tak więc w index.php mam niewiele:

[PHP] pobierz, plaintext 
use nameOne\PageDisplay;
use nameOne\DB;
 
session_start();
 
require('pagefiles/config.php');
$displayPage = new PageDisplay($_SERVER['HTTP_HOST'] . $_SERVER['REQUEST_URI'], $db);
$displayPage->decideOnContent();
[PHP] pobierz, plaintext 

w configu definuję stałe do DB (to dobre miejsce na to , tak?) oraz zaciągam DB.php oraz PageDisplay.php.


Teraz PageDisplay wg mojego założenia miała sprawdzać którą z dwóch podstron wybrano (liste produktów lub dodawanie produktu). W index.php ją wywołuję i przekazuję w parametrach $request oraz $db. Jeszcze nie zabrałem się za jej porządkowanie, więc wiem że idzie zwymiotować jak się na nią patrzy. Tak - zaciąga stałe a nie powinna, ma w sobie $_POST a powinna go dostać w parametrze. Wiem to wszystko już, i zamierzam ją oczyścić. A zacząłem od $db.
Wygląda ona tak:

[PHP] pobierz, plaintext 
namespace nameOne;
 
class PageDisplay
{
    private $request;
    private array $recordsIds;
    private $db;
 
    public function __construct($request, $db)
    {
        $this->db = $db;
        $requestString = explode("?", $request);
        $this->request = $requestString[0];
    }
    public function decideOnContent()
    {
 
        if (!$this->request) {
            return;
        }
 
        switch ($this->request) {
            case PRODUCT_LIST_LANDING . '/':
                $title = 'Product List';
                $pageContent = "ProductList";
                include("ProductList.php");
                if (isset($_POST['mass_delete']) && isset($_POST['product_check'])) {
                    $this->massDelete($_POST['product_check']);
                }
                break;
            case PRODUCT_ADD_LANDING:
                $title = 'Product Add';
                $pageContent = "ProductAdd";
                include("ProductAdd.php");
                if (isset($_POST['save']) && isset($_POST['sku'])) {
                    $productObject = new ProductAdd($db);
                    if (!$productObject->checkExistingSKU($_POST['sku'])) {
                        $productObject->insertNewProduct();
                    }
                    header("Location:http://" . PRODUCT_LIST_LANDING);
                }
                break;
            default:
                $title = 'Product List';
                $pageContent = "ProductList";
                include("ProductList.php");
                break;
 
        }
        $this->displayHeader($title);
        require('views/' . $pageContent . '.view.php');
        $this->displayFooter();
    }
 
    public static function displayHeader($title)
    {
        require_once("views/html/header.html");
    }
 
    public static function displayFooter()
    {
        require_once("views/html/footer.html");
 
    }
 
//nie miałem pomysłu gdzie ta metoda ma być, czy jako oddzielna klasa, czy jak...
    private function massDelete(array $recordsIds)
    {
        $idsToDel = implode(", ", array_map('intval', $recordsIds));
 
        $this->db->query("DELETE FROM `product_property` WHERE `product_property`.`product_id` IN ($idsToDel)");
        $this->db->execute();
 
        $this->db->query("DELETE FROM `product` WHERE `product`.`id` IN ($idsToDel)");
        $this->db->execute();
 
    }
 
}
[PHP] pobierz, plaintext 

Teraz jak widać switch decyduje o tym (poprzez include) która strona ma się wyświetlić. Nie wiem czy chcę się tutaj dzielić ProductAdd.php i ProductList.php bo tam to już jest kompletny p1erdolnik i mi wstyd :|


EDIT:
to moje ProductList.php
Chyba nie wygląda jeszcze, aż tak źle, żeby mnie postawić przed ścianą egzekucyjną.

[PHP] pobierz, plaintext 
namespace nameOne;
 
class ProductList
{
    private $db;
 
    public function __construct($db){
        $this->db = $db;
    }
    public function listProducts()
    {
        $products = $this->getProducts();
 
        return $products;
    }
 
    private function getProducts(): array
    {
        // $db = new DB();
        $this->db->query("SELECT product.id prodId, product.sku, product.name, product.price, property.id, property.type, property.property, property.label, product_property.id, product_property.value FROM product_property INNER JOIN property ON product_property.property_id = property.id INNER JOIN product ON product_property.product_id = product.id ORDER BY product.id DESC
        ");
        $results = $this->db->resultSet();
        return $results;
    }
 
    public function listGroupedProducts(): array
    {
        $products = array();
        foreach ($this->listProducts() as $row) {
 
            $pid = $row['sku'];
            if (!isset($products[$pid])) {
                $products[$pid] = array('name' => $row['name'], 'price' => $row['price'], 'id' => $row['prodId'], 'properties' => array());
            }
            if (!empty($row['value'])) {
                $products[$pid]['properties'][] = array('value' => $row['value'], 'label' => $row['label']);
            }
        }
        return $products;
    }
[PHP] pobierz, plaintext 

Gorzej juz nie bedzie pokazuj, a potrzebuje tego by widziec co z tym $db dalej robic

No dobra, tu masz blad
$productObject = new ProductAdd($db);

przeciez nie $db a $this->db

$productObject = new ProductAdd($this->db);

zakladam ze z produktList jest podobnie

Ok, to ProductList wkleiłem wyżej a tutaj największy burdel - ProductAdd. Zaznaczam, że jeszcze tutaj jest zupełnie przed czyszczeniem tych klas - używają $_POST wewnątrz, nie ma konstruktorów, setter/getter itd. Nie ma wszędzie typowania zmiennych czy tego co ma zwracać metoda. To wszystko do poprawienia jeszcze.

[PHP] pobierz, plaintext 
namespace nameOne;
use Product;
 
class ProductAdd extends Product
{
    private $db;
 
    public function __construct($db){
        $this->$db = $db;
    }
 
    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()
    {
 
        if ($this->ensureNoEmpytValues() === false)
            return false;
 
        // $db = new DB();
 
        $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 

No i Product.php. Jednak coś tam robi. Nawet zapomniałem, że to napisałem.

[PHP] pobierz, plaintext 
class Product
{
 
    public $productName;
    public $sku;
    public $price;
    public $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 

EDIT:


A no tak, przecież $db to ona jest w index, a wewnątrz klasy to już jest $this->db
Lecę na zakupy na obiad i za 45 minut zabieram się za porządkowanie tego bałaganu. Czy w międzyczasie byłbyś uprzejmy mi z grubsza opisać jak naprawić konstrukcję tej strony, żeby choć przypominała jakiś wzorzec projektowy? W którym miejscu najlepiej porobić setter/getter żeby wykazać że wiem o co w nich chodzi (wymóg projektu)? Jest tu jakaś klasa z której można zrobić abstrakcyjną i byloby to uzasadnione?

Jak pisalem wczesniej:
nie
$productObject = new ProductAdd($db);

a
$productObject = new ProductAdd($this->db);


No i skoro $db to obiekt klasy DB
to nie

private $db;
 
public function __construct($db){
$this->$db = $db;
}

a
private DB $db;
 
public function __construct(DB $db){
$this->$db = $db;
}


No jak zrobic setter/getter przeciez ci podalem w pierwszym poscie tego wlasnie tematu.


Tan caly balagan to jedna wielka abstrakcja wiec juz masz
A na powaznie, nachwile obecna nie widze gdzie to by mozna bylo dac, za duzy balagan i za malo czasu by poprawiac

class ProductAdd extends Product

Pisalem, ze ProductAdd nie moze dziedziczyc po Produkt, tylko ma dostac Produkt gdzie trzeba.

public function insertNewProduct(Product $product)

Tak tak, jak zrobić i w którym miejscu danej klasy to rozumiem - pisałeś. Ale moje pytanie było bardziej typu - czy dla każdej klasy to robić? Czy są jakieś uzasadnienia kiedy getter/setter nie robić? Czy w moim powyższym kodzie jest jakaś klasa w której szczególnie aż rzuca się w oczy że powinny byś gettery i settery?


Serio jest aż tak źle, że nawet kandydat na juniora powinien się wstydzić?



Ok, clear. Nie zdążyłem tego jeszcze poprawić. I tak dziś to wygląda to wszystko już dużo lepiej niż jeszcze choćby 24h temu.


A czy sama klasa Product jest zrobiona należycie?

napisz te setter dla Product tylko.


Ja tylko mowie ze jest balagan a nie ze maszs sie wstydzic. Wybacz, nie jestem za dobry w social talks


NO teraz nie. NIe masz setterow/getterow tylko w construktorze pobierasz z POST
Dodatkowo masz tam validacje napisana a mowilem ci tez juzze walidacja ma byc gdzie indziej.
Klasa Product wg rozumienia DTO, a w tym kontekscie to bylo pisane, ma miec tyko pola, ktore chcesz wypelnic no i te settery/gettery i to wszystko

Ok, rozumiem. Zabrałem się za to, ale najpierw zrobiłem sobie backup plików. A następnie sprawdziłem czy wszystkie funkcjonalności działają. I kurde nie dodaje mi nowego produktu okazało się. Doszedłem do tego że właśnie ta metoda ensureNoEmpytValues z Product zwraca false. Natomiast var dump z POST wygląda ok:Coś gdzieś po drodze spieprzyłem i nie potrafię znaleźć co. Wygląda na to, że metoda z klasy ProductAdd, która w chwili obecnej nadal dziedziczy po Product, nie widzi tych miennych:
$sku = $this->sku;
$productName = $this->productName;
$price = $this->price;
$selectedType = $this->productType;
Dlaczego?

W Product jest konstruktor do sku, price itd. Następnie dziedzicząca klasa nie wie co to jest $this->sku ...

No logicznie przeciez.

Jesli zrobiles jak mowilem czyli
public function insertNewProduct(Product $product)

to te zmienne masz w $product->productName itd itd. No chyba ze juz gettery masz to wtedy uzyj getterow

Nic jeszcze nie zrobiłem, bo od godziny (odkąd poprawiłem wszędzie wszystko odnosnie $db) to się głowię czemu nie dodaje nowego produktu.
Tak więc w chwili obecnej mam tak:

[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;
    }
}
 
 
/*
inny plik
*/
 
 
class ProductAdd extends Product
{
    public function insertNewProduct()
    {
 
        if ($this->ensureNoEmpytValues() === false)
            return false;
 
        // $db = new DB();
 
        $sku = $this->sku;
        $productName = $this->productName;
        $price = $this->price;
        $selectedType = $this->productType;
 
[PHP] pobierz, plaintext 

Tak więc na razie metoda klasy ProductAdd dziedziczącej po Product powinna znać $this->productName prawda? A generalnie wynika z tego że ensureNoEmpytValues zwraca false, czyli nawet sama klasa Product nie wie co to za zmienne. A POST przechodzi.

Natomiast kiedy zrobię tak public function insertNewProduct(Product $product) to mam za mało argumentów.

Kurcze, ale ty nadal dziedziczysz po Produkt.

A pewnie masz jeszcze konstruktor w ProductAdd ktory nadpisuje ci konstruktor z Produkt, temu twoje rzeczy nie sa ustawione bo konstruktor z Product sie nie odpala...
Jesli nadal chcesz miec to swoje bezsensoswne dziedziecznie to w konstuktorze ProductAdd masz wywolac konstuktor z Product


class ProductAdd extends Product
{
private $db;
public function __construct($db){
$this->$db = $db;

parent::__construct();
}

Zamierzam się go pozbyć, ale na razie chcę mieć działającą stronę (mimo chaosu w kodzie), a po uprzednich poprawkach z dziś już ona nie działa

Dodałem konstruktor rodzica, to mnie uderzyło tym...Kurde, opadam z sił. Jest uczucie rezygnacji Sprzątanie takiego bałaganu to dramat

EDIT:
Tak, bo teraz jak tylko wejdę na stronę to konstruktor działa i sprawdza czy $_POST są podane. A że nie ma to próbuje dac im null. Ale czemu nie może przypisać?

Pokaz jak wyglada teraz ProductAdd i Product

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

zmien
private string $productName;

na
protected string $productName;
poniewaz dziedziczysz

analogicnzie reszta pol



No i odkomentuj ten parent::
public function __construct(DB $db){
$this->db = $db;
parent::__construct();
}

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 

Cannot assign null to property Product::$productName of type string in

No bo pola sa ustawione jako teksty czy liczby a ty przypisujesz null. No komunikat mowi to wyraznie.
Nie bardzo ogarniam czemu tworzysz produkt jesli POST nie byl wyslany.Znaczy wiem czemu, wszystko przez ten balagan. No ale dobra, nie ustawiaj nullow tylko to co ma byc

czyli

$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'] : '';

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ę.

Klase Produkt zostala ci zaproponowana wczesniej jako DTO.

Wiec klasa Produkt jest po to, bys mial ladno klase do przechowywania nazwy produkt, ceny itp.

Juz ci pisalem wczesniej wiele razy. ProduktAdd nie moze dziedziczyc po Produkt, tylko ma otrzymac produkt tam gdzie trzeba czyli np


public function insertNewProduct(Product $product)

A gdzie tam w odmentach swojego kodu, gdize wywolujesz insertNewProduct, masz ten product stworzyc czyli




$product = new Product();
if(isset$_POST['save']) && isset($_POST['name'])){
$product->setName($_POST['name']);
}
.....
.....->nsertNewProduct($product);

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)?

Na te chwile moze.

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.

tak

I jesli to juz bedzie oddzielna klasa i ProductAdd po nei nie bedzie dziedziczyl, to zamien spowrotem protected na private

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?

No obiekt, ale konkretnie obiekt PDO wiec

private \PDO $dbh;

Na takiej samej zasadzie jak ci typowalem wczoraj DB ale znowy nie laczysz kropek

Co do value to albo mixed albo union
https://www.php.net/manual/en/language.types.mixed.php

No a $param to przeciez string

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 

Starasz sie o te nowa robote, ona wymaga samodzielnosci. Ok, na poczatku mozna o cos pytac, ale latanie z pierdulami to naprawde za dlugo miejsca tam nie zagrzejesz nawet jako junior

Jkaim cudem $type to jest string?
przeciez do $type przypisujesz
$type = \PDO::PARAM_INT;

Wiec idziesz do manuala PHP i patrzysz czym jest \PDO::PARAM_INT i juz wiesz jakiego typu bedzie $type


Tak, jak funkcja nic nie zwraca to void


return $this->stmt->fetchAll(\PDO::FETCH_ASSOC);
No to samo tutaj. Co ci zwraca fetchAll() ? Obiekt? Naprawde? Bo ja wchodze do manuala i widze ze wraca jednak co innego

Poczytaj sobie https://prophp.pl/advice/show/14/jak_czytac...mentacje_php%3F
Masz np https://www.php.net/manual/en/pdostatement.fetchall.php
Więc co zwraca public PDOStatement::fetchAll(int $mode = PDO::FETCH_DEFAULT): array ?

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.

$this->db->bind(':sku', $sku);
Troche sie zgubilem. Co ma sku do $type danych ktore bindujesz?

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?

W przykladach tutaj co podales zawsze jest NULL. Ale type to type od PDO a ten zawsze jest INT. Wiec twoj $type moze byc nullem albo INTem wiec


public function bind(string $param, mixed $value, ?int $type = null)

znak zapytania mowi, ze cos moze byc NULL

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.

Generalnie dobrze, ale nie tu

$sku = $product->sku;
$sku i inne jest juz prywane wiec masz uzyc getter

$sku = $product->getSku();

Tak tak, to dopisałem w poprzednim poście już jako edit, bo wkleiłem wcześniejszą wersję kodu wcześniej. No ok, to działam żeby teraz przerobić całość, a jest tego od groma.
Dzięki!

a czy w konstruktorze trzeba pisać : void skoro nic nie zwraca?

Nie, konstruktor to przypadek szczegolny

A co ma wskazywać typ zwracanych danych w przypadku funkcji która w zależności od warunku zwraca albo false albo np tabliczę czy string?

[PHP] pobierz, plaintext 
public function test(int $myInt, string $myString)
{
if($this->myInt == 50){
 return false;
}else{
 return $this->$myString.'siema';
}
[PHP] pobierz, plaintext 

Jeszcze to sobie poczytaj: https://designpatternsphp.readthedocs.io/en...ace/README.html (dla setterów)

Jesli tak jest znaczy, ze logika funkcja jest napisana do 4 liter

Zwracane moze byc albo DANY TYP albo NULL.
Funkcja nie powinna zwracac mieszanych typow bo to znaczy ze cos z nia jest nie tak.
Jesli zas chcesz sygnalizowac blad, to nie zwracasz false tylko rzucasz wyjatek

Jestem tego samego zdania, ale przetłumacz to tym co głosowali za wprowadzeniem Union Types xD

Jeszcze ani razu nie uzylem UNION w moich projektach wiec da sie

Ale sa przypadki gddzie trzeba uzyc, jak np. tu w tej metodzie bind dla $value ktore moze byc roznego typy. Ale to tylko powinny byc bardzo nieliczne wyjatki a juz w ogole nie wyobrazam sobie funkcji, ktora zwraca UNION/mixed... grrrrrrr

Zapewne w piekle jest oddzielny kociol tylko dla ludzi uzywajacych za czesto UNION/mixed

Dobra, rozumiem.

ale w takim razie czemu np TUTAJ jest public PDO::lastInsertId(?string $name = null): string|false ?
Jak rozumiem ma tutaj zastosowanie powiedzenie "co wolno wojewodzie to nie tobie smrodzie"

I jak wtedy będzie wyglądać deklaracja tej metody?

[PHP] pobierz, plaintext 
    public function lastInsertId()
    {
        return $this->dbh->lastInsertId();
    }
[PHP] pobierz, plaintext 

Metody PHP istnieja od wiekow, kiedy byla jeszcze ciemnosc i zwracali co zwracali. Teraz by zachowac kompatybulnosc wsteczna nie moga ot tak sobie wszystko pozmieniac bo miliony stron przestanie dzialac. Temu w starych metodach php masz jeszcze smietnik i sie tym nie kieruj

Zas u ciebie to albo tak:

public function lastInsertId(): int
{
return (int) $this->dbh->lastInsertId();
}


Albo tak

public function lastInsertId() ?int
{
$id = $this->dbh->lastInsertId();
return $id ? $id : null;
}

Ja zawsze osobiscie stosuje te pierwsza metode.