Configuración de un Blog con PHP: Clases de Usuario, Autor, Post y Categoría

Clase 18 de 19 • Curso de Programación Orientada a Objetos en PHP

Practicar es muy importante, ya que te permitirá pulir tus habilidades de desarrollo y te animo a que realices el siguiente reto con todo lo que has aprendido.

Crea un ejemplo que ilustre la configuración de un post o artículo de un blog. Entendemos que este tipo de soluciones requieren un autor (quien crea el post) y el post (pieza de contenido creada por un autor). Este post tendrá categorías para segmentarlos y hacer un fácil filtrado.

¿Qué necesitas?

User: clase base para los autores.
Author: hereda de User y es quien creará a los post o artículos.
Post: clase protagonista, es quien servirá para dar vida al objetivo principal de un blog.
Category: clase que servirá para segmentar a nuestros artículos. Es un campo más de los artículos y permitirá por ejemplo que un artículo sea de PHP, Vue.js, JavaScript, etc.

No hay una única solución ni una solución correcta, el objetivo es pensar, practicar y entender poco a poco cómo funciona esta nueva forma de construir proyectos.

User.php

<?php
  
class User 
{
    # Code ...
}

Author.php

<?php
  
class Author extends User 
{
    # Code ...
}

Post.php

<?php
  
class Post 
{
    # Code ...
}

Category.php

<?php
  
class Category
{
    # Code ...
}

Finalmente index.php.

Desarrolla todos estos archivos, pon en práctica lo aprendido. Compárteme tus resultados en los comentarios y que más añadirías.

Carlos Eduardo Gomez García

teacher•

Listo!

Mi estructura de archivos es:

+ Blog: {

    +src: {
        -Author.php
        -Category.php
        -Post.php
        -User.php
    }

    +vendor: { ... }

    -composer.json
    -composer.lock
    -index.php

}

composer.json:

{
    "name": "retaxmaster/post",
    "description": "Proyeto de OOP",
    "autoload": {
        "psr-4": {
            "Blog\\": "src/"
        }
    }
}

Author.php:

<?php

namespace Blog;

class Author extends User {

    protected $created_posts;
    protected $posts = [];

    public function create_post(Post $post) {
        $this->posts[] = $post;
    }

    public function get_postst() : array {
        return $this->posts;
    }

}

?>

Category.php:

<?php

namespace Blog;

class Category {

    protected $name;

    public function set_name(string $name) {
        $this->name = $name;
    }

    public function get_name() : string {
        return $this->name;
    }

}

?>

Post.php:

<?php

namespace Blog;

class Post {

    protected $title;
    protected $content;
    protected $category;

    public function add_category(Category $category) {
        $this->category = $category;
    }

    public function add_title(string $title) {
        $this->title = $title;
    }

    public function add_content(string $content) {
        $this->content = $content;
    }

    public function get_post() : string {
        return "<strong>Título:</strong> $this->title <br> <strong>Contenido:</strong> $this->content <br> <strong>Categoría:</strong> {$this->category->get_name()}";
    }

}

?>

User.php:

<?php

namespace Blog;

class User {

    protected $name;
    protected $last_name;

    public function set_name(string $name, string $last_name) {
        $this->name = $name;
        $this->last_name = $last_name;
    }

    public function get_full_name() : string {
        return $this->name . " " . $this->last_name;
    }

}

?>

index.php:

<?php

include __DIR__ . "/vendor/autoload.php";

use Blog\Author;
use Blog\Category;
use Blog\Post;

// Primero creo las categorías

// Categoría PHP
$php_category = new Category();
$php_category->set_name("PHP");

// Categoría VueJS
$vue_category = new Category();
$vue_category->set_name("VueJS");

// Ahora creo al autor
$retaxmaster = new Author();
$retaxmaster->set_name("Carlos", "Gómez");

// Ahora creo un post sobre PHP
$php_functions_post = new Post();
$php_functions_post->add_title("Post para hablar acerca de funciones en PHP");
$php_functions_post->add_content("En este post hablaremos sobre cómo funcionan las funciones en PHP");
$php_functions_post->add_category($php_category);

// Ahora creo un post sobre VueJS
$vue_app_post = new Post();
$vue_app_post->add_title("Post sobre cómo crear una app con VueJS");
$vue_app_post->add_content("En este post hablaremos sobre qué necesitamos para crear una app con VueJS");
$vue_app_post->add_category($vue_category);

// Ahora le asigno los posts al autor
$retaxmaster->create_post($php_functions_post);
$retaxmaster->create_post($vue_app_post);

// Y por último listamos los posts
$author_post = $retaxmaster->get_postst();

foreach ($author_post as $post) {
    
    echo "El usuario {$retaxmaster->get_full_name()} tiene el siguiente post: <br><br>";
    echo $post->get_post();
    echo "<br><br><br>";

}

