Mit PHP-hochladen von Bildern zu einem Ordner beim speichern Beschreibungen in eine Datenbank

1) das Hochladen von Dateien

Bei der Verwendung von array-syntax für die Datei-Eingänge, die index-Datei ist der Letzte Schlüssel. $_FILES["file"]["name"] zum Beispiel ist ein array von file-Namen. Um die Informationen für die i-te Datei, die Sie benötigen, um Zugang $_FILES["file"]["name"][$i], $_FILES["file"]["size"][$i] &c.

2) Speichern von Bildern in einem Ordner

Einige der Daten in $_FILES (wie der name) kommt vom client, und damit ist nicht zu trauen (, dass ist, überprüfen Sie zuerst). Im Fall der Dateiname, könnten Sie beginnen, indem Sie mit realpath zu überprüfen Sie die Ziel-Datei Pfadname ist sicher, oder verwenden Sie basename oder pathinfo extrahiert die Letzte Komponente die gelieferten Namen vor der Montage der Ziel-Pfadname.

3) Speichern von Bild-info der DB

Die (unvollständige) Datenbank-schema, das Sie geben, sieht aus wie Sie, geben Sie jedem Bild zwei Spalten in derselben Tabelle. Unter dem relationalen Modell, zu-viele-Beziehungen werden modelliert mit einer separaten Tabelle:

CREATE TABLE images (
    id INT UNSIGNED PRIMARY KEY AUTO_INCREMENT,
    `path` VARCHAR(256) NOT NULL,
    `description` TEXT,
    `member` INT UNSIGNED NOT NULL,
    FOREIGN KEY `member` REFERENCES members (`id`) ON DELETE CASCADE ON UPDATE CASCADE -- the image's owner
) Engine=InnoDB;

-- Note: this is a many-to-many relationship
CREATE TABLE ad_images (
    `ad` INT UNSIGNED NOT NULL,
    `image` INT UNSIGNED NOT NULL,
    FOREIGN KEY `ad` REFERENCES ads (`ad_id`) ON DELETE CASCADE ON UPDATE CASCADE,
    FOREIGN KEY `image` REFERENCES images (id) ON DELETE CASCADE ON UPDATE CASCADE,
    UNIQUE KEY (`ad`, `image`)
) Engine=InnoDB;

Sonst, du brichst die zero-one-infinity Regel und Platz verschwenden, wenn es weniger als die maximale Anzahl von Bildern.

Anderen

Beachten Sie, dass Sie die array-syntax für die Beschreibung der Datei-Felder zu machen die Handhabung einfacher. Nennen Sie Sie "filedesc[]".

Eher als eine lange Abfolge von vergleichen, verwenden Sie ein array-lookup oder ein Muster übereinstimmen.

function isImage($type) {
    static $imageTypes = array(
            'image/gif'=>1, 'image/jpeg'=>1, 'image/pjpeg'=>1, 'image/png'=>1,
        );
    return isset($imageTypes[$type]);
    /* OR */
    return preg_match('%^image/(?:p?jpeg|gif|png)%', $type);
    /* OR allow all images */
    return preg_match('%^image/%', $type);
}

