Configuración de un Blog con PHP: Clases de Usuario, Autor, Post y Categoría
Contenido del curso
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
Angel Fernando Quiroz Campos
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.
Carlos Eduardo Gomez Garcí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:
Jhon Fabio Cardona Martinez
Excelente diagrama.
Juan Sebastian Calderon
Muchas gracias por el aporte, me ayudo mucho
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!!!!
Estructure
Aka SinssChoss
Gustavo Alonso Medina Santiago
Saul Zamora
Jose Alexis Vazquez Morales
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
Author.php
User.php
Category.php
Comment.php
Post.php
Sixto Ortega
Super!, a practicar lo aprendido
Jimmy Buriticá Londoño
Ahora vamos por el examen ...
Nestor David Velasquez Lopez
Francisco Javier Vázquez Paredes
Gustavo Alonso Medina Santiago
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
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
index.php
Sí funcionó!
Muchas gracias.
Xavier Majoral Clols
<u>Clase User: </u>
<?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;
}
}
<u>Clase Author: </u>
<?php
namespace Repte;
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);
}
}
<u>Clase Category: </u>
<?php
namespace Repte;
class Category
{
protected $name;
public function setName(string $name)
{
$this->name = $name;
}
public function getCategoryName()
{
return $this->name;
}
}
<u>Clase Post :</u>
<?php
namespace Repte;
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 :
<?php
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 :
<?php
include __DIR__ ."/vendor/autoload.php";
use Repte\Category;
use Repte\Author;
use Repte\Post;
//creamos 3 autores
$authors[0] = new Author;
$authors[0]->setName("Xavier","Mateu");
$authors[1] = new Author;
$authors[1]->setName("Manel","Martinez");
$authors[2] = new Author;
$authors[2]->setName("Carles","Andreu");
//creamos las 3 categorias
$categories[0] = new Category;
$categories[0]->setName("PHP");
$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[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]);
$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[0]);
$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()}<br>";
foreach ($author->getPosts() as $post)
{
echo "Título articulo: {$post->getPostTitle()}<br>";
echo "Categoria {$post->getCategory()}<br>";
echo "Contenido: {$post->getContent()}<br>";
echo "<br><br><br>";
}
}
Andre Huaman Yovera
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:
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
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>"; } } ?>
Author.php
<?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; } } ?>
Category.php
<?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>"; } } ?>
Post.php
<?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 } } ?>
index.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; }
Así quedó mi proyecto
User.php
<?php namespace App; class User { public $nombre; protected $password; public function __construct($nombre, $password = 'defaultPassword') { $this->nombre = $nombre; $this->password = $password; } }
Author.php
<?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; } }
Category.php
<?php namespace App; class Category { public $name; public function __construct($name) { $this->name = $name; } }
Post.php
<?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; } }
index.php
<?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>';
<?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; } }
resultado
{ "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); } }
Comparto mi solución al reto:
Estructura de archivos
Post.php
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; } }
Category.php
namespace App; class Category { private $name; public function __construct (string $name) { $this->name = $name; } public function getName () { return $this->name; } }
User.php
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; } }
Author.php
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; } }
index.php
<?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>"; }
Comparto mi solución
Estructura de Carpetas
User.php
<?php namespace App; class User { protected $name; public function __construct($name) { $this->name = $name; } }
Author.php
<?php namespace App; use App\User; class Author extends User { }
Category.php
<?php namespace App; class Category { protected $name; public function __construct($name) { $this->name = $name; } }
Comment.php
<?php namespace App; class Comment { }
Post.php
<?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); } }
index.php
<?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);
### 1. User.php
class User  {   protected $id;   protected $name;   protected $email;   protected $createdAt;   public function \_\_construct($name, $email)    {   $this->id = uniqid();   $this->name = $name;   $this->email = $email;   $this->createdAt = new DateTime();   }   public function getName()    {   return $this->name;   }   public function getEmail()    {   return $this->email;   } }
### 2. Author.php
class Author extends User  {   private $posts = \[];   private $biography;   public function \_\_construct($name, $email, $biography = '')    {   parent::\_\_construct($name, $email);   $this->biography = $biography;   }   public function createPost($title, $content, $category)    {   $post = new Post($this, $title, $content, $category);   $this->posts\[] = $post;   return $post;   }   public function getPosts()    {   return $this->posts;   } }
### 3. Category.php
class Category  {   private $id;   private $name;   private $slug;   public function \_\_construct($name)    {   $this->id = uniqid();   $this->name = $name;   $this->slug = strtolower(str\_replace(' ', '-', $name));   }   public function getName()    {   return $this->name;   }   public function getSlug()    {   return $this->slug;   } }
### 4. Post.php
class Post  {   private $id;   private $author;   private $title;   private $content;   private $category;   private $createdAt;   private $status = 'draft';   public function \_\_construct(Author $author, $title, $content, Category $category)    {   $this->id = uniqid();   $this->author = $author;   $this->title = $title;   $this->content = $content;   $this->category = $category;   $this->createdAt = new DateTime();   }   public function publish()    {   $this->status = 'published';   }   public function getExcerpt($length = 150)    {   return substr($this->content, 0, $length) . '...';   }   public function getAuthor()    {   return $this->author;   }   public function getCategory()    {   return $this->category;   } }
### 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(   'María García',    'maria@ejemplo.com',   'Desarrolladora Full Stack con 5 años de experiencia' ); // Crear posts $post1 = $author->createPost(   'Introducción a PHP 8',   'PHP 8 trae nuevas características interesantes como...',   $phpCategory ); $post2 = $author->createPost(   'Vue.js 3 Composition API',   'La Composition API nos permite mejor organización del código...',   $vueCategory ); // Publicar posts $post1->publish(); $post2->publish(); // Mostrar posts foreach ($author->getPosts() as $post) {   echo "Título: " . $post->getExcerpt() . "\n";   echo "Categoría: " . $post->getCategory()->getName() . "\n";   echo "Autor: " . $post->getAuthor()->getName() . "\n\n"; }
### Mejoras que se podrían añadir:
1. **Sistema de comentarios**:
class Comment {   private $author;   private $content;   private $post;   private $createdAt; }
2. **Sistema de etiquetas (tags)**:
class Tag {   private $name;   private $slug; }
3. **Sistema de validación**:
trait Validatable {   public function validate($data) {   // Lógica de validación   } }
4. **Sistema de búsqueda**:
trait Searchable {   public function search($query) {   // Lógica de búsqueda   } }
5. **Manejo de imágenes**:
class Image {   private $url;   private $alt;   private $caption; }
6. **Sistema de caché**:
trait Cacheable {   private function cache($key, $value) {   // Lógica de caché   } }
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.