?>

It works :D!

Excelente curso <3

Angel Fernando Quiroz Campos

student•

Bien!

La clase Category podría tener también un método getPosts para así filtrar (obtener) los posts que pertenecen a esa categoría.

Si, de hecho este código tiene muuuuchas cosas que se pueden mejorar, como pasar los parámetros por el contructor, agregar cositas más chulas pero como práctica creo que está bien jaja

Daniel Martín

Esta es mi solución al reto, agradecería cualquier feedback que me puedan dar:

Aquí está el código:

Jhon Fabio Cardona Martinez

Excelente diagrama.

Juan Sebastian Calderon

Muchas gracias por el aporte, me ayudo mucho

Carlos Francisco Betancourt Requena

Clase User:

<?php

namespace App;

class User
{
    private $name;
    private $email;
    private $password;

    public function setName($name)
    {
        $this->name = $name;
    }

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

    public function setEmail($email)
    {
        $this->email = $email;
    }

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

    public function setPassword($password)
    {
        $this->password = $password;
    }
}

Clase Author:

<?php

namespace App;
use App\Post;
use App\Category;

class Author extends User
{
    private $posts = [];

    public function setPost(Post $post)
    {
        $this->posts[] = $post;
    }

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

    public function addPost($post)
    {
        array_push($this->posts, $post);
    }

    public function countPosts()
    {
        return count($this->posts);
    }
}

Clase Post:

<?php

namespace App;

class Post
{
    private $title;
    private $content;
    private $category = [];

    public function __construct ($title, $content, Category $category)
    {
        $this->title        = $title;
        $this->content      = $content;
        $this->setCategory($category);
    }

    public function setTitle($title)
    {
        $this->title = $title;
    }

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

    public function setContent($content)
    {
        $this->content = $content;
    }

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

    public function setCategory(Category $category)
    {
        array_push($this->category, $category);
    }

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

Clase Category:

<?php

namespace App;

class Category
{
    private $name;

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

Clase PostTest:

<?php

use PHPUnit\Framework\TestCase;
use App\Author;
use App\Category;
use App\Post;

class PostTest extends TestCase
{
    public function test_post()
    {
        // Creamos un usuario
        $author = new Author();
        // Crear categoría
        $category = new Category("PHP");
        // Crear post
        $post = new Post("Título", "Contenido", $category);
        // Agregar post al autor
        $author->addPost($post);

        // Aserción o afirmación para comprobar que tenemos 1 post agregado
        $this->assertEquals(1, $author->countPosts());
        // Aserción o afirmación para comprobar que la categoría es una instancia de la clase Category
        $this->assertInstanceOf(Category::class, $post->getCategory()[0]);
    }
}

index.php

<?php

require_once "vendor/autoload.php";
use App\Author;
use App\Post;
use App\Category;

// Crear un autor:
$author = new Author();
$author->setName("Carlos Betancourt");
$author->setEmail("carlos@betancourt.com");
$author->setPassword("mypassword");

// Crear categorías:
$categoryPHP    = new Category("PHP");
$categoryJava   = new Category("Java");
$categoryHTML   = new Category("HTML");

// Crear tres post
$postOne    = new Post("Primer Post","Contenido del primer post.", $categoryPHP, $author);
$postTwo    = new Post("Segundo Post","Contenido del segundo post.", $categoryJava, $author);
$postThree  = new Post("Tercer Post","Contenido del tercer post.", $categoryHTML, $author);

// Agregar otras categorías a cada post
$postOne->setCategory($categoryJava);
$postThree->setCategory($categoryJava);

// Agregar posts al author
$author->addPost($postOne);
$author->addPost($postTwo);

echo "<pre>";
var_dump($author);

Es bienvenido el feedback, saludos!!!!

Tony Manuel Ojeda Vela

Estructure

Author

Category

Post

User

Test

Aka SinssChoss

Reto POO con PHP ✅

user.php

<?php
    
    class User{
        // Nombre completo del usuario
        protected $full_name;

        // Almacena todos los post creados
        protected static $post_created = [];
        public static $random = [];

        // Agrega el objeto post al array post_created
        public function agregarPost(Post $post){
            array_push(User::$post_created, $post);
        }

        // Muestra todos los array creados
        public static function mostrarTodo(){
            echo "<pre>";
                print_r(User::$post_created);
            echo "</pre>";
        }
        

    }

?>

<?php

    class Author extends User{
        // Lo usamos como objeto para crear un post
        public $post;        

        // Constructor que crea al User
        public function __construct($full_name){
            $this->full_name = $full_name;
        }

        public function getFullName(){
            return $this->full_name;   
        }
    }
?>

<?php

    class Category {

        // Será el arreglo que va a contener todas las categorías
        public static $categorys = [];

