806 lines
28 KiB
PHP
806 lines
28 KiB
PHP
<?php
|
|
|
|
// It's good practice to use namespaces, e.g.:
|
|
// namespace VintageCoding\Models;
|
|
// namespace VintageCoding\Repositories;
|
|
|
|
require_once 'db.php'; // For exec_stmt() and get_connection() (though get_connection is used by exec_stmt)
|
|
require_once 'user.php'; // For User and Author classes
|
|
require_once 'space.php';
|
|
|
|
// -- Data Transfer Object for Topics --
|
|
class Topic
|
|
{
|
|
public int $topicId;
|
|
public string $name;
|
|
|
|
public function __construct(int $topicId, string $name)
|
|
{
|
|
$this->topicId = $topicId;
|
|
$this->name = $name;
|
|
}
|
|
|
|
public function getId(): int
|
|
{
|
|
return $this->topicId;
|
|
}
|
|
|
|
public function getName(): string
|
|
{
|
|
return $this->name;
|
|
}
|
|
}
|
|
|
|
// -- Post Data Models (as previously defined, with setReadCount in Post) --
|
|
class Post
|
|
{
|
|
private Space $space;
|
|
private Author $author;
|
|
private int $postTypeId;
|
|
private ?string $title;
|
|
private ?string $slug;
|
|
private int $readCount;
|
|
private ?DateTime $createdAt;
|
|
private ?DateTime $updatedAt;
|
|
private ?DateTime $status;
|
|
private bool $published;
|
|
|
|
public function __construct($postArray)
|
|
{
|
|
$this->postId = $postArray['postId'];
|
|
$this->author = $postArray['authorId'];
|
|
$this->postTypeId = $postArray['postType'];
|
|
$this->title = $postArray['title'];
|
|
$this->slug = $postArray['slug'];
|
|
$this->readCount = 0;
|
|
$this->status = $postArray['status'];
|
|
}
|
|
|
|
public function getPostId(): int
|
|
{
|
|
return $this->postId;
|
|
}
|
|
|
|
public function getAuthor(): Author
|
|
{
|
|
return $this->author;
|
|
}
|
|
|
|
public function getPostTypeId(): int
|
|
{
|
|
return $this->postTypeId;
|
|
}
|
|
|
|
public function getTitle(): ?string
|
|
{
|
|
return $this->title;
|
|
}
|
|
|
|
public function getSlug(): ?string
|
|
{
|
|
return $this->slug;
|
|
}
|
|
|
|
public function getReadCount(): int
|
|
{
|
|
return $this->readCount;
|
|
}
|
|
|
|
public function getCreatedAt(): ?DateTime
|
|
{
|
|
return $this->createdAt;
|
|
}
|
|
|
|
public function getUpdatedAt(): ?DateTime
|
|
{
|
|
return $this->updatedAt;
|
|
}
|
|
|
|
public function getStatus(): ?DateTime
|
|
{
|
|
return $this->status;
|
|
}
|
|
|
|
public function isPublished(): bool
|
|
{
|
|
return $this->published;
|
|
}
|
|
|
|
public function incrementReadCount(): void
|
|
{
|
|
$this->readCount++;
|
|
}
|
|
|
|
public function setSlug(?string $slug): void
|
|
{
|
|
$this->slug = $slug;
|
|
}
|
|
|
|
public function setStatus(?string $status): void
|
|
{
|
|
$this->status = $status;
|
|
}
|
|
|
|
public function setPublished(bool $published): void
|
|
{
|
|
$this->published = $published;
|
|
}
|
|
|
|
public function setReadCount(int $count): void
|
|
{
|
|
$this->readCount = $count;
|
|
}
|
|
}
|
|
|
|
class Essay extends Post
|
|
{
|
|
private ?string $markdown;
|
|
private ?string $excerpt;
|
|
private ?array $files;
|
|
|
|
public function __construct(int $postId, Author $author, ?string $title = null, ?string $slug = null, ?string $markdown = null, ?string $excerpt = null, ?array $files = null, ?DateTime $createdAt = null, ?DateTime $updatedAt = null, ?DateTime $publishedAt = null, bool $published = true)
|
|
{
|
|
parent::__construct($postId, $author, 1, $title, $slug, $createdAt, $updatedAt, $publishedAt, $published);
|
|
$this->markdown = $markdown;
|
|
$this->excerpt = $excerpt;
|
|
$this->files = $files;
|
|
}
|
|
|
|
public function getMarkdown(): ?string
|
|
{
|
|
return $this->markdown;
|
|
}
|
|
|
|
public function getExcerpt(): ?string
|
|
{
|
|
return $this->excerpt;
|
|
}
|
|
|
|
public function getFiles(): ?array
|
|
{
|
|
return $this->files;
|
|
}
|
|
|
|
public function setMarkdown(?string $markdown): void
|
|
{
|
|
$this->markdown = $markdown;
|
|
}
|
|
|
|
public function setExcerpt(?string $excerpt): void
|
|
{
|
|
$this->excerpt = $excerpt;
|
|
}
|
|
|
|
public function setFiles(?array $files): void
|
|
{
|
|
$this->files = $files;
|
|
}
|
|
}
|
|
|
|
class Moment extends Post
|
|
{
|
|
private ?string $caption;
|
|
private ?array $images;
|
|
|
|
public function __construct(int $postId, Author $author, ?string $caption = null, ?array $images = null, ?DateTime $createdAt = null, ?DateTime $updatedAt = null, ?DateTime $publishedAt = null, bool $published = true)
|
|
{
|
|
parent::__construct($postId, $author, 2, null, null, $createdAt, $updatedAt, $publishedAt, $published);
|
|
$this->caption = $caption;
|
|
$this->images = $images;
|
|
}
|
|
|
|
public function getCaption(): ?string
|
|
{
|
|
return $this->caption;
|
|
}
|
|
|
|
public function getImages(): ?array
|
|
{
|
|
return $this->images;
|
|
}
|
|
|
|
public function setCaption(?string $caption): void
|
|
{
|
|
$this->caption = $caption;
|
|
}
|
|
|
|
public function setImages(?array $images): void
|
|
{
|
|
$this->images = $images;
|
|
}
|
|
}
|
|
|
|
class Thought extends Post
|
|
{
|
|
private ?string $thought;
|
|
|
|
public function __construct(int $postId, Author $author, ?string $thought = null, ?DateTime $createdAt = null, ?DateTime $updatedAt = null, ?DateTime $publishedAt = null, bool $published = true)
|
|
{
|
|
parent::__construct($postId, $author, 3, null, null, $createdAt, $updatedAt, $publishedAt, $published);
|
|
$this->thought = $thought;
|
|
}
|
|
|
|
public function getThought(): ?string
|
|
{
|
|
return $this->thought;
|
|
}
|
|
|
|
public function setThought(?string $thought): void
|
|
{
|
|
$this->thought = $thought;
|
|
}
|
|
}
|
|
|
|
// -- Repository for Topics --
|
|
class TopicRepository
|
|
{
|
|
// No $conn property needed as exec_stmt handles connection
|
|
|
|
public function __construct()
|
|
{
|
|
// Constructor is now empty
|
|
}
|
|
|
|
public function getAllTopics(): array
|
|
{
|
|
$result = exec_stmt('SELECT topic_id, topic FROM topics ORDER BY topic ASC', ''); // No params
|
|
$topics = [];
|
|
if ($result instanceof mysqli_result) {
|
|
while ($row = $result->fetch_assoc()) {
|
|
$topics[] = new Topic((int) $row['topic_id'], $row['topic']);
|
|
}
|
|
$result->free();
|
|
} else {
|
|
// exec_stmt for SELECT should return mysqli_result. If not, it's an issue with exec_stmt or query.
|
|
error_log('TopicRepository::getAllTopics expected mysqli_result, got something else.');
|
|
}
|
|
return $topics;
|
|
}
|
|
|
|
public function findById(int $topicId): ?Topic
|
|
{
|
|
$result = exec_stmt('SELECT topic_id, topic FROM topics WHERE topic_id = ?', 'i', $topicId);
|
|
if ($result instanceof mysqli_result) {
|
|
if ($row = $result->fetch_assoc()) {
|
|
$result->free();
|
|
return new Topic((int) $row['topic_id'], $row['topic']);
|
|
}
|
|
$result->free();
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public function findByName(string $name): ?Topic
|
|
{
|
|
$result = exec_stmt('SELECT topic_id, topic FROM topics WHERE topic = ?', 's', $name);
|
|
if ($result instanceof mysqli_result) {
|
|
if ($row = $result->fetch_assoc()) {
|
|
$result->free();
|
|
return new Topic((int) $row['topic_id'], $row['topic']);
|
|
}
|
|
$result->free();
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public function findOrCreate(string $name): Topic
|
|
{
|
|
$topic = $this->findByName($name);
|
|
if ($topic) {
|
|
return $topic;
|
|
}
|
|
|
|
// topics.topic_id is AUTO_INCREMENT, so exec_stmt should return the new ID.
|
|
$newTopicId = exec_stmt('INSERT INTO topics (topic) VALUES (?)', 's', $name);
|
|
|
|
if (is_numeric($newTopicId) && $newTopicId > 0) {
|
|
return new Topic((int) $newTopicId, $name);
|
|
}
|
|
// If $newTopicId is 0 or not numeric, insert failed or exec_stmt behavior is unexpected.
|
|
throw new \RuntimeException('Failed to create topic or retrieve its ID: ' . $name);
|
|
}
|
|
}
|
|
|
|
// -- Repository for Posts --
|
|
class PostRepository
|
|
{
|
|
private TopicRepository $topicRepository;
|
|
private string $essayContentPath;
|
|
|
|
public function __construct(TopicRepository $topicRepository, string $essayContentPath)
|
|
{
|
|
$this->topicRepository = $topicRepository;
|
|
$this->essayContentPath = rtrim($essayContentPath, '/') . '/';
|
|
}
|
|
|
|
private function getAuthorFromDb(int $authorId): ?Author
|
|
{
|
|
$result = exec_stmt('SELECT user_id, username, profile_picture, bio, website FROM user WHERE user_id = ?', 'i', $authorId);
|
|
if ($result instanceof mysqli_result) {
|
|
$authorData = $result->fetch_assoc();
|
|
$result->free();
|
|
if ($authorData) {
|
|
return new Author(
|
|
(int) $authorData['user_id'],
|
|
$authorData['username'],
|
|
$authorData['profile_picture'],
|
|
$authorData['bio'],
|
|
$authorData['website']
|
|
);
|
|
}
|
|
} else {
|
|
error_log('PostRepository::getAuthorFromDb expected mysqli_result for author ID: ' . $authorId);
|
|
}
|
|
error_log('Author not found with ID: ' . $authorId);
|
|
return null;
|
|
}
|
|
|
|
private function hydratePost(array $row): ?Post
|
|
{
|
|
$author = $this->getAuthorFromDb((int) $row['author_id']);
|
|
if (!$author)
|
|
return null;
|
|
|
|
$postId = (int) $row['post_id'];
|
|
$postTypeId = (int) $row['post_type'];
|
|
$title = $row['title'];
|
|
$slug = $row['slug'];
|
|
$readCount = (int) $row['read_count'];
|
|
$createdAt = $row['created_at'] ? new DateTime($row['created_at']) : null;
|
|
$updatedAt = $row['updated_at'] ? new DateTime($row['updated_at']) : null;
|
|
$publishedAt = $row['published_at'] ? new DateTime($row['published_at']) : null;
|
|
$published = (bool) $row['published'];
|
|
$post = null;
|
|
|
|
switch ($postTypeId) {
|
|
case 1: // Essay
|
|
$markdown = $this->getEssayMarkdown($postId);
|
|
$post = new Essay($postId, $author, $title, $slug, $markdown, $row['excerpt'], null, $createdAt, $updatedAt, $publishedAt, $published);
|
|
break;
|
|
case 2: // Moment
|
|
$post = new Moment($postId, $author, $row['excerpt'], null, $createdAt, $updatedAt, $publishedAt, $published);
|
|
break;
|
|
case 3: // Thought
|
|
$post = new Thought($postId, $author, $row['excerpt'], $createdAt, $updatedAt, $publishedAt, $published);
|
|
break;
|
|
default:
|
|
error_log('Unknown post type ID: ' . $postTypeId);
|
|
return null;
|
|
}
|
|
if ($post)
|
|
$post->setReadCount($readCount);
|
|
return $post;
|
|
}
|
|
|
|
// File operations remain unchanged as they don't use the DB connection directly
|
|
private function getEssayMarkdown(int $postId): ?string
|
|
{ /* ... same as before ... */
|
|
$filePath = $this->essayContentPath . $postId . '/article.md';
|
|
if (file_exists($filePath) && is_readable($filePath)) {
|
|
return file_get_contents($filePath);
|
|
}
|
|
return null;
|
|
}
|
|
|
|
private function saveEssayMarkdown(int $postId, string $markdownContent): bool
|
|
{ /* ... same as before ... */
|
|
$dirPath = $this->essayContentPath . $postId . '/';
|
|
if (!is_dir($dirPath)) {
|
|
if (!mkdir($dirPath, 0755, true)) {
|
|
error_log('Failed to create directory: ' . $dirPath);
|
|
return false;
|
|
}
|
|
}
|
|
$filePath = $dirPath . 'article.md';
|
|
if (file_put_contents($filePath, $markdownContent) === false) {
|
|
error_log('Failed to write markdown file: ' . $filePath);
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
private function deleteEssayContentDirectory(int $postId): bool
|
|
{ /* ... same as before ... */
|
|
$dirPath = $this->essayContentPath . $postId . '/';
|
|
if (!is_dir($dirPath))
|
|
return true;
|
|
$files = new RecursiveIteratorIterator(
|
|
new RecursiveDirectoryIterator($dirPath, RecursiveDirectoryIterator::SKIP_DOTS),
|
|
RecursiveIteratorIterator::CHILD_FIRST
|
|
);
|
|
foreach ($files as $fileinfo) {
|
|
$todo = ($fileinfo->isDir() ? 'rmdir' : 'unlink');
|
|
if (!@$todo($fileinfo->getRealPath())) {
|
|
error_log("Failed to {$todo} {$fileinfo->getRealPath()}");
|
|
return false;
|
|
}
|
|
}
|
|
if (!@rmdir($dirPath)) {
|
|
error_log("Failed to remove main directory {$dirPath}");
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
public function findById(int $postId): ?Post
|
|
{
|
|
$result = exec_stmt('SELECT * FROM posts WHERE post_id = ?', 'i', $postId);
|
|
if ($result instanceof mysqli_result) {
|
|
$row = $result->fetch_assoc();
|
|
$result->free();
|
|
return $row ? $this->hydratePost($row) : null;
|
|
}
|
|
error_log('PostRepository::findById expected mysqli_result for post ID: ' . $postId);
|
|
return null;
|
|
}
|
|
|
|
public function getPostIds(string $orderBy = 'published_at', string $direction = 'DESC'): array
|
|
{
|
|
// Basic validation for orderBy and direction
|
|
$orderBy = preg_replace('/[^a-zA-Z0-9_]/', '', $orderBy); // Basic sanitization
|
|
$direction = strtoupper($direction) === 'ASC' ? 'ASC' : 'DESC';
|
|
|
|
$sql = "SELECT post_id FROM posts ORDER BY $orderBy $direction";
|
|
$result = exec_stmt($sql, '');
|
|
$ids = [];
|
|
if ($result instanceof mysqli_result) {
|
|
while ($row = $result->fetch_assoc())
|
|
$ids[] = (int) $row['post_id'];
|
|
$result->free();
|
|
} else {
|
|
error_log('Error in getPostIds: Expected mysqli_result.');
|
|
}
|
|
return $ids;
|
|
}
|
|
|
|
public function getAllPosts(string $orderBy = 'published_at', string $direction = 'DESC'): array
|
|
{
|
|
$orderBy = preg_replace('/[^a-zA-Z0-9_]/', '', $orderBy);
|
|
$direction = strtoupper($direction) === 'ASC' ? 'ASC' : 'DESC';
|
|
|
|
$sql = "SELECT * FROM posts ORDER BY $orderBy $direction";
|
|
$result = exec_stmt($sql, '');
|
|
$posts = [];
|
|
if ($result instanceof mysqli_result) {
|
|
while ($row = $result->fetch_assoc()) {
|
|
if ($postObject = $this->hydratePost($row))
|
|
$posts[] = $postObject;
|
|
}
|
|
$result->free();
|
|
} else {
|
|
error_log('Error in getAllPosts: Expected mysqli_result.');
|
|
}
|
|
return $posts;
|
|
}
|
|
|
|
public function getPostIdsByAuthor(int $authorId, string $orderBy = 'published_at', string $direction = 'DESC'): array
|
|
{
|
|
$orderBy = preg_replace('/[^a-zA-Z0-9_]/', '', $orderBy);
|
|
$direction = strtoupper($direction) === 'ASC' ? 'ASC' : 'DESC';
|
|
|
|
$sql = "SELECT post_id FROM posts WHERE author_id = ? ORDER BY $orderBy $direction";
|
|
$result = exec_stmt($sql, 'i', $authorId);
|
|
$ids = [];
|
|
if ($result instanceof mysqli_result) {
|
|
while ($row = $result->fetch_assoc())
|
|
$ids[] = (int) $row['post_id'];
|
|
$result->free();
|
|
} else {
|
|
error_log('Error in getPostIdsByAuthor: Expected mysqli_result.');
|
|
}
|
|
return $ids;
|
|
}
|
|
|
|
public function getPostsByAuthor(int $authorId, string $orderBy = 'published_at', string $direction = 'DESC'): array
|
|
{
|
|
$orderBy = preg_replace('/[^a-zA-Z0-9_.]/', '', $orderBy); // Allow dot for aliased columns
|
|
$direction = strtoupper($direction) === 'ASC' ? 'ASC' : 'DESC';
|
|
|
|
$sql = "SELECT * FROM posts WHERE author_id = ? ORDER BY $orderBy $direction";
|
|
$result = exec_stmt($sql, 'i', $authorId);
|
|
$posts = [];
|
|
if ($result instanceof mysqli_result) {
|
|
while ($row = $result->fetch_assoc()) {
|
|
if ($postObject = $this->hydratePost($row))
|
|
$posts[] = $postObject;
|
|
}
|
|
$result->free();
|
|
} else {
|
|
error_log('Error in getPostsByAuthor: Expected mysqli_result.');
|
|
}
|
|
return $posts;
|
|
}
|
|
|
|
public function getPostIdsByTopicName(string $topicName, string $orderBy = 'p.published_at', string $direction = 'DESC'): array
|
|
{
|
|
$orderBy = preg_replace('/[^a-zA-Z0-9_.]/', '', $orderBy);
|
|
$direction = strtoupper($direction) === 'ASC' ? 'ASC' : 'DESC';
|
|
|
|
$sql = "SELECT p.post_id FROM posts p
|
|
INNER JOIN post_topics pt ON p.post_id = pt.post_id
|
|
INNER JOIN topics t ON pt.topic_id = t.topic_id
|
|
WHERE t.topic = ?
|
|
ORDER BY $orderBy $direction";
|
|
$result = exec_stmt($sql, 's', $topicName);
|
|
$ids = [];
|
|
if ($result instanceof mysqli_result) {
|
|
while ($row = $result->fetch_assoc())
|
|
$ids[] = (int) $row['post_id'];
|
|
$result->free();
|
|
} else {
|
|
error_log('Error in getPostIdsByTopicName: Expected mysqli_result.');
|
|
}
|
|
return $ids;
|
|
}
|
|
|
|
public function getPostsByTopicName(string $topicName, string $orderBy = 'p.published_at', string $direction = 'DESC'): array
|
|
{
|
|
$orderBy = preg_replace('/[^a-zA-Z0-9_.]/', '', $orderBy);
|
|
$direction = strtoupper($direction) === 'ASC' ? 'ASC' : 'DESC';
|
|
|
|
$sql = "SELECT p.* FROM posts p
|
|
INNER JOIN post_topics pt ON p.post_id = pt.post_id
|
|
INNER JOIN topics t ON pt.topic_id = t.topic_id
|
|
WHERE t.topic = ?
|
|
ORDER BY $orderBy $direction";
|
|
$result = exec_stmt($sql, 's', $topicName);
|
|
$posts = [];
|
|
if ($result instanceof mysqli_result) {
|
|
while ($row = $result->fetch_assoc()) {
|
|
if ($postObject = $this->hydratePost($row))
|
|
$posts[] = $postObject;
|
|
}
|
|
$result->free();
|
|
} else {
|
|
error_log('Error in getPostsByTopicName: Expected mysqli_result.');
|
|
}
|
|
return $posts;
|
|
}
|
|
|
|
private function updatePostTopics(int $postId, array $topicNames): void
|
|
{
|
|
// Delete existing topics for the post
|
|
// exec_stmt returns 0 for successful DELETE. No direct success check here.
|
|
exec_stmt('DELETE FROM post_topics WHERE post_id = ?', 'i', $postId);
|
|
|
|
if (empty($topicNames))
|
|
return;
|
|
|
|
// Batch insert is harder with this exec_stmt. Doing one by one.
|
|
// This is inefficient but simpler with the current exec_stmt.
|
|
foreach ($topicNames as $name) {
|
|
$topicObj = $this->topicRepository->findOrCreate(trim($name));
|
|
// post_topics has no auto-increment, exec_stmt will return 0 for success.
|
|
exec_stmt('INSERT INTO post_topics (post_id, topic_id) VALUES (?, ?)', 'ii', $postId, $topicObj->getId());
|
|
}
|
|
}
|
|
|
|
public function createPost(Post $post, array $topicNames = []): ?Post
|
|
{
|
|
// WARNING: No transaction possible with the provided exec_stmt for multi-step operations.
|
|
// Each exec_stmt is its own transaction.
|
|
try {
|
|
$sql = 'INSERT INTO posts (post_id, author_id, post_type, title, slug, read_count, created_at, updated_at, published_at, published, excerpt)
|
|
VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)';
|
|
|
|
$postIdVal = $post->getPostId();
|
|
$authorId = $post->getAuthor()->getUserId();
|
|
$postTypeId = $post->getPostTypeId();
|
|
$title = $post->getTitle();
|
|
$slug = $post->getSlug();
|
|
$readCount = $post->getReadCount();
|
|
$createdAtDb = $post->getCreatedAt() ? $post->getCreatedAt()->format('Y-m-d H:i:s') : (new DateTime())->format('Y-m-d H:i:s');
|
|
$updatedAtDb = $post->getUpdatedAt() ? $post->getUpdatedAt()->format('Y-m-d H:i:s') : (new DateTime())->format('Y-m-d H:i:s');
|
|
$publishedAtDb = $post->getPublishedAt() ? $post->getPublishedAt()->format('Y-m-d H:i:s') : null;
|
|
$published = (int) $post->isPublished();
|
|
$excerpt = null;
|
|
if ($post instanceof Essay)
|
|
$excerpt = $post->getExcerpt();
|
|
elseif ($post instanceof Moment)
|
|
$excerpt = $post->getCaption();
|
|
elseif ($post instanceof Thought)
|
|
$excerpt = $post->getThought();
|
|
|
|
// For INSERT on `posts` (no auto-increment PK), exec_stmt returns 0 on success.
|
|
$insertResult = exec_stmt(
|
|
$sql,
|
|
'iiississsis',
|
|
$postIdVal,
|
|
$authorId,
|
|
$postTypeId,
|
|
$title,
|
|
$slug,
|
|
$readCount,
|
|
$createdAtDb,
|
|
$updatedAtDb,
|
|
$publishedAtDb,
|
|
$published,
|
|
$excerpt
|
|
);
|
|
|
|
// We can't reliably check $insertResult for success of this specific insert.
|
|
// Assume success if no PHP error/exception was thrown by exec_stmt (though it doesn't throw).
|
|
|
|
if ($post instanceof Essay && $post->getMarkdown() !== null) {
|
|
if (!$this->saveEssayMarkdown($postIdVal, $post->getMarkdown())) {
|
|
// Rollback is not possible. Log error.
|
|
error_log('Failed to save essay markdown for post ID: ' . $postIdVal . '. DB insert was separate.');
|
|
// Potentially delete the created post record if consistency is critical, but that's complex.
|
|
}
|
|
}
|
|
$this->updatePostTopics($postIdVal, $topicNames); // Also not part of a transaction
|
|
return $this->findById($postIdVal);
|
|
} catch (\Exception $e) { // Catch any exceptions from our code, not exec_stmt
|
|
error_log("Error creating post (ID: {$post->getPostId()}): " . $e->getMessage());
|
|
return null;
|
|
}
|
|
}
|
|
|
|
public function updatePost(Post $post, array $topicNames = []): ?Post
|
|
{
|
|
// WARNING: No transaction possible.
|
|
try {
|
|
$sql = 'UPDATE posts SET author_id = ?, post_type = ?, title = ?, slug = ?,
|
|
updated_at = CURRENT_TIMESTAMP, published_at = ?, published = ?, excerpt = ?
|
|
WHERE post_id = ?';
|
|
|
|
$authorId = $post->getAuthor()->getUserId();
|
|
$postTypeId = $post->getPostTypeId();
|
|
$title = $post->getTitle();
|
|
$slug = $post->getSlug();
|
|
$publishedAtDb = $post->getPublishedAt() ? $post->getPublishedAt()->format('Y-m-d H:i:s') : null;
|
|
$published = (int) $post->isPublished();
|
|
$postIdVal = $post->getPostId();
|
|
$excerpt = null;
|
|
if ($post instanceof Essay)
|
|
$excerpt = $post->getExcerpt();
|
|
elseif ($post instanceof Moment)
|
|
$excerpt = $post->getCaption();
|
|
elseif ($post instanceof Thought)
|
|
$excerpt = $post->getThought();
|
|
|
|
// exec_stmt returns 0 for successful UPDATE.
|
|
exec_stmt(
|
|
$sql,
|
|
'iisssisi',
|
|
$authorId,
|
|
$postTypeId,
|
|
$title,
|
|
$slug,
|
|
$publishedAtDb,
|
|
$published,
|
|
$excerpt,
|
|
$postIdVal
|
|
);
|
|
|
|
if ($post instanceof Essay && $post->getMarkdown() !== null) {
|
|
if (!$this->saveEssayMarkdown($postIdVal, $post->getMarkdown())) {
|
|
error_log('Failed to save essay markdown for post ID: ' . $postIdVal . ' during update.');
|
|
}
|
|
}
|
|
$this->updatePostTopics($postIdVal, $topicNames);
|
|
return $this->findById($postIdVal);
|
|
} catch (\Exception $e) {
|
|
error_log("Error updating post (ID: {$post->getPostId()}): " . $e->getMessage());
|
|
return null;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Deletes a post.
|
|
* WARNING: Due to exec_stmt, this is not a transactional operation.
|
|
* Success of individual DB deletions is not reliably checkable.
|
|
* This method attempts the operations and logs errors.
|
|
* Consider changing return type to void as boolean success is ambiguous.
|
|
*/
|
|
public function deletePost(int $postId): void
|
|
{
|
|
try {
|
|
$postDataResult = exec_stmt('SELECT post_type FROM posts WHERE post_id = ?', 'i', $postId);
|
|
$postType = null;
|
|
if ($postDataResult instanceof mysqli_result && $row = $postDataResult->fetch_assoc()) {
|
|
$postType = (int) $row['post_type'];
|
|
$postDataResult->free();
|
|
}
|
|
|
|
exec_stmt('DELETE FROM post_topics WHERE post_id = ?', 'i', $postId);
|
|
exec_stmt('DELETE FROM posts WHERE post_id = ?', 'i', $postId);
|
|
// Cannot reliably check if the above deletes were successful or affected rows.
|
|
|
|
if ($postType === 1) { // Essay
|
|
if (!$this->deleteEssayContentDirectory($postId)) {
|
|
error_log('Failed to delete essay content directory for post ID: ' . $postId);
|
|
}
|
|
}
|
|
} catch (\Exception $e) {
|
|
error_log("Error during deletePost for ID $postId: " . $e->getMessage());
|
|
// Depending on desired behavior, re-throw or handle
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Deletes posts by author.
|
|
* WARNING: Not transactional. Returns void as count of deleted posts cannot be reliably obtained from exec_stmt.
|
|
*/
|
|
public function deletePostsByAuthor(int $authorId): void
|
|
{
|
|
try {
|
|
$result = exec_stmt('SELECT post_id, post_type FROM posts WHERE author_id = ?', 'i', $authorId);
|
|
$postsToDelete = [];
|
|
if ($result instanceof mysqli_result) {
|
|
while ($row = $result->fetch_assoc())
|
|
$postsToDelete[] = $row;
|
|
$result->free();
|
|
} else {
|
|
error_log("Failed to fetch posts for deletion by author ID: $authorId");
|
|
return; // Exit if we can't get the list of posts
|
|
}
|
|
|
|
foreach ($postsToDelete as $postInfo) {
|
|
if ((int) $postInfo['post_type'] === 1) { // Essay
|
|
if (!$this->deleteEssayContentDirectory((int) $postInfo['post_id'])) {
|
|
error_log('Failed to delete essay content for post ' . $postInfo['post_id'] . ' during mass delete by author.');
|
|
}
|
|
}
|
|
// Handle Moment image deletion if any
|
|
}
|
|
|
|
// Must delete from child table `post_topics` first if no ON DELETE CASCADE, or if ensuring order.
|
|
// This is more complex with joins if exec_stmt doesn't handle it well.
|
|
// Simpler: iterate and delete topics for each post_id, or a broader delete.
|
|
foreach ($postsToDelete as $postInfo) {
|
|
exec_stmt('DELETE FROM post_topics WHERE post_id = ?', 'i', (int) $postInfo['post_id']);
|
|
}
|
|
exec_stmt('DELETE FROM posts WHERE author_id = ?', 'i', $authorId);
|
|
// Cannot get actual deleted count.
|
|
} catch (\Exception $e) {
|
|
error_log("Error deleting posts by author (ID: $authorId): " . $e->getMessage());
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Increments read count for a post.
|
|
* WARNING: Success of the UPDATE is not reliably checkable with current exec_stmt.
|
|
*/
|
|
public function incrementReadCount(int $postId): void
|
|
{
|
|
// exec_stmt returns 0 for successful UPDATE.
|
|
exec_stmt('UPDATE posts SET read_count = read_count + 1 WHERE post_id = ?', 'i', $postId);
|
|
// No easy way to confirm success with current exec_stmt.
|
|
}
|
|
}
|
|
|
|
// Example Usage (Illustrative - this would go in your controller/logic files)
|
|
|
|
/*
|
|
* $topicRepo = new TopicRepository();
|
|
* // Ensure $_ENV['ESSAY_CONTENT_PATH'] is set in your environment/config
|
|
* $essayPath = $_ENV['ESSAY_CONTENT_PATH'] ?? '/path/to/your/site/public/essays';
|
|
* $postRepo = new PostRepository($topicRepo, $essayPath);
|
|
*
|
|
* // --- Fetching Posts ---
|
|
* // $allPosts = $postRepo->getAllPosts('created_at', 'DESC');
|
|
* // $post123 = $postRepo->findById(123);
|
|
* // if ($post123 instanceof Essay) {
|
|
* // echo "Essay Title: " . $post123->getTitle() . "\n";
|
|
* // }
|
|
*
|
|
* // --- Creating a new Essay ---
|
|
* // $author = $userRepo->findAuthorById(1); // Assuming a UserRepo or similar for authors
|
|
* // if ($author) {
|
|
* // $newEssayId = 1001; // Must be unique, not auto-incremented in schema
|
|
* // $newEssay = new Essay(
|
|
* // $newEssayId, $author, "My New OOP Essay", "my-new-oop-essay",
|
|
* // "# Hello World\n\nThis is markdown content.", "An excerpt about the essay."
|
|
* // );
|
|
* // $createdPost = $postRepo->createPost($newEssay, ['PHP', 'OOP', 'Refactoring']);
|
|
* // if ($createdPost) {
|
|
* // echo "Created Post ID: " . $createdPost->getPostId() . "\n";
|
|
* // } else {
|
|
* // echo "Failed to create post.\n";
|
|
* // }
|
|
* // }
|
|
*
|
|
* // No explicit $dbConnection->close(); needed as exec_stmt handles its own connections.
|
|
*/
|