if (isImage($_FILES["file"]["type"][$idx]) && ($_FILES["file"]["size"][$idx] < 1048600)) {

Den Datei-Typ ist einer von diesen client bereitgestellten Werte. Sicherer wäre die Verwendung fileinfo, um das image geben.

$finfo = finfo_open(FILEINFO_MIME_TYPE);

if (isImage(finfo_file($finfo, $path)) && ($_FILES["file"]["size"][$idx] < 1048600)) {

Selbst das kann täuschen, wenn die Datei eine gültige Bild-header aber der rest ist nicht gültig. Sie können eine Bild-Bibliothek (wie GD oder ImageMagick), die Datei zu validieren, indem Sie prüfen, ob Sie erfolgreich können öffnen Sie die Datei wie ein Bild.

P. S: ich habe das Gefühl, Sie sind ein Anfänger und ich denke, ich habe eine schöne Liste an PHP-Neulinge: Wie Sie guten code zu schreiben

2) Speichern Sie die Bilder in einen Ordner angegeben

move-uploaded-file funktionieren sollte. Was mir einfällt, ist, dass Sie nicht die richtige schreib-Berechtigungen, um Dateien zu verschieben. Welche Art von server du bist mit(Linux/Windows/MacOSX)? Was bedeutet die Funktion als boolean(Ergebnis)?

Eine andere Sache: brauche ich, um das Bild umbenannt, um eine zufällige Zeichenfolge
(um zu verhindern, dass Bilder überschrieben werden). Ich weiß, ich kann dies mit dem
rand () - Funktion, aber ich vergaß zu erwähnen, dass es in meinem ursprünglichen Beitrag.

rand() ist nicht wirklich zufällig und geben konnte doppelter Dateinamen. uniqid wird einzigartig sein

Edit: ich habe herausgefunden, das speichern der Beschreibungen in der Datenbank mit
$_SESSION['file_n_desc']. Ich muss nur herausfinden, wie hoch die
die verflixte Dinge, und speichern Sie dann die Standorte in der Datenbank.

Bei der Verwendung von session, wenn Sie noch nicht überschrieben Sitzung, die Sie nicht mit Ihrer MySQL-Datenbank, sondern das Datei-system. Sie Lesen könnte dieses tutorial für store session in einer Datenbank. Standard dieser Sitzung wird gelöscht, wenn der browser geschlossen wird(nur für diese Sitzung). Versuchen Sie einfach diesen code:

<?php

session_start();

echo "<p>";
if (isset($_SESSION['count'])) {
    echo $_SESSION['count']++;
} else {
    $_SESSION['count'] = 0;
    echo $_SESSION['count']++;
}
echo "</p>";

echo "<p>" . session_id() . "</p>";

Laden, die Seite paar mal, ohne den browser schließen. Sie erhalten etwas, das aussieht wie:

0

rlu10shi6l390il130qinlt913

1

rlu10shi6l390il130qinlt913

Aber wenn Sie den browser schließen, dass die session_id hat sich verändert und Ihr Zähler ist zurückgesetzt und Sie erhalten eine Ausgabe wie.

0

fiakdijmmk38i40f39fm8u5mi4

1

fiakdijmmk38i40f39fm8u5mi4

Werden in der Lage, um die Bilder und Beschreibungen in Ihrem klassifiziert
Auflistung in Art einer Galerie-Einstellung

Ich verwendet PDO(Gut zu Lesen) zu tun, (My)SQL. Habe ich unit-Tests(TDD) mit phpunit. Der Zugriff auf die Datenbank verwendete ich SQLite in-memory-Modus(sehr schön zu tun, den SQL-Test) => new PDO('sqlite::memory:');. Ich habe versucht zu Folgen, Uncle Bob ' s drei Regeln(Gut zu Lesen).

Normalerweise aufgeteilt in mehrere Dateien. Jede Klasse in einer separaten Datei. Jede Klasse sollte von der Klasse Isoliert getestet werden(lose Kopplung) in einer separaten Datei.

Ich verwendet foreign key zuordnen "Auflistung-Bild". Ich denke, dieses Beispiel ist ziemlich gründlich getestet, aber jetzt ist es wirklich Zeit für mich, etwas Schlaf zu bekommen, also bin ich nicht sicher ;).

<?php

function createDatabase() {
    $db = new PDO('sqlite::memory:');
    $db->setAttribute(PDO::ATTR_DEFAULT_FETCH_MODE, PDO::FETCH_ASSOC);
    $db->setAttribute(PDO::ATTR_EMULATE_PREPARES, true);
    $db->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
    return $db;
}

function createTables($db) {

//Listing table containing all listings.
    $db->exec(
<<<EOT
CREATE TABLE IF NOT EXISTS listing(
id INTEGER PRIMARY KEY, 
description TEXT NOT NULL UNIQUE)
EOT
    );

//Image table containg all images.
    $db->exec(
<<<EOT
CREATE TABLE IF NOT EXISTS image(
id INTEGER PRIMARY KEY, 
listing_id INTEGER,
URL TEXT NOT NULL UNIQUE,
description TEXT NOT NULL UNIQUE,
FOREIGN KEY (listing_id) REFERENCES listing(id))
EOT
    );
}

class Listing {
    private $db;
    private $id;
    public $description;

    /*private function __construct() {

    }*/

    private function __construct(PDO $db, $id, $description) {
        $this->db = $db;
        $this->id = $id;
        $this->description = $description;
    }