        // Muestra todas las categorías creadas
        public static function mostrar(){
            echo "<pre>";
                print_r(Category::$categorys);
            echo "</pre>";
        }
    }

?>

<?php

    include("Category.php");

    class Post{

        protected $date_create; // Fecha creada

        public function __construct(private string $full_name, protected $title, protected $comment, private string $category){

            // Establezco la fecha
            $this->date_create = date("d-n-Y");

            // paso a minuscula la categoría
            $category = strtolower($category);

            // Agrego la categoría al array categorys
            if( in_array($category, Category::$categorys) == false){
                array_push(Category::$categorys, $this->category);
            }

            // Se puede añadir desde aquí el post al arreglo de post_created, pero me dio flojera
        }

        public function showPost(){ 
?>
            <!DOCTYPE html>
            <html lang="es">
            <head>
                <meta charset="UTF-8">
                <meta http-equiv="X-UA-Compatible" content="IE=edge">
                <meta name="viewport" content="width=device-width, initial-scale=1.0">
                <title>Mi Post</title>
                <link rel="stylesheet" href="random.css">
            </head>
            <body>

                <section class="main-container">
                    <div class="container">
                        <div class="container-author">
                            <p><?=$this->full_name?></p>
                        </div>
                        <div class="container-date">
                            <!-- <p>05-10-2022</p>  -->
                            <p><?=$this->date_create?></p>
                        </div>
                    </div>

                    <div class="container">
                        <div class="container-title">
                            <p><?=$this->title?></p>
                        </div>
                        <div class="container-category">
                            <p><?=$this->category?></p>
                        </div>
                    </div>
                    

                    <div class="container container-content">
                        <p><?=$this->comment?></p>    
                    </div>
                </section>
                
            </body>
            </html>
<?php  
        }
    }

?>

<?php
    include("User.php");
    include("Author.php");
    include("Post.php");

    // Primero creo al author quien es un usuario 
    $Akeneth = new Author("Keneth Lopez Izaguirre"); // objeto "Akeneth" de la clase "Author"
    $AMaria = new Author("Maria Angelica Del Sol"); // objeto "AMaria" de la clase "Author"
    $APablo = new Author("Pablo Quispe Mamani"); // objeto "APablo" de la clase "Author"
    
    // Creo el post
    // Creo el post con el atributo post
    $Akeneth->post = new Post(
        $Akeneth->getFullName(), 
        "Mi primer título", 
        "Content: Lorem ipsum dolor sit, amet consectetur adipisicing elit. Nam, asperiores, sint libero, quisquam nesciunt minus placeat iure neque tempore quidem earum velit ducimus commodi a nobis aspernatur? Quam, odio ut!", 
        "VueJS");
    // Agrego todo el objeto al array posts
    $Akeneth->agregarPost($Akeneth->post);

    $AMaria->post = new Post(
        $AMaria->getFullName(), 
        "Saludando", 
        "Content: Lorem ipsum dolor sit, amet consectetur adipisicing elit. Nam, asperiores, sint libero, quisquam nesciunt minus placeat iure neque tempore quidem earum velit ducimus commodi a nobis aspernatur? Quam, odio ut!", 
        "PHP");
    // Agrego todo el objeto al array posts
    $AMaria->agregarPost($AMaria->post);  

    $APablo->post = new Post(
        $APablo->getFullName(),
        "Esto es otro título",
        "Esto es el contenido de todo el post, lo mismo que lo anterior pero más corto",
        "Mensaje random");
    // Agrego todo el objeto al array posts
    $APablo->agregarPost($APablo->post);  

    // Muestro el post
    echo $Akeneth->post->showPost();
    echo $AMaria->post->showPost();
    echo $APablo->post->showPost();

    // Lo siguiente es solo para debuguear 
    // Category::mostrar();
    // User::mostrarTodo();
?>

###style.css

@import url('https://fonts.googleapis.com/css2?family=Poppins:wght@200;400&display=swap');

*{
    box-sizing: border-box; 
    margin: 0; 
    padding: 0;
}

:root {
    --color-text: #f3f3f3;
    --primary-color: #f7931a;
    --secondary-color: white;
    --principal-font: 'Poppins', sans-serif;
}
html{
    font-size: 62.5%; /* 1rem = 10px */
    font-family: var(--principal-font);
}


.main-container{
    width: 600px;
    height: auto;
    margin: 0 auto;
    margin-top: 30px;
    padding: 10px;
    display: flex;
    flex-direction: column;
    align-items: center;
    background-color:  var(--primary-color);
    border-radius: 1rem;
    box-shadow: 0px 4px 8px rgb(89 73 30 / 16%);
}

.container{
    display: flex;
    width: 100%;
    padding: 5px;
}
.container-author{
    display: inline-block;
    margin-right: 15px;
    font-size: 1.8rem;
    font-weight: bold;
}

.container-date{
    display: inline-block;
    font-size: 1.8rem;
}

.container-title{
    color: var(--secondary-color);
    font-size: 1.5rem;
    margin-right: 15px;
    font-weight: bold;
}

.container-category{
    color: var(--secondary-color);
    font-size: 1.2rem;
    border-radius: 1rem;
    box-shadow: 1px 1px 2px rgba(128, 128, 128, 0.5);
    padding: 3px 5px;
    background-color: white;
    color: black;
}

.container-content{
    color: var(--secondary-color);
    font-size: 1.5rem;
    text-align: justify;
}

Gustavo Alonso Medina Santiago

Así quedó mi proyecto

<?php

namespace App;

class User
{
    public $nombre;
    protected $password;

    public function __construct($nombre, $password = 'defaultPassword')
    {
        $this->nombre = $nombre;
        $this->password = $password;
    }
}

<?php 

namespace App;

class Author extends User
{
    public $amount_of_posts = 0;

    public function addAmountOfPost()
    {
        $this->amount_of_posts = $this->getAmountOfPost() + 1;
    }

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

Comment.php

<?php

namespace App;

class Comment
{
    protected $likes;
    protected $comment;

    public function __construct($comment)
    {
        $this->comment = $comment;
        $this->likes = 0;
    }
}

<?php

namespace App;

class Category
{
    public $name;

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

<?php

namespace App;

class Post
{
    protected $comments = [];
    protected $author;
    protected $category;
    protected $title;
    protected $content;
    protected $views = 0;
    protected $tags = [];

    public function addComment(Comment $comment)
    {
        $this->comments[] = $comment;
    }

    public function countComments()
    {
        return count($this->comments);
    }

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

    public function addAuthor(Author $author)
    {
        $this->author = $author;
        $author->addAmountOfPost();
    }

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

    public function addCategoty(Category $category)
    {
        $this->category = $category;
    }

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

    public function addTittle($title)
    {
        $this->title = $title;
    }

    public function addContent($content)
    {
        $this->content = $content;
    }

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

    public function addView()
    {
        $this->views = $this->getViews() + 1;
    }

    public function addTag($tag)
    {
        $this->tags[] = $tag;
    }

    public function countTags()
    {
        return count($this->tags);
    }

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

<?php

require __DIR__ . '/vendor/autoload.php';

use App\Author;
use App\Category;
use App\Comment;
use App\Post;

$author = new Author("Gustavo");
$category = new Category("PHP");
$post = new Post();
$comment = new Comment("Muy bueno, gracias");

$post->addComment($comment);
$post->addAuthor($author);
$post->addCategoty($category);
$post->addTittle("Introducción a PHP");
$post->addContent("PHP es un lenguaje de programación Orientado a Objetos");
$post->addView();
$post->addTag("Programación");
$post->addTag("Backend");

echo '<pre>';
echo var_dump($post);
echo '</pre>';

Saul Zamora

<?php

use PHPUnit\Framework\TestCase;
use App\Post;
use App\Comment;
use App\Author;
use App\Category;

class PostTest extends TestCase
{

    public function testCreatePost(){
        $author = new Author("Saul");
        $category = new Category("PHP");
        $post = new Post();

        $post->create($author, $category, 'content');

        $this->assertEquals(1, $post->getCountPostByAuthor($author));
        $this->assertEquals(1, $post->getCountPostByCategory($category));

    }

    public function testAddCommentToPost(){
        $post = new Post();
        $author = new Author("Saul");
        $comment = new Comment();

        $post->addComment($author, $comment);

        $this->assertEquals(1, $post->countComments());
        $this->assertInstanceOf(Comment::Class, $post->getComments()[0]['comment']);

    }
}

<?php

namespace App;

use App\User;

class Author extends User{

    public function __construct($name)
    {
        parent::__construct($name);
    }

}

<?php

namespace App;

class Category{

    private $name;

    public function __construct($name){

        $this->name = $name;

    }

    public function getName(){

        return $this->name;
    }

}

<?php

namespace App;

class Post{

    private $comments=[];
    private $articles=[];


    public function create(Author $author, Category $category, $content){

        $this->articles[] = ["author" => $author->getName(),
        "category" => $category->getName(), 
        "content" => $content ];
        
    }


    public function getCountPostByAuthor(Author $author){

        return  count(array_map(function($item) use($author){
            return $item['author'] == $author->getName();
            }
        ,$this->articles ));

    }
        
    public function getCountPostByCategory(Category $category){


        return  count(array_map(function($item) use($category){
            return $item['category'] == $category->getName();
            }
        ,$this->articles ));

    }

    public function addComment(Author $author,Comment $comment){

        $this->comments[] = ["author" => $author->getName(),
            "comment" => $comment];

    }

    public function countComments(){

        return count ($this->comments);

    } 