    public static function create(PDO $db, $description) {
        $stmt = $db->prepare(<<<EOT
INSERT OR IGNORE INTO listing(description)
VALUES (:description)
EOT
        );
        $stmt->execute(array(
            ":description" => $description
        ));

        if ($stmt->rowCount() !== 1) {
            return NULL;
        }

        return new Listing($db, $db->lastInsertId(), $description);
    }

    public static function get(PDO $db, $id) {
        $stmt       = $db->prepare("SELECT description FROM listing WHERE id = :id");
        $stmt->execute(array(
            ":id" => $id
        ));
        $row = $stmt->fetch();

        if ($row == null) {
            return null;
        }
        return new Listing($db, $id, $row['description']);
    }

    public function getImages() {
        return Image::getImages($this->db, $this);
    }

    public function save() {
            $stmt = $this->db->prepare(
<<<EOT
UPDATE listing SET description = :description WHERE id = :id
EOT
            );
            $stmt->execute(array(
                ":description"  => $this->description,
                ":id"           => $this->id
            ));
    }

    public function id() {
        return $this->id;
    }
}

class Image {
    private $pdo;
    public $URL;
    private $id;
    public $description;

    private function __construct(PDO $pdo, $URL, $description, Listing $listing, $id) {
        $this->pdo          = $pdo;
        $this->URL          = $URL;
        $this->description  = $description;
        $this->id           = $id;
    }

    public static function create(PDO $pdo, $URL, $description, Listing $listing) {
        $stmt = $pdo->prepare(
<<<EOT
INSERT OR IGNORE INTO image(URL, listing_id, description)
VALUES (:URL, :listing_id, :description)
EOT
        );

        $stmt->execute(array(
            ":URL"          => $URL,
            ":listing_id"   => $listing->id(),
            ":description"  => $description
        ));

        if ($stmt->rowCount() !== 1) {
            return NULL;
        }

        return new Image($pdo, $URL, $description, $listing, $pdo->lastInsertId());
    }

    public function id() {
        return $this->id;
    }

    public static function getImages(PDO $pdo, Listing $listing) {
        $result = array();

        $stmt = $pdo->prepare(
<<<EOT
SELECT * FROM image where listing_id = :listing_id
EOT
        );

        $stmt->execute(array(
            ":listing_id"   => $listing->id(),
        ));

        while($row = $stmt->fetch()) {
            //$result[] = array($row['URL'], $row['description']);
            $result[] = new Image($pdo, $row['URL'], $row['description'], $listing, $row['id']);
        }  

        return $result;
    }
}

class Test extends PHPUnit_Framework_TestCase {
    protected $db;

    protected function setUp() {
        $this->db = createDatabase();
        createTables($this->db);
    }

    public function testCreatingSingleListing() {
        $listing1 = Listing::create($this->db, "Listing 1");   
        $this->assertEquals(1, $listing1->id());
    }


    public function testCreatingMultipleListings() {
        $listing1 = Listing::create($this->db, "Listing 1");
        $listing1 = Listing::create($this->db, "Listing 2");   
        $this->assertEquals(2, $listing1->id());
    }

    public function testReturningListingReturnsNullWhenNonexistence() {
        $this->assertNull(Listing::get($this->db, 1));
    }

    public function testReturningCreatedListing() {
        $Listing1 = Listing::create($this->db, "Listing 1");   
        $this->assertEquals("Listing 1", Listing::get($this->db, 1)->description);
    }

    public function testSavingListing() {
        $listing1 = Listing::create($this->db, "Listing 1");
        $listing1->description = "new";
        $listing1->save();
        $this->assertEquals("new", Listing::get($this->db, 1)->description);
    }

    public function testListingHasNoImagesWhenJustCreated() {
        $listing1 = Listing::create($this->db, "Listing 1");
        $this->assertEquals(array(), $listing1->getImages());
    }

    public function testAddingImageToListing() {
        $listing1 = Listing::create($this->db, "Listing 1");
        $image1 = Image::create($this->db, "http://localhost:12343/dfdfx/45.png", "first image", $listing1); 
        $this->assertEquals(array($image1), $listing1->getImages());
    }

    public function testAddingImagesToListing() {
        $listing1 = Listing::create($this->db, "Listing 1");
        $image1 = Image::create($this->db, "http://localhost:12343/dfdfx/45.png", "first image", $listing1);
        $image2 = Image::create($this->db, "http://localhost:12343/df/46.png", "second image", $listing1);
        $this->assertEquals(array($image1, $image2), $listing1->getImages());
    }

}