    public function getComments(){

        return $this->comments;
    }

}

<?php

namespace App;

class User{

    private $name;

    public function __construct($name)
    {
        $this->name = $name;

    }

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

}

Jose Alexis Vazquez Morales

resultado

composer.json

{
    "name": "slasher/project",
    "description": "just a simple project",
    "autoload": {
        "psr-4": {
            "App\\": "src/"
        }
    },
    "require-dev": {
        "phpunit/phpunit": "^9.5"
    }
}

AuthorTest

<?php

use PHPUnit\Framework\TestCase;
use App\Author;

class AuthorTest extends TestCase
{
    public function test_add_author()
    {
        $author = new Author('197O00045', 'Alexis','Vazquez','Morales', true);

        $this->assertInstanceOf(Author::class, $author);
    }
}

CategoryTest

<?php

use PHPUnit\Framework\TestCase;
use App\Category;

class CategoryTest extends TestCase
{
    public function test_add_category()
    {
        $cateogry = new Category('1','PHP');

        $this->assertInstanceOf(Category::class, $cateogry);
    }
}

PostTest

<?php

use PHPUnit\Framework\TestCase;
use App\Post;

class PostTest extends TestCase
{
    public function test_add_post()
    {
        $post = new Post(1, 'este es un nuevo post', '197O00045', '1');

        $this->assertInstanceOf(Post::class, $post);

    }
}

UserTest

<?php

use PHPUnit\Framework\TestCase;
use App\User;

class UserTest extends TestCase
{
    public function test_add_user()
    {
        $user = new User('Alexis','Vazquez','Morales');

        $this->assertInstanceOf(User::class, $user);
    }
}

José Alberto Ortiz Vargas

El reto esta genial, lo solucione a mi manera y conforme lo que llegue a aprender en los cursos que fue bastante. Reconozco que me falta mucho por mejorar y aprender. Les comparto mi repositorio con el reto y les prometo que volveré para resolver toda la deuda técnica que deje en el reto. Saludos.

Jhonatan Moreno Velasquez

Julian Carelli

Reto Completado ;D

Estructura de carpetas y archivos

Sixto Ortega

Super!, a practicar lo aprendido

Jimmy Buriticá Londoño

Ahora vamos por el examen ...

Nestor David Velasquez Lopez

Comparto mi solución al reto:

Estructura de archivos

namespace App;

class Post 
{
    protected $comments = [];
    protected $title;
    protected $description;

    public function __construct (string $title, string $description)
    {
        $this->title = $title;
        $this->description = $description;
    }

    public function addComment(Comment $comment)
    {
        $this->comments[] = $comment;
    }

    public function countComments()
    {
        return count($this->comments);
    }

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

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

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

namespace App;

class Category
{
    private $name;

    public function __construct (string $name)
    {
        $this->name = $name;
    }

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

namespace App;

class User
{
    protected $firstName;
    protected $lastName;

    public function __construct(string $firstName, string $lastName)
    {
        $this->firstName = $firstName;
        $this->lastName = $lastName;
    }

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

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

namespace App;

class Author extends User
{
   protected $createdPosts = [];

   public function writePost (Post $post)
   {
        array_push($this->createdPosts, $post);
   }

   public function countCreatedPosts ()
   {
      return count($this->createdPosts);
   }

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

<?php
include './vendor/autoload.php';

use App\Author;
use App\Category;
use App\Post;

// Creo al autor del post
$author = new Author('Nestor', 'Velasquez');

// Creo una categoría de ciencias
$scienceCategory = new Category('Ciencias');

// Creo una categoría de Programación
$programmingCategory = new Category('Programacion');

// Creo un primer post
$firstPost = new Post('Las ciencias de la vida', 'La vida es una cienca y la ciencia es una vida... Eres lo que vives, somos ellos, somos aquellos, somos los hombres de negro');

// Creo otro post
$secondPost = new Post('Cómo ser un hacker con Python', 'Para ser un hacker en python tienes que ser un crack en python primero... asi como yo que soy un super crack');

// Mensaje de bienvenida al usuario autor
echo "<h2>Bienvenido {$author->getFirstName()} {$author->getLastName()}</h2>";

// Le asigno un autor a los post creados
$author->writePost($firstPost);
$author->writePost($secondPost);

echo "<p>Has creado hasta ahora {$author->countCreatedPosts()} Posts</p>";

echo "<p>Tus Posts creados son: </p>";

echo "<table>";
    for ($i=0; $i < $author->countCreatedPosts(); $i++) {
        echo "<tr>";
        echo "<td><h4>{$author->getCreatedPosts()[$i]->getTitle()}</h4>
                    <p>{$author->getCreatedPosts()[$i]->getDescription()}</p>
            </td>";
        echo "</tr>";
    }

Francisco Javier Vázquez Paredes

Comparto mi solución

Estructura de Carpetas

<?php

namespace App;

class User {
    protected $name;
    public function __construct($name)
    {
        $this->name = $name;
    }
}

<?php 
namespace App;

use App\User;

class Author extends User 
{

}

<?php
namespace App; 

class Category 
{
    protected $name;
    
    public function __construct($name)
    {  
        $this->name = $name;
    }
}

<?php 

namespace App;

class Comment 
{
    
}

<?php

namespace App;

class Post 
{
    protected $comments = [];
    public $author;
    public $category;

    public function addComment(Comment $comment){
        $this->comments[] = $comment;
    }

    public function countComments(){
        return count($this->comments);
    }

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

PostTest.php

<?php 
use PHPUnit\Framework\TestCase;
use App\Author;
use App\Post;
use App\Category;

class PostTest extends TestCase
{
    public function test_create_post(){
        $author = new Author('Francisco');
        $category = new Category('PHP');
        $post = new Post();
        $post->author = $author;
        $post->category = $category;        
        
        $this->assertInstanceOf(Author::class, $author);
        $this->assertInstanceOf(Category::class, $category);
        $this->assertInstanceOf(Post::class, $post);
        $this->assertClassHasAttribute('author', Post::class);
        $this->assertClassHasAttribute('category', Post::class);
        $this->assertInstanceOf(Author::class, $post->author);
        $this->assertInstanceOf(Category::class, $post->category);
    }
}

<?php
include './vendor/autoload.php';

use App\Post;
use App\Author;
use App\Category;

$author = new Author('Francisco');
$category = new Category('PHPUnit');
$post = new Post();
$post->author = $author;
$post->category = $category;

print_r($post);

Bien ahí. Solo recuerda que en la Programación Orientada a Objetos es importante el uso de getters y setters para manipular los atributos de una clase ;)

Agustin Diaz

student••

Soy autodidacta. En mi juventud inicié con "Basic", y algunos años después (decadas) conocí PHP estructurado, ahora me inicio con POO.

Básandome en la propuesta de Carlos Eduardo Gomez García, generé esta propuesta con dos autores y cada uno con dos publicaciones.

Usuario.php

Categoria.php

Autor.php

Publicacion.php

Sí funcionó!

Muchas gracias.

Xavier Majoral Clols

Clase User: 

<?php

namespace Repte;

class User

{

protected $name;

protected $lastname;

public function setName($name,$lastname)

$this->name = $name;

$this->lastname = $lastname;

}

public function getFullName()

return $this->name . ' ' .$this->lastname;

Clase Author: 

class Author extends User

protected $posts = [];

public function setPost(Post $post)

$this->posts[] = $post;

public function getPosts()

return $this->posts;

public function countPosts()

return count($this->posts);

Clase Category: 

class Category

public function setName(string $name)

public function getCategoryName()

return $this->name;

Clase Post :

class Post

protected $title;

protected $content;

protected $category;

protected $author;

public function setTitle(string $title)

$this->title = $title;

public function setContent(string $content)

$this->content = $content;

public function setCategory(string $category)

$this->category = $category;

public function setAuthor($author)

$this->author = $author;

public function getPostTitle()

return $this->title;

public function getAuthorName()

return $this->author;

public function getCategory()

return $this->category;

public function getContent()

return $this->content;

Test :

use PHPUnit\Framework\TestCase;

use Repte\Author;

use Repte\Post;

use Repte\Category;

class PostTest extends TestCase

public function test_post()

// Creamos un autor

$authors[0] = new Author;

$authors[0]->setName("Xavier","Mateu");

// Creamos una categoría

$categories[0] = new Category;

$categories[0]->setName("PHP");

// Creamos un post

//$posts = new Post("Título", "Contenido", $categories);

$posts[0] = new Post;

$posts[0]->setTitle("Lo más sobre PHP");

$posts[0]->setContent("bla bla bla sobre PHP");

$posts[0]->setCategory($categories[0]->getCategoryName());

$posts[0]->setAuthor($authors[0]);

// Agregar post al autor

$authors[0]->setPost($posts[0]);

// Aserción o afirmación para comprobar que tenemos 1 post agregado

$this->assertEquals(1, $authors[0]->countPosts());

// Aserción o afirmación para comprobar que los post de un autor son una instancia de la clase Post

$this->assertInstanceOf(Post::class, $authors[0]->getPosts()[0]);

index :

include __DIR__ ."/vendor/autoload.php";

//creamos 3 autores

$authors[1] = new Author;

$authors[1]->setName("Manel","Martinez");

$authors[2] = new Author;

$authors[2]->setName("Carles","Andreu");

//creamos las 3 categorias

$categories[1] = new Category;

$categories[1]->setName("VueJS");

$categories[2] = new Category;

$categories[2]->setName("JS");

//creamos los posts y los asociamos a los autores

$posts[3] = new Post;

$posts[3]->setTitle("Algo más sobre PHP");

$posts[3]->setContent("na de na sobre PHP");

$posts[3]->setCategory($categories[0]->getCategoryName());

$posts[3]->setAuthor($authors[0]);

$posts[1] = new Post;

$posts[1]->setTitle("Lo más sobre Vue");

$posts[1]->setContent("bla bla bla sobre Vue");

$posts[1]->setCategory($categories[1]->getCategoryName());

$posts[1]->setAuthor($authors[1]);

$posts[2] = new Post;

$posts[2]->setTitle("Lo más sobre Javascript");

$posts[2]->setContent("bla bla bla sobre Javascript");

$posts[2]->setCategory($categories[2]->getCategoryName());

$posts[2]->setAuthor($authors[2]);

//asignamos los post a los autores

$authors[0]->setPost($posts[3]);

$authors[1]->setPost($posts[1]);

$authors[2]->setPost($posts[2]);

//Listamos todos los posts de cada autor con su título, categoria y contenido

foreach ($authors as $author)

echo "Autor: {$author->getFullName()} ";

foreach ($author->getPosts() as $post)

echo "Título articulo: {$post->getPostTitle()} ";

echo "Categoria {$post->getCategory()} ";

echo "Contenido: {$post->getContent()} ";

echo " ";

Andre Huaman Yovera

### 1. User.php


class User&#x20;

{

&#x20;   protected $id;

&#x20;   protected $name;

&#x20;   protected $email;

&#x20;   protected $createdAt;



&#x20;   public function \_\_construct($name, $email)&#x20;

&#x20;   {

&#x20;       $this->id = uniqid();

&#x20;       $this->name = $name;

&#x20;       $this->email = $email;

&#x20;       $this->createdAt = new DateTime();

&#x20;   }



&#x20;   public function getName()&#x20;

&#x20;   {

&#x20;       return $this->name;

&#x20;   }



&#x20;   public function getEmail()&#x20;

&#x20;   {

&#x20;       return $this->email;

&#x20;   }

}

### 2. Author.php


class Author extends User&#x20;

{

&#x20;   private $posts = \[];

&#x20;   private $biography;



&#x20;   public function \_\_construct($name, $email, $biography = '')&#x20;

&#x20;   {

&#x20;       parent::\_\_construct($name, $email);

&#x20;       $this->biography = $biography;

&#x20;   }



&#x20;   public function createPost($title, $content, $category)&#x20;

&#x20;   {

&#x20;       $post = new Post($this, $title, $content, $category);

&#x20;       $this->posts\[] = $post;

&#x20;       return $post;

&#x20;   }



&#x20;   public function getPosts()&#x20;

&#x20;   {

&#x20;       return $this->posts;

&#x20;   }

}

### 3. Category.php


class Category&#x20;

{

&#x20;   private $id;

&#x20;   private $name;

&#x20;   private $slug;



&#x20;   public function \_\_construct($name)&#x20;

&#x20;   {

&#x20;       $this->id = uniqid();

&#x20;       $this->name = $name;

&#x20;       $this->slug = strtolower(str\_replace(' ', '-', $name));

&#x20;   }



&#x20;   public function getName()&#x20;

&#x20;   {

&#x20;       return $this->name;

&#x20;   }



&#x20;   public function getSlug()&#x20;

&#x20;   {

&#x20;       return $this->slug;

&#x20;   }

}

### 4. Post.php


class Post&#x20;

{

&#x20;   private $id;

&#x20;   private $author;

&#x20;   private $title;

&#x20;   private $content;

&#x20;   private $category;

&#x20;   private $createdAt;

&#x20;   private $status = 'draft';



&#x20;   public function \_\_construct(Author $author, $title, $content, Category $category)&#x20;

&#x20;   {

&#x20;       $this->id = uniqid();

&#x20;       $this->author = $author;

&#x20;       $this->title = $title;

&#x20;       $this->content = $content;

&#x20;       $this->category = $category;

&#x20;       $this->createdAt = new DateTime();

&#x20;   }



&#x20;   public function publish()&#x20;

&#x20;   {

&#x20;       $this->status = 'published';

&#x20;   }



&#x20;   public function getExcerpt($length = 150)&#x20;

&#x20;   {

&#x20;       return substr($this->content, 0, $length) . '...';

&#x20;   }



&#x20;   public function getAuthor()&#x20;

&#x20;   {

&#x20;       return $this->author;

&#x20;   }



&#x20;   public function getCategory()&#x20;

&#x20;   {

&#x20;       return $this->category;

&#x20;   }

}

### 5. index.php


// Incluir las clases

require\_once 'User.php';

require\_once 'Author.php';

require\_once 'Category.php';

require\_once 'Post.php';



// Crear categorías

$phpCategory = new Category('PHP');

$jsCategory = new Category('JavaScript');

$vueCategory = new Category('Vue.js');



// Crear un autor

$author = new Author(

&#x20;   'María García',&#x20;

&#x20;   'maria@ejemplo.com',

&#x20;   'Desarrolladora Full Stack con 5 años de experiencia'

);



// Crear posts

$post1 = $author->createPost(

&#x20;   'Introducción a PHP 8',

&#x20;   'PHP 8 trae nuevas características interesantes como...',

&#x20;   $phpCategory

);



$post2 = $author->createPost(

&#x20;   'Vue.js 3 Composition API',

&#x20;   'La Composition API nos permite mejor organización del código...',

&#x20;   $vueCategory

);



// Publicar posts

$post1->publish();

$post2->publish();



// Mostrar posts

foreach ($author->getPosts() as $post) {

&#x20;   echo "Título: " . $post->getExcerpt() . "\n";

&#x20;   echo "Categoría: " . $post->getCategory()->getName() . "\n";

&#x20;   echo "Autor: " . $post->getAuthor()->getName() . "\n\n";

}

### Mejoras que se podrían añadir:

1. **Sistema de comentarios**:


class Comment {

&#x20;   private $author;

&#x20;   private $content;

&#x20;   private $post;

&#x20;   private $createdAt;

}

2. **Sistema de etiquetas (tags)**:


class Tag {

&#x20;   private $name;

&#x20;   private $slug;

}

3. **Sistema de validación**:


trait Validatable {

&#x20;   public function validate($data) {

&#x20;       // Lógica de validación

&#x20;   }

}

4. **Sistema de búsqueda**:


trait Searchable {

&#x20;   public function search($query) {

&#x20;       // Lógica de búsqueda

&#x20;   }

}

5. **Manejo de imágenes**:


class Image {

&#x20;   private $url;

&#x20;   private $alt;

&#x20;   private $caption;

}

6. **Sistema de caché**:


trait Cacheable {

&#x20;   private function cache($key, $value) {

&#x20;       // Lógica de caché

&#x20;   }

}

7. **Estados del post más elaborados**:

- draft

- pending_review

- published

- archived

8. **Sistema de permisos**:

- Roles (admin, editor, author)

- Permisos específicos por rol

9. **Métricas y estadísticas**:

- Vistas del post

- Tiempo de lectura

- Interacciones

10. **Versiones del post**:

- Historial de cambios

- Restauración de versiones anteriores

Esta implementación es básica pero funcional, y puede expandirse según las necesidades específicas del proyecto.

John Mejia

El test asociado podría ser algo así:

use PHPUnit\Framework\TestCase;
use App\Post;
use App\Comment;
use App\User;
use App\Author;
use App\Category;

class Ejercicio18Test extends TestCase
{
    public function test_user_and_author()
    {
        $author = new Author('john.doe');
        $this->assertEquals('john.doe', $author->name());
    }

    public function test_add_categories()
    {
        $category = new Category('PHP Code');
        $comment = new Comment();
        $comment->addCategory($category);
        // Las categorias deben asociarse a un slug basado en el texto original
        $this->assertEquals('php-code', $category->slug());
    }
  }

Diego Iván Cundapí León

Reto completado.

les dejo el link del repositorio en git hub.

Tengo que decir que si me llevo sus dos horitas por que salieron muchos errores, y aunque implemente un poco de test no supe hacer algunos test pero espero en siguiente cursos aprender más.

Exito a todos.

resultado:

Configuración de un Blog con PHP: Clases de Usuario, Autor, Post y Categoría

Fundamentos

Programación Orientada a Objetos en PHP: Clases y Objetos

Reducción de Deuda Técnica en Programación

Mejorando la Calidad del Código: Evita el "Code Smell"

Cómo evitar el código espagueti con programación orientada a objetos

Técnicas de Inclusión de Archivos en PHP

Programación orientada a objetos

Programación Orientada a Objetos en PHP: Clases y Objetos

Abstracción en Programación Orientada a Objetos

Encapsulamiento y Alcance en PHP: Público, Protegido y Privado

Modularidad en Programación Orientada a Objetos

Polimorfismo en Programación Orientada a Objetos con PHP

Polimorfismo en Programación Orientada a Objetos con PHP

Herencia en Programación Orientada a Objetos

Interfaz en Programación: Concepto y Ejemplo Práctico

Conceptos Clave de Programación Orientada a Objetos en PHP

Proyecto en PHP

Configuración de PHP Unit y Composer para Proyectos PHP

Desarrollo Guiado por Pruebas en PHP: Creación de Clases y Métodos

Pruebas Unitarias con PHP Unit para Proyectos en PHP

Configuración de un Blog con PHP: Clases de Usuario, Autor, Post y Categoría

Conceptos clave de PHP y Programación Orientada a Objetos