You are logged in as getRole()) ?>
+Username: getUsername()) ?>
+Email: getEmail()) ?>
+Role: getRole()) ?>
+Account Status: getStatus()) ?>
+ getLastLoginAt()): ?> +Last Login: getLastLoginAt()->format('F j, Y g:i A') ?>
+ +, 128) ?>)
+ + Your profile picture is provided by Gravatar and linked to your email address. +
+ Change Avatar at Gravatar.com +| ID | +Username | +Role | +Status | +Created | +Actions | +|
|---|---|---|---|---|---|---|
| getId() ?> | +getUsername() ) ?> | +getEmail() ) ?> | +getRole() ) ?> | +getStatus() ) ?> | +getCreatedAt() ? $user->getCreatedAt()->format( 'Y-m-d H:i' ) : 'N/A' ?> | ++ Edit + getId() !== $user->getId() ): ?> + + + | +
| No users found | +||||||
+ Enter your email address and we'll send you a link to reset your password. +
++ Enter a new password for your account. +
+getDescription() ) ?>
+ ++ getPostCount() ?? 0 ?> posts in this category +
++ + By getAuthor() ) ?> + on getCreatedAt() ? $post->getCreatedAt()->format( 'F j, Y' ) : '' ?> + +
+ getExcerpt() ): ?> +getExcerpt() ) ?>
+ + Read More +No posts found in this category.
++ + getAuthor(); ?> + By getUsername() : 'Unknown' ) ?> + on getCreatedAt() ? $Post->getCreatedAt()->format( 'F j, Y' ) : '' ?> + getViewCount() > 0 ): ?> + · getViewCount() ?> views + + +
+ getExcerpt() ): ?> +getExcerpt() ) ?>
+ + + getCategories() ) ): ?> +No posts found. Check back soon!
++ getAuthor(); ?> + By getUsername() : 'Unknown' ) ?> + on getCreatedAt() ? $Post->getCreatedAt()->format( 'F j, Y' ) : '' ?> + getViewCount() > 0 ): ?> + · getViewCount() ?> views + +
+ + getCategories() ) ): ?> ++ getPostCount() ?? 0 ?> posts with this tag +
++ + By getAuthor() ) ?> + on getCreatedAt() ? $post->getCreatedAt()->format( 'F j, Y' ) : '' ?> + +
+ getExcerpt() ): ?> +getExcerpt() ) ?>
+ + Read More +No posts found with this tag.
+Blank Neuron CMS website.
+' . htmlspecialchars( $Message ) . '
'; + exit; + } +} diff --git a/src/Cms/Auth/PasswordHasher.php b/src/Cms/Auth/PasswordHasher.php new file mode 100644 index 0000000..b48baa8 --- /dev/null +++ b/src/Cms/Auth/PasswordHasher.php @@ -0,0 +1,200 @@ +_MinLength ) + { + return false; + } + + // Check for uppercase letters + if( $this->_RequireUppercase && !preg_match( '/[A-Z]/', $Password ) ) + { + return false; + } + + // Check for lowercase letters + if( $this->_RequireLowercase && !preg_match( '/[a-z]/', $Password ) ) + { + return false; + } + + // Check for numbers + if( $this->_RequireNumbers && !preg_match( '/[0-9]/', $Password ) ) + { + return false; + } + + // Check for special characters + if( $this->_RequireSpecialChars && !preg_match( '/[^A-Za-z0-9]/', $Password ) ) + { + return false; + } + + return true; + } + + /** + * Get password validation error messages + */ + public function getValidationErrors( string $Password ): array + { + $Errors = []; + + if( strlen( $Password ) < $this->_MinLength ) + { + $Errors[] = "Password must be at least {$this->_MinLength} characters long"; + } + + if( $this->_RequireUppercase && !preg_match( '/[A-Z]/', $Password ) ) + { + $Errors[] = 'Password must contain at least one uppercase letter'; + } + + if( $this->_RequireLowercase && !preg_match( '/[a-z]/', $Password ) ) + { + $Errors[] = 'Password must contain at least one lowercase letter'; + } + + if( $this->_RequireNumbers && !preg_match( '/[0-9]/', $Password ) ) + { + $Errors[] = 'Password must contain at least one number'; + } + + if( $this->_RequireSpecialChars && !preg_match( '/[^A-Za-z0-9]/', $Password ) ) + { + $Errors[] = 'Password must contain at least one special character'; + } + + return $Errors; + } + + /** + * Set minimum password length + */ + public function setMinLength( int $MinLength ): self + { + $this->_MinLength = $MinLength; + return $this; + } + + /** + * Set whether uppercase letters are required + */ + public function setRequireUppercase( bool $RequireUppercase ): self + { + $this->_RequireUppercase = $RequireUppercase; + return $this; + } + + /** + * Set whether lowercase letters are required + */ + public function setRequireLowercase( bool $RequireLowercase ): self + { + $this->_RequireLowercase = $RequireLowercase; + return $this; + } + + /** + * Set whether numbers are required + */ + public function setRequireNumbers( bool $RequireNumbers ): self + { + $this->_RequireNumbers = $RequireNumbers; + return $this; + } + + /** + * Set whether special characters are required + */ + public function setRequireSpecialChars( bool $RequireSpecialChars ): self + { + $this->_RequireSpecialChars = $RequireSpecialChars; + return $this; + } + + /** + * Configure password requirements from settings + */ + public function configure( array $Settings ): self + { + if( isset( $Settings['min_length'] ) ) + { + $this->setMinLength( $Settings['min_length'] ); + } + + if( isset( $Settings['require_uppercase'] ) ) + { + $this->setRequireUppercase( $Settings['require_uppercase'] ); + } + + if( isset( $Settings['require_lowercase'] ) ) + { + $this->setRequireLowercase( $Settings['require_lowercase'] ); + } + + if( isset( $Settings['require_numbers'] ) ) + { + $this->setRequireNumbers( $Settings['require_numbers'] ); + } + + if( isset( $Settings['require_special_chars'] ) ) + { + $this->setRequireSpecialChars( $Settings['require_special_chars'] ); + } + + return $this; + } +} diff --git a/src/Cms/Auth/PasswordResetManager.php b/src/Cms/Auth/PasswordResetManager.php new file mode 100644 index 0000000..1b37ca9 --- /dev/null +++ b/src/Cms/Auth/PasswordResetManager.php @@ -0,0 +1,239 @@ +_TokenRepository = $TokenRepository; + $this->_UserRepository = $UserRepository; + $this->_PasswordHasher = $PasswordHasher; + $this->_ResetUrl = $ResetUrl; + $this->_FromEmail = $FromEmail; + $this->_FromName = $FromName; + } + + /** + * Set token expiration time in minutes + */ + public function setTokenExpirationMinutes( int $Minutes ): self + { + $this->_TokenExpirationMinutes = $Minutes; + return $this; + } + + /** + * Request a password reset for a user + * + * Generates a secure token, stores it, and sends an email to the user. + * + * @param string $Email User's email address + * @return bool True if reset email was sent, false if user not found + * @throws Exception if email sending fails + */ + public function requestReset( string $Email ): bool + { + // Check if user exists + $User = $this->_UserRepository->findByEmail( $Email ); + + if( !$User ) + { + // Don't reveal whether email exists in system + return true; + } + + // Delete any existing tokens for this email + $this->_TokenRepository->deleteByEmail( $Email ); + + // Generate secure random token + $PlainToken = bin2hex( random_bytes( 32 ) ); + $HashedToken = hash( 'sha256', $PlainToken ); + + // Create and store token + $Token = new PasswordResetToken( + $Email, + $HashedToken, + $this->_TokenExpirationMinutes + ); + + $this->_TokenRepository->create( $Token ); + + // Send reset email + $this->sendResetEmail( $Email, $PlainToken ); + + return true; + } + + /** + * Validate a reset token + * + * @param string $PlainToken Plain text token from URL + * @return PasswordResetToken|null Token if valid and not expired, null otherwise + */ + public function validateToken( string $PlainToken ): ?PasswordResetToken + { + $HashedToken = hash( 'sha256', $PlainToken ); + + $Token = $this->_TokenRepository->findByToken( $HashedToken ); + + if( !$Token || $Token->isExpired() ) + { + return null; + } + + return $Token; + } + + /** + * Reset password using a valid token + * + * @param string $PlainToken Plain text token from URL + * @param string $NewPassword New password to set + * @return bool True if password was reset, false if token invalid or expired + * @throws Exception if password doesn't meet requirements or update fails + */ + public function resetPassword( string $PlainToken, string $NewPassword ): bool + { + // Validate token + $Token = $this->validateToken( $PlainToken ); + + if( !$Token ) + { + return false; + } + + // Validate new password + if( !$this->_PasswordHasher->meetsRequirements( $NewPassword ) ) + { + $Errors = $this->_PasswordHasher->getValidationErrors( $NewPassword ); + throw new Exception( implode( ', ', $Errors ) ); + } + + // Find user + $User = $this->_UserRepository->findByEmail( $Token->getEmail() ); + + if( !$User ) + { + return false; + } + + // Update password + $User->setPasswordHash( $this->_PasswordHasher->hash( $NewPassword ) ); + $this->_UserRepository->update( $User ); + + // Delete the token + $this->_TokenRepository->deleteByToken( hash( 'sha256', $PlainToken ) ); + + return true; + } + + /** + * Clean up expired tokens + * + * @return int Number of tokens deleted + */ + public function cleanupExpiredTokens(): int + { + return $this->_TokenRepository->deleteExpired(); + } + + /** + * Send password reset email + * + * @param string $Email Recipient email + * @param string $PlainToken Plain text token to include in URL + * @throws Exception if email sending fails + */ + private function sendResetEmail( string $Email, string $PlainToken ): void + { + $ResetLink = $this->_ResetUrl . '?token=' . urlencode( $PlainToken ); + + $Subject = 'Password Reset Request'; + + $Body = << + + + + + + +You have requested to reset your password. Click the button below to proceed:
+ Reset Password +Or copy and paste this link into your browser:
+ +This link will expire in {$this->_TokenExpirationMinutes} minutes.
+If you did not request a password reset, please ignore this email.
+Your email content goes here.
' + ]; + + $content = $this->replacePlaceholders( $content, $replacements ); + + // Write the file + if( file_put_contents( $filePath, $content ) === false ) + { + $this->output->error( "Failed to create template file" ); + return false; + } + + return true; + } + + /** + * Replace placeholders in content + */ + private function replacePlaceholders( string $content, array $replacements ): string + { + foreach( $replacements as $key => $value ) + { + $content = str_replace( '{{' . $key . '}}', $value ?? '', $content ); + } + return $content; + } +} diff --git a/src/Cms/Cli/Commands/Generate/stubs/email.stub b/src/Cms/Cli/Commands/Generate/stubs/email.stub new file mode 100644 index 0000000..15a922d --- /dev/null +++ b/src/Cms/Cli/Commands/Generate/stubs/email.stub @@ -0,0 +1,61 @@ + + + + + +Hello,
+ + {{content}} + +Best regards,
Your Team
Estimated time: {$hours} hour" . + ($hours > 1 ? 's' : '') . + ($minutes > 0 ? " and {$minutes} minute" . ($minutes > 1 ? 's' : '') : '') . + "
"; + } + elseif( $minutes > 0 ) + { + $estimatedTime = "Estimated time: {$minutes} minute" . + ($minutes > 1 ? 's' : '') . + "
"; + } + } + + return << + + + + + +Estimated time: minutes
+ + + +``` + +2. Configure it in `config.yaml`: + +```yaml +maintenance: + custom_view: themes/my-theme/maintenance.php +``` + +Or specify it when creating the filter: + +```php +$filter = new MaintenanceFilter($manager, 'path/to/custom/view.php'); +``` + +## SEO Considerations + +The maintenance mode system is SEO-friendly: + +- Returns **HTTP 503 Service Unavailable** status (not 404 or 500) +- Includes **Retry-After** header to inform search engines when to return +- Prevents search engines from deindexing your site during temporary maintenance + +## Security + +- Localhost (127.0.0.1 and ::1) is allowed by default +- IP whitelist supports both exact matches and CIDR notation +- Handles proxied requests (checks X-Forwarded-For, X-Real-IP headers) +- Validates IP addresses before checking whitelist + +## Use Cases + +### Scheduled Maintenance +```bash +# Before maintenance window +neuron cms:maintenance:enable \ + --message="Scheduled maintenance: 2am-4am EST" \ + --retry-after=7200 \ + --allow-ip="192.168.1.0/24" + +# After maintenance +neuron cms:maintenance:disable +``` + +### Database Migrations +```bash +neuron cms:maintenance:enable \ + --message="Updating database schema" \ + --retry-after=600 + +# Run migrations +php artisan migrate + +# Disable maintenance +neuron cms:maintenance:disable --force +``` + +### Deployment Process +```bash +#!/bin/bash +# deploy.sh + +# Enable maintenance +neuron cms:maintenance:enable --force --retry-after=300 + +# Pull latest code +git pull origin main + +# Update dependencies +composer install --no-dev + +# Clear caches +neuron cms:cache:clear + +# Disable maintenance +neuron cms:maintenance:disable --force +``` + +## Troubleshooting + +### Maintenance mode won't enable +- Check write permissions on the application root directory +- Ensure `.maintenance.json` can be created + +### Can't access site after disabling +- Verify the `.maintenance.json` file was deleted +- Check for cached responses (clear browser cache) + +### IP whitelist not working +- Verify IP address format (use `cms:maintenance:status` to see current config) +- Check if behind a proxy (filter checks X-Forwarded-For header) +- Ensure CIDR notation is correct for subnets + +## API Reference + +### MaintenanceManager + +```php +// Create manager +$manager = new MaintenanceManager($basePath); + +// Enable maintenance mode +$manager->enable($message, $allowedIps, $retryAfter, $enabledBy); + +// Disable maintenance mode +$manager->disable(); + +// Check if enabled +$isEnabled = $manager->isEnabled(); + +// Get current status +$status = $manager->getStatus(); + +// Check if IP is allowed +$isAllowed = $manager->isIpAllowed('192.168.1.100'); + +// Get message +$message = $manager->getMessage(); + +// Get retry-after value +$retryAfter = $manager->getRetryAfter(); +``` + +### MaintenanceConfig + +```php +// Create from settings +$config = MaintenanceConfig::fromSettings($settingsSource); + +// Get configuration values +$message = $config->getDefaultMessage(); +$ips = $config->getAllowedIps(); +$retry = $config->getRetryAfter(); +$view = $config->getCustomView(); +``` + +### MaintenanceFilter + +```php +// Create filter +$filter = new MaintenanceFilter($manager, $customViewPath); + +// Register with router +$router->registerFilter('maintenance', $filter); +$router->addFilter('maintenance'); +``` + +## License + +MIT License - Part of the Neuron-PHP framework. diff --git a/src/Cms/Models/Category.php b/src/Cms/Models/Category.php new file mode 100644 index 0000000..6081cc1 --- /dev/null +++ b/src/Cms/Models/Category.php @@ -0,0 +1,186 @@ +_CreatedAt = new DateTimeImmutable(); + } + + /** + * Get category ID + */ + public function getId(): ?int + { + return $this->_Id; + } + + /** + * Set category ID + */ + public function setId( int $Id ): self + { + $this->_Id = $Id; + return $this; + } + + /** + * Get name + */ + public function getName(): string + { + return $this->_Name; + } + + /** + * Set name + */ + public function setName( string $Name ): self + { + $this->_Name = $Name; + return $this; + } + + /** + * Get slug + */ + public function getSlug(): string + { + return $this->_Slug; + } + + /** + * Set slug + */ + public function setSlug( string $Slug ): self + { + $this->_Slug = $Slug; + return $this; + } + + /** + * Get description + */ + public function getDescription(): ?string + { + return $this->_Description; + } + + /** + * Set description + */ + public function setDescription( ?string $Description ): self + { + $this->_Description = $Description; + return $this; + } + + /** + * Get created timestamp + */ + public function getCreatedAt(): ?DateTimeImmutable + { + return $this->_CreatedAt; + } + + /** + * Set created timestamp + */ + public function setCreatedAt( DateTimeImmutable $CreatedAt ): self + { + $this->_CreatedAt = $CreatedAt; + return $this; + } + + /** + * Get updated timestamp + */ + public function getUpdatedAt(): ?DateTimeImmutable + { + return $this->_UpdatedAt; + } + + /** + * Set updated timestamp + */ + public function setUpdatedAt( ?DateTimeImmutable $UpdatedAt ): self + { + $this->_UpdatedAt = $UpdatedAt; + return $this; + } + + /** + * Create Category from array data + * + * @param array $Data Associative array of category data + * @return Category + * @throws Exception + */ + public static function fromArray( array $Data ): Category + { + $Category = new self(); + + if( isset( $Data['id'] ) ) + { + $Category->setId( (int)$Data['id'] ); + } + + $Category->setName( $Data['name'] ?? '' ); + $Category->setSlug( $Data['slug'] ?? '' ); + $Category->setDescription( $Data['description'] ?? null ); + + if( isset( $Data['created_at'] ) && $Data['created_at'] ) + { + $Category->setCreatedAt( + is_string( $Data['created_at'] ) + ? new DateTimeImmutable( $Data['created_at'] ) + : $Data['created_at'] + ); + } + + if( isset( $Data['updated_at'] ) && $Data['updated_at'] ) + { + $Category->setUpdatedAt( + is_string( $Data['updated_at'] ) + ? new DateTimeImmutable( $Data['updated_at'] ) + : $Data['updated_at'] + ); + } + + return $Category; + } + + /** + * Convert category to array + * + * @return array + */ + public function toArray(): array + { + return [ + 'id' => $this->_Id, + 'name' => $this->_Name, + 'slug' => $this->_Slug, + 'description' => $this->_Description, + 'created_at' => $this->_CreatedAt?->format( 'Y-m-d H:i:s' ), + 'updated_at' => $this->_UpdatedAt?->format( 'Y-m-d H:i:s' ), + ]; + } +} diff --git a/src/Cms/Models/PasswordResetToken.php b/src/Cms/Models/PasswordResetToken.php new file mode 100644 index 0000000..4870d4a --- /dev/null +++ b/src/Cms/Models/PasswordResetToken.php @@ -0,0 +1,178 @@ +_Email = $Email; + $this->_Token = $Token; + $this->_CreatedAt = new DateTimeImmutable(); + $this->_ExpiresAt = $this->_CreatedAt->modify( "+{$ExpirationMinutes} minutes" ); + } + + /** + * Get token ID + */ + public function getId(): ?int + { + return $this->_Id; + } + + /** + * Set token ID + */ + public function setId( int $Id ): self + { + $this->_Id = $Id; + return $this; + } + + /** + * Get email address + */ + public function getEmail(): string + { + return $this->_Email; + } + + /** + * Set email address + */ + public function setEmail( string $Email ): self + { + $this->_Email = $Email; + return $this; + } + + /** + * Get token (hashed) + */ + public function getToken(): string + { + return $this->_Token; + } + + /** + * Set token (should be hashed before setting) + */ + public function setToken( string $Token ): self + { + $this->_Token = $Token; + return $this; + } + + /** + * Get created timestamp + */ + public function getCreatedAt(): DateTimeImmutable + { + return $this->_CreatedAt; + } + + /** + * Set created timestamp + */ + public function setCreatedAt( DateTimeImmutable $CreatedAt ): self + { + $this->_CreatedAt = $CreatedAt; + return $this; + } + + /** + * Get expiration timestamp + */ + public function getExpiresAt(): DateTimeImmutable + { + return $this->_ExpiresAt; + } + + /** + * Set expiration timestamp + */ + public function setExpiresAt( DateTimeImmutable $ExpiresAt ): self + { + $this->_ExpiresAt = $ExpiresAt; + return $this; + } + + /** + * Check if token has expired + */ + public function isExpired(): bool + { + return new DateTimeImmutable() > $this->_ExpiresAt; + } + + /** + * Create token from array data + */ + public static function fromArray( array $Data ): self + { + $Token = new self(); + + if( isset( $Data['id'] ) ) + { + $Token->setId( (int) $Data['id'] ); + } + + if( isset( $Data['email'] ) ) + { + $Token->setEmail( $Data['email'] ); + } + + if( isset( $Data['token'] ) ) + { + $Token->setToken( $Data['token'] ); + } + + if( isset( $Data['created_at'] ) ) + { + $Token->setCreatedAt( new DateTimeImmutable( $Data['created_at'] ) ); + } + + if( isset( $Data['expires_at'] ) ) + { + $Token->setExpiresAt( new DateTimeImmutable( $Data['expires_at'] ) ); + } + + return $Token; + } + + /** + * Convert token to array + */ + public function toArray(): array + { + return [ + 'id' => $this->_Id, + 'email' => $this->_Email, + 'token' => $this->_Token, + 'created_at' => $this->_CreatedAt->format( 'Y-m-d H:i:s' ), + 'expires_at' => $this->_ExpiresAt->format( 'Y-m-d H:i:s' ) + ]; + } +} diff --git a/src/Cms/Models/Post.php b/src/Cms/Models/Post.php new file mode 100644 index 0000000..fc8d027 --- /dev/null +++ b/src/Cms/Models/Post.php @@ -0,0 +1,516 @@ +_CreatedAt = new DateTimeImmutable(); + } + + /** + * Get post ID + */ + public function getId(): ?int + { + return $this->_Id; + } + + /** + * Set post ID + */ + public function setId( int $Id ): self + { + $this->_Id = $Id; + return $this; + } + + /** + * Get title + */ + public function getTitle(): string + { + return $this->_Title; + } + + /** + * Set title + */ + public function setTitle( string $Title ): self + { + $this->_Title = $Title; + return $this; + } + + /** + * Get slug + */ + public function getSlug(): string + { + return $this->_Slug; + } + + /** + * Set slug + */ + public function setSlug( string $Slug ): self + { + $this->_Slug = $Slug; + return $this; + } + + /** + * Get body content + */ + public function getBody(): string + { + return $this->_Body; + } + + /** + * Set body content + */ + public function setBody( string $Body ): self + { + $this->_Body = $Body; + return $this; + } + + /** + * Get excerpt + */ + public function getExcerpt(): ?string + { + return $this->_Excerpt; + } + + /** + * Set excerpt + */ + public function setExcerpt( ?string $Excerpt ): self + { + $this->_Excerpt = $Excerpt; + return $this; + } + + /** + * Get featured image + */ + public function getFeaturedImage(): ?string + { + return $this->_FeaturedImage; + } + + /** + * Set featured image + */ + public function setFeaturedImage( ?string $FeaturedImage ): self + { + $this->_FeaturedImage = $FeaturedImage; + return $this; + } + + /** + * Get author ID + */ + public function getAuthorId(): int + { + return $this->_AuthorId; + } + + /** + * Set author ID + */ + public function setAuthorId( int $AuthorId ): self + { + $this->_AuthorId = $AuthorId; + return $this; + } + + /** + * Get author + */ + public function getAuthor(): ?User + { + return $this->_Author; + } + + /** + * Set author + */ + public function setAuthor( ?User $Author ): self + { + $this->_Author = $Author; + if( $Author && $Author->getId() ) + { + $this->_AuthorId = $Author->getId(); + } + return $this; + } + + /** + * Get status + */ + public function getStatus(): string + { + return $this->_Status; + } + + /** + * Set status + */ + public function setStatus( string $Status ): self + { + $this->_Status = $Status; + return $this; + } + + /** + * Check if post is published + */ + public function isPublished(): bool + { + return $this->_Status === self::STATUS_PUBLISHED; + } + + /** + * Check if post is draft + */ + public function isDraft(): bool + { + return $this->_Status === self::STATUS_DRAFT; + } + + /** + * Check if post is scheduled + */ + public function isScheduled(): bool + { + return $this->_Status === self::STATUS_SCHEDULED; + } + + /** + * Get published date + */ + public function getPublishedAt(): ?DateTimeImmutable + { + return $this->_PublishedAt; + } + + /** + * Set published date + */ + public function setPublishedAt( ?DateTimeImmutable $PublishedAt ): self + { + $this->_PublishedAt = $PublishedAt; + return $this; + } + + /** + * Get view count + */ + public function getViewCount(): int + { + return $this->_ViewCount; + } + + /** + * Set view count + */ + public function setViewCount( int $ViewCount ): self + { + $this->_ViewCount = $ViewCount; + return $this; + } + + /** + * Increment view count + */ + public function incrementViewCount(): self + { + $this->_ViewCount++; + return $this; + } + + /** + * Get created timestamp + */ + public function getCreatedAt(): ?DateTimeImmutable + { + return $this->_CreatedAt; + } + + /** + * Set created timestamp + */ + public function setCreatedAt( DateTimeImmutable $CreatedAt ): self + { + $this->_CreatedAt = $CreatedAt; + return $this; + } + + /** + * Get updated timestamp + */ + public function getUpdatedAt(): ?DateTimeImmutable + { + return $this->_UpdatedAt; + } + + /** + * Set updated timestamp + */ + public function setUpdatedAt( ?DateTimeImmutable $UpdatedAt ): self + { + $this->_UpdatedAt = $UpdatedAt; + return $this; + } + + /** + * Get categories + * + * @return Category[] + */ + public function getCategories(): array + { + return $this->_Categories; + } + + /** + * Set categories + * + * @param Category[] $Categories + */ + public function setCategories( array $Categories ): self + { + $this->_Categories = $Categories; + return $this; + } + + /** + * Add category + */ + public function addCategory( Category $Category ): self + { + if( !$this->hasCategory( $Category ) ) + { + $this->_Categories[] = $Category; + } + return $this; + } + + /** + * Remove category + */ + public function removeCategory( Category $Category ): self + { + $this->_Categories = array_filter( + $this->_Categories, + fn( $c ) => $c->getId() !== $Category->getId() + ); + return $this; + } + + /** + * Check if post has category + */ + public function hasCategory( Category $Category ): bool + { + foreach( $this->_Categories as $c ) + { + if( $c->getId() === $Category->getId() ) + { + return true; + } + } + return false; + } + + /** + * Get tags + * + * @return Tag[] + */ + public function getTags(): array + { + return $this->_Tags; + } + + /** + * Set tags + * + * @param Tag[] $Tags + */ + public function setTags( array $Tags ): self + { + $this->_Tags = $Tags; + return $this; + } + + /** + * Add tag + */ + public function addTag( Tag $Tag ): self + { + if( !$this->hasTag( $Tag ) ) + { + $this->_Tags[] = $Tag; + } + return $this; + } + + /** + * Remove tag + */ + public function removeTag( Tag $Tag ): self + { + $this->_Tags = array_filter( + $this->_Tags, + fn( $t ) => $t->getId() !== $Tag->getId() + ); + return $this; + } + + /** + * Check if post has tag + */ + public function hasTag( Tag $Tag ): bool + { + foreach( $this->_Tags as $t ) + { + if( $t->getId() === $Tag->getId() ) + { + return true; + } + } + return false; + } + + /** + * Create Post from array data + * + * @param array $Data Associative array of post data + * @return Post + * @throws Exception + */ + public static function fromArray( array $Data ): Post + { + $Post = new self(); + + if( isset( $Data['id'] ) ) + { + $Post->setId( (int)$Data['id'] ); + } + + $Post->setTitle( $Data['title'] ?? '' ); + $Post->setSlug( $Data['slug'] ?? '' ); + $Post->setBody( $Data['body'] ?? '' ); + $Post->setExcerpt( $Data['excerpt'] ?? null ); + $Post->setFeaturedImage( $Data['featured_image'] ?? null ); + $Post->setAuthorId( (int)($Data['author_id'] ?? 0) ); + $Post->setStatus( $Data['status'] ?? self::STATUS_DRAFT ); + $Post->setViewCount( (int)($Data['view_count'] ?? 0) ); + + if( isset( $Data['published_at'] ) && $Data['published_at'] ) + { + $Post->setPublishedAt( + is_string( $Data['published_at'] ) + ? new DateTimeImmutable( $Data['published_at'] ) + : $Data['published_at'] + ); + } + + if( isset( $Data['created_at'] ) && $Data['created_at'] ) + { + $Post->setCreatedAt( + is_string( $Data['created_at'] ) + ? new DateTimeImmutable( $Data['created_at'] ) + : $Data['created_at'] + ); + } + + if( isset( $Data['updated_at'] ) && $Data['updated_at'] ) + { + $Post->setUpdatedAt( + is_string( $Data['updated_at'] ) + ? new DateTimeImmutable( $Data['updated_at'] ) + : $Data['updated_at'] + ); + } + + // Relationships + if( isset( $Data['author'] ) && $Data['author'] instanceof User ) + { + $Post->setAuthor( $Data['author'] ); + } + + if( isset( $Data['categories'] ) && is_array( $Data['categories'] ) ) + { + $Post->setCategories( $Data['categories'] ); + } + + if( isset( $Data['tags'] ) && is_array( $Data['tags'] ) ) + { + $Post->setTags( $Data['tags'] ); + } + + return $Post; + } + + /** + * Convert post to array + * + * @return array + */ + public function toArray(): array + { + return [ + 'id' => $this->_Id, + 'title' => $this->_Title, + 'slug' => $this->_Slug, + 'body' => $this->_Body, + 'excerpt' => $this->_Excerpt, + 'featured_image' => $this->_FeaturedImage, + 'author_id' => $this->_AuthorId, + 'status' => $this->_Status, + 'published_at' => $this->_PublishedAt?->format( 'Y-m-d H:i:s' ), + 'view_count' => $this->_ViewCount, + 'created_at' => $this->_CreatedAt?->format( 'Y-m-d H:i:s' ), + 'updated_at' => $this->_UpdatedAt?->format( 'Y-m-d H:i:s' ), + ]; + } +} diff --git a/src/Cms/Models/Tag.php b/src/Cms/Models/Tag.php new file mode 100644 index 0000000..f1b3d3b --- /dev/null +++ b/src/Cms/Models/Tag.php @@ -0,0 +1,166 @@ +_CreatedAt = new DateTimeImmutable(); + } + + /** + * Get tag ID + */ + public function getId(): ?int + { + return $this->_Id; + } + + /** + * Set tag ID + */ + public function setId( int $Id ): self + { + $this->_Id = $Id; + return $this; + } + + /** + * Get name + */ + public function getName(): string + { + return $this->_Name; + } + + /** + * Set name + */ + public function setName( string $Name ): self + { + $this->_Name = $Name; + return $this; + } + + /** + * Get slug + */ + public function getSlug(): string + { + return $this->_Slug; + } + + /** + * Set slug + */ + public function setSlug( string $Slug ): self + { + $this->_Slug = $Slug; + return $this; + } + + /** + * Get created timestamp + */ + public function getCreatedAt(): ?DateTimeImmutable + { + return $this->_CreatedAt; + } + + /** + * Set created timestamp + */ + public function setCreatedAt( DateTimeImmutable $CreatedAt ): self + { + $this->_CreatedAt = $CreatedAt; + return $this; + } + + /** + * Get updated timestamp + */ + public function getUpdatedAt(): ?DateTimeImmutable + { + return $this->_UpdatedAt; + } + + /** + * Set updated timestamp + */ + public function setUpdatedAt( ?DateTimeImmutable $UpdatedAt ): self + { + $this->_UpdatedAt = $UpdatedAt; + return $this; + } + + /** + * Create Tag from array data + * + * @param array $Data Associative array of tag data + * @return Tag + * @throws Exception + */ + public static function fromArray( array $Data ): Tag + { + $Tag = new self(); + + if( isset( $Data['id'] ) ) + { + $Tag->setId( (int)$Data['id'] ); + } + + $Tag->setName( $Data['name'] ?? '' ); + $Tag->setSlug( $Data['slug'] ?? '' ); + + if( isset( $Data['created_at'] ) && $Data['created_at'] ) + { + $Tag->setCreatedAt( + is_string( $Data['created_at'] ) + ? new DateTimeImmutable( $Data['created_at'] ) + : $Data['created_at'] + ); + } + + if( isset( $Data['updated_at'] ) && $Data['updated_at'] ) + { + $Tag->setUpdatedAt( + is_string( $Data['updated_at'] ) + ? new DateTimeImmutable( $Data['updated_at'] ) + : $Data['updated_at'] + ); + } + + return $Tag; + } + + /** + * Convert tag to array + * + * @return array + */ + public function toArray(): array + { + return [ + 'id' => $this->_Id, + 'name' => $this->_Name, + 'slug' => $this->_Slug, + 'created_at' => $this->_CreatedAt?->format( 'Y-m-d H:i:s' ), + 'updated_at' => $this->_UpdatedAt?->format( 'Y-m-d H:i:s' ), + ]; + } +} diff --git a/src/Cms/Models/User.php b/src/Cms/Models/User.php new file mode 100644 index 0000000..3756da2 --- /dev/null +++ b/src/Cms/Models/User.php @@ -0,0 +1,459 @@ +_CreatedAt = new DateTimeImmutable(); + } + + /** + * Get user ID + */ + public function getId(): ?int + { + return $this->_Id; + } + + /** + * Set user ID + */ + public function setId( int $Id ): self + { + $this->_Id = $Id; + return $this; + } + + /** + * Get username + */ + public function getUsername(): string + { + return $this->_Username; + } + + /** + * Set username + */ + public function setUsername( string $Username ): self + { + $this->_Username = $Username; + return $this; + } + + /** + * Get email + */ + public function getEmail(): string + { + return $this->_Email; + } + + /** + * Set email + */ + public function setEmail( string $Email ): self + { + $this->_Email = $Email; + return $this; + } + + /** + * Get password hash + */ + public function getPasswordHash(): string + { + return $this->_PasswordHash; + } + + /** + * Set password hash + */ + public function setPasswordHash( string $PasswordHash ): self + { + $this->_PasswordHash = $PasswordHash; + return $this; + } + + /** + * Get user role + */ + public function getRole(): string + { + return $this->_Role; + } + + /** + * Set user role + */ + public function setRole( string $Role ): self + { + $this->_Role = $Role; + return $this; + } + + /** + * Check if user is admin + */ + public function isAdmin(): bool + { + return $this->_Role === self::ROLE_ADMIN; + } + + /** + * Check if user is editor + */ + public function isEditor(): bool + { + return $this->_Role === self::ROLE_EDITOR; + } + + /** + * Check if user is author + */ + public function isAuthor(): bool + { + return $this->_Role === self::ROLE_AUTHOR; + } + + /** + * Get user status + */ + public function getStatus(): string + { + return $this->_Status; + } + + /** + * Set user status + */ + public function setStatus( string $Status ): self + { + $this->_Status = $Status; + return $this; + } + + /** + * Check if user is active + */ + public function isActive(): bool + { + return $this->_Status === self::STATUS_ACTIVE; + } + + /** + * Check if user is suspended + */ + public function isSuspended(): bool + { + return $this->_Status === self::STATUS_SUSPENDED; + } + + /** + * Check if email is verified + */ + public function isEmailVerified(): bool + { + return $this->_EmailVerified; + } + + /** + * Set email verified status + */ + public function setEmailVerified( bool $EmailVerified ): self + { + $this->_EmailVerified = $EmailVerified; + return $this; + } + + /** + * Get remember token + */ + public function getRememberToken(): ?string + { + return $this->_RememberToken; + } + + /** + * Set remember token + */ + public function setRememberToken( ?string $RememberToken ): self + { + $this->_RememberToken = $RememberToken; + return $this; + } + + /** + * Get two-factor secret + */ + public function getTwoFactorSecret(): ?string + { + return $this->_TwoFactorSecret; + } + + /** + * Set two-factor secret + */ + public function setTwoFactorSecret( ?string $TwoFactorSecret ): self + { + $this->_TwoFactorSecret = $TwoFactorSecret; + return $this; + } + + /** + * Check if two-factor authentication is enabled + */ + public function hasTwoFactorEnabled(): bool + { + return $this->_TwoFactorSecret !== null; + } + + /** + * Get two-factor recovery codes + */ + public function getTwoFactorRecoveryCodes(): ?array + { + return $this->_TwoFactorRecoveryCodes; + } + + /** + * Set two-factor recovery codes + */ + public function setTwoFactorRecoveryCodes( ?array $TwoFactorRecoveryCodes ): self + { + $this->_TwoFactorRecoveryCodes = $TwoFactorRecoveryCodes; + return $this; + } + + /** + * Get failed login attempts count + */ + public function getFailedLoginAttempts(): int + { + return $this->_FailedLoginAttempts; + } + + /** + * Set failed login attempts count + */ + public function setFailedLoginAttempts( int $FailedLoginAttempts ): self + { + $this->_FailedLoginAttempts = $FailedLoginAttempts; + return $this; + } + + /** + * Increment failed login attempts + */ + public function incrementFailedLoginAttempts(): self + { + $this->_FailedLoginAttempts++; + return $this; + } + + /** + * Reset failed login attempts + */ + public function resetFailedLoginAttempts(): self + { + $this->_FailedLoginAttempts = 0; + $this->_LockedUntil = null; + return $this; + } + + /** + * Get locked until timestamp + */ + public function getLockedUntil(): ?DateTimeImmutable + { + return $this->_LockedUntil; + } + + /** + * Set locked until timestamp + */ + public function setLockedUntil( ?DateTimeImmutable $LockedUntil ): self + { + $this->_LockedUntil = $LockedUntil; + return $this; + } + + /** + * Check if user is locked out + */ + public function isLockedOut(): bool + { + if( $this->_LockedUntil === null ) + { + return false; + } + + return $this->_LockedUntil > new DateTimeImmutable(); + } + + /** + * Get created at timestamp + */ + public function getCreatedAt(): ?DateTimeImmutable + { + return $this->_CreatedAt; + } + + /** + * Set created at timestamp + */ + public function setCreatedAt( DateTimeImmutable $CreatedAt ): self + { + $this->_CreatedAt = $CreatedAt; + return $this; + } + + /** + * Get updated at timestamp + */ + public function getUpdatedAt(): ?DateTimeImmutable + { + return $this->_UpdatedAt; + } + + /** + * Set updated at timestamp + */ + public function setUpdatedAt( ?DateTimeImmutable $UpdatedAt ): self + { + $this->_UpdatedAt = $UpdatedAt; + return $this; + } + + /** + * Get last login at timestamp + */ + public function getLastLoginAt(): ?DateTimeImmutable + { + return $this->_LastLoginAt; + } + + /** + * Set last login at timestamp + */ + public function setLastLoginAt( ?DateTimeImmutable $LastLoginAt ): self + { + $this->_LastLoginAt = $LastLoginAt; + return $this; + } + + /** + * Convert user to array + */ + public function toArray(): array + { + return [ + 'id' => $this->_Id, + 'username' => $this->_Username, + 'email' => $this->_Email, + 'password_hash' => $this->_PasswordHash, + 'role' => $this->_Role, + 'status' => $this->_Status, + 'email_verified' => $this->_EmailVerified, + 'remember_token' => $this->_RememberToken, + 'two_factor_secret' => $this->_TwoFactorSecret, + 'two_factor_recovery_codes' => $this->_TwoFactorRecoveryCodes ? json_encode( $this->_TwoFactorRecoveryCodes ) : null, + 'failed_login_attempts' => $this->_FailedLoginAttempts, + 'locked_until' => $this->_LockedUntil?->format( 'Y-m-d H:i:s' ), + 'created_at' => $this->_CreatedAt?->format( 'Y-m-d H:i:s' ), + 'updated_at' => $this->_UpdatedAt?->format( 'Y-m-d H:i:s' ), + 'last_login_at' => $this->_LastLoginAt?->format( 'Y-m-d H:i:s' ) + ]; + } + + /** + * Create user from array + */ + public static function fromArray( array $Data ): self + { + $User = new self(); + + if( isset( $Data['id'] ) ) + { + $User->setId( $Data['id'] ); + } + + $User->setUsername( $Data['username'] ); + $User->setEmail( $Data['email'] ); + $User->setPasswordHash( $Data['password_hash'] ); + $User->setRole( $Data['role'] ?? self::ROLE_SUBSCRIBER ); + $User->setStatus( $Data['status'] ?? self::STATUS_ACTIVE ); + $User->setEmailVerified( $Data['email_verified'] ?? false ); + $User->setRememberToken( $Data['remember_token'] ?? null ); + $User->setTwoFactorSecret( $Data['two_factor_secret'] ?? null ); + + if( isset( $Data['two_factor_recovery_codes'] ) && $Data['two_factor_recovery_codes'] ) + { + $User->setTwoFactorRecoveryCodes( json_decode( $Data['two_factor_recovery_codes'], true ) ); + } + + $User->setFailedLoginAttempts( $Data['failed_login_attempts'] ?? 0 ); + + if( isset( $Data['locked_until'] ) && $Data['locked_until'] ) + { + $User->setLockedUntil( new DateTimeImmutable( $Data['locked_until'] ) ); + } + + if( isset( $Data['created_at'] ) && $Data['created_at'] ) + { + $User->setCreatedAt( new DateTimeImmutable( $Data['created_at'] ) ); + } + + if( isset( $Data['updated_at'] ) && $Data['updated_at'] ) + { + $User->setUpdatedAt( new DateTimeImmutable( $Data['updated_at'] ) ); + } + + if( isset( $Data['last_login_at'] ) && $Data['last_login_at'] ) + { + $User->setLastLoginAt( new DateTimeImmutable( $Data['last_login_at'] ) ); + } + + return $User; + } +} diff --git a/src/Cms/Repositories/DatabaseCategoryRepository.php b/src/Cms/Repositories/DatabaseCategoryRepository.php new file mode 100644 index 0000000..7dcecb4 --- /dev/null +++ b/src/Cms/Repositories/DatabaseCategoryRepository.php @@ -0,0 +1,234 @@ + "sqlite:{$DatabaseConfig['name']}", + 'mysql' => sprintf( + "mysql:host=%s;port=%s;dbname=%s;charset=%s", + $DatabaseConfig['host'] ?? 'localhost', + $DatabaseConfig['port'] ?? 3306, + $DatabaseConfig['name'], + $DatabaseConfig['charset'] ?? 'utf8mb4' + ), + 'pgsql' => sprintf( + "pgsql:host=%s;port=%s;dbname=%s", + $DatabaseConfig['host'] ?? 'localhost', + $DatabaseConfig['port'] ?? 5432, + $DatabaseConfig['name'] + ), + default => throw new Exception( "Unsupported database adapter: $adapter" ) + }; + + $this->_PDO = new PDO( + $dsn, + $DatabaseConfig['user'] ?? null, + $DatabaseConfig['pass'] ?? null, + [ + PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION, + PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC + ] + ); + } + + /** + * Find category by ID + */ + public function findById( int $Id ): ?Category + { + $stmt = $this->_PDO->prepare( "SELECT * FROM categories WHERE id = ? LIMIT 1" ); + $stmt->execute( [ $Id ] ); + + $row = $stmt->fetch(); + + return $row ? Category::fromArray( $row ) : null; + } + + /** + * Find category by slug + */ + public function findBySlug( string $Slug ): ?Category + { + $stmt = $this->_PDO->prepare( "SELECT * FROM categories WHERE slug = ? LIMIT 1" ); + $stmt->execute( [ $Slug ] ); + + $row = $stmt->fetch(); + + return $row ? Category::fromArray( $row ) : null; + } + + /** + * Find category by name + */ + public function findByName( string $Name ): ?Category + { + $stmt = $this->_PDO->prepare( "SELECT * FROM categories WHERE name = ? LIMIT 1" ); + $stmt->execute( [ $Name ] ); + + $row = $stmt->fetch(); + + return $row ? Category::fromArray( $row ) : null; + } + + /** + * Create a new category + */ + public function create( Category $Category ): Category + { + // Check for duplicate slug + if( $this->findBySlug( $Category->getSlug() ) ) + { + throw new Exception( 'Slug already exists' ); + } + + // Check for duplicate name + if( $this->findByName( $Category->getName() ) ) + { + throw new Exception( 'Category name already exists' ); + } + + $stmt = $this->_PDO->prepare( + "INSERT INTO categories (name, slug, description, created_at, updated_at) + VALUES (?, ?, ?, ?, ?)" + ); + + $stmt->execute([ + $Category->getName(), + $Category->getSlug(), + $Category->getDescription(), + $Category->getCreatedAt()->format( 'Y-m-d H:i:s' ), + (new DateTimeImmutable())->format( 'Y-m-d H:i:s' ) + ]); + + $Category->setId( (int)$this->_PDO->lastInsertId() ); + + return $Category; + } + + /** + * Update an existing category + */ + public function update( Category $Category ): bool + { + if( !$Category->getId() ) + { + return false; + } + + // Check for duplicate slug (excluding current category) + $ExistingBySlug = $this->findBySlug( $Category->getSlug() ); + if( $ExistingBySlug && $ExistingBySlug->getId() !== $Category->getId() ) + { + throw new Exception( 'Slug already exists' ); + } + + // Check for duplicate name (excluding current category) + $ExistingByName = $this->findByName( $Category->getName() ); + if( $ExistingByName && $ExistingByName->getId() !== $Category->getId() ) + { + throw new Exception( 'Category name already exists' ); + } + + $stmt = $this->_PDO->prepare( + "UPDATE categories SET + name = ?, + slug = ?, + description = ?, + updated_at = ? + WHERE id = ?" + ); + + return $stmt->execute([ + $Category->getName(), + $Category->getSlug(), + $Category->getDescription(), + (new DateTimeImmutable())->format( 'Y-m-d H:i:s' ), + $Category->getId() + ]); + } + + /** + * Delete a category + */ + public function delete( int $Id ): bool + { + // Foreign key constraints will handle cascade delete of post relationships + $stmt = $this->_PDO->prepare( "DELETE FROM categories WHERE id = ?" ); + $stmt->execute( [ $Id ] ); + + return $stmt->rowCount() > 0; + } + + /** + * Get all categories + */ + public function all(): array + { + $stmt = $this->_PDO->query( "SELECT * FROM categories ORDER BY name ASC" ); + $rows = $stmt->fetchAll(); + + return array_map( fn( $row ) => Category::fromArray( $row ), $rows ); + } + + /** + * Count total categories + */ + public function count(): int + { + $stmt = $this->_PDO->query( "SELECT COUNT(*) as total FROM categories" ); + $row = $stmt->fetch(); + + return (int)$row['total']; + } + + /** + * Get categories with post count + */ + public function allWithPostCount(): array + { + $stmt = $this->_PDO->query( + "SELECT c.*, COUNT(pc.post_id) as post_count + FROM categories c + LEFT JOIN post_categories pc ON c.id = pc.category_id + GROUP BY c.id + ORDER BY c.name ASC" + ); + + $rows = $stmt->fetchAll(); + + return array_map( function( $row ) { + $category = Category::fromArray( $row ); + return [ + 'category' => $category, + 'post_count' => (int)$row['post_count'] + ]; + }, $rows ); + } +} diff --git a/src/Cms/Repositories/DatabasePasswordResetTokenRepository.php b/src/Cms/Repositories/DatabasePasswordResetTokenRepository.php new file mode 100644 index 0000000..83480f3 --- /dev/null +++ b/src/Cms/Repositories/DatabasePasswordResetTokenRepository.php @@ -0,0 +1,144 @@ + "sqlite:{$DatabaseConfig['name']}", + 'mysql' => sprintf( + "mysql:host=%s;port=%s;dbname=%s;charset=%s", + $DatabaseConfig['host'] ?? 'localhost', + $DatabaseConfig['port'] ?? 3306, + $DatabaseConfig['name'], + $DatabaseConfig['charset'] ?? 'utf8mb4' + ), + 'pgsql' => sprintf( + "pgsql:host=%s;port=%s;dbname=%s", + $DatabaseConfig['host'] ?? 'localhost', + $DatabaseConfig['port'] ?? 5432, + $DatabaseConfig['name'] + ), + default => throw new Exception( "Unsupported database adapter: $adapter" ) + }; + + $this->_PDO = new PDO( + $dsn, + $DatabaseConfig['user'] ?? null, + $DatabaseConfig['pass'] ?? null, + [ + PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION, + PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC + ] + ); + } + + /** + * Create a new password reset token + */ + public function create( PasswordResetToken $Token ): PasswordResetToken + { + $stmt = $this->_PDO->prepare( + "INSERT INTO password_reset_tokens (email, token, created_at, expires_at) + VALUES (?, ?, ?, ?)" + ); + + $stmt->execute([ + $Token->getEmail(), + $Token->getToken(), + $Token->getCreatedAt()->format( 'Y-m-d H:i:s' ), + $Token->getExpiresAt()->format( 'Y-m-d H:i:s' ) + ]); + + $Token->setId( (int) $this->_PDO->lastInsertId() ); + + return $Token; + } + + /** + * Find a token by its hashed value + */ + public function findByToken( string $Token ): ?PasswordResetToken + { + $stmt = $this->_PDO->prepare( "SELECT * FROM password_reset_tokens WHERE token = ? LIMIT 1" ); + $stmt->execute( [ $Token ] ); + + $row = $stmt->fetch(); + + return $row ? $this->mapRowToToken( $row ) : null; + } + + /** + * Delete all tokens for a given email address + */ + public function deleteByEmail( string $Email ): int + { + $stmt = $this->_PDO->prepare( "DELETE FROM password_reset_tokens WHERE email = ?" ); + $stmt->execute( [ $Email ] ); + + return $stmt->rowCount(); + } + + /** + * Delete a specific token by its hashed value + */ + public function deleteByToken( string $Token ): bool + { + $stmt = $this->_PDO->prepare( "DELETE FROM password_reset_tokens WHERE token = ?" ); + $stmt->execute( [ $Token ] ); + + return $stmt->rowCount() > 0; + } + + /** + * Delete all expired tokens + */ + public function deleteExpired(): int + { + $now = (new DateTimeImmutable())->format( 'Y-m-d H:i:s' ); + + $stmt = $this->_PDO->prepare( "DELETE FROM password_reset_tokens WHERE expires_at < ?" ); + $stmt->execute( [ $now ] ); + + return $stmt->rowCount(); + } + + /** + * Map database row to PasswordResetToken object + */ + private function mapRowToToken( array $Row ): PasswordResetToken + { + return PasswordResetToken::fromArray([ + 'id' => $Row['id'], + 'email' => $Row['email'], + 'token' => $Row['token'], + 'created_at' => $Row['created_at'], + 'expires_at' => $Row['expires_at'] + ]); + } +} diff --git a/src/Cms/Repositories/DatabasePostRepository.php b/src/Cms/Repositories/DatabasePostRepository.php new file mode 100644 index 0000000..c457518 --- /dev/null +++ b/src/Cms/Repositories/DatabasePostRepository.php @@ -0,0 +1,532 @@ + "sqlite:{$DatabaseConfig['name']}", + 'mysql' => sprintf( + "mysql:host=%s;port=%s;dbname=%s;charset=%s", + $DatabaseConfig['host'] ?? 'localhost', + $DatabaseConfig['port'] ?? 3306, + $DatabaseConfig['name'], + $DatabaseConfig['charset'] ?? 'utf8mb4' + ), + 'pgsql' => sprintf( + "pgsql:host=%s;port=%s;dbname=%s", + $DatabaseConfig['host'] ?? 'localhost', + $DatabaseConfig['port'] ?? 5432, + $DatabaseConfig['name'] + ), + default => throw new Exception( "Unsupported database adapter: $adapter" ) + }; + + $this->_PDO = new PDO( + $dsn, + $DatabaseConfig['user'] ?? null, + $DatabaseConfig['pass'] ?? null, + [ + PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION, + PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC + ] + ); + } + + /** + * Find post by ID + */ + public function findById( int $Id ): ?Post + { + $stmt = $this->_PDO->prepare( "SELECT * FROM posts WHERE id = ? LIMIT 1" ); + $stmt->execute( [ $Id ] ); + + $row = $stmt->fetch(); + + if( !$row ) + { + return null; + } + + return $this->mapRowToPost( $row ); + } + + /** + * Find post by slug + */ + public function findBySlug( string $Slug ): ?Post + { + $stmt = $this->_PDO->prepare( "SELECT * FROM posts WHERE slug = ? LIMIT 1" ); + $stmt->execute( [ $Slug ] ); + + $row = $stmt->fetch(); + + if( !$row ) + { + return null; + } + + return $this->mapRowToPost( $row ); + } + + /** + * Create a new post + */ + public function create( Post $Post ): Post + { + // Check for duplicate slug + if( $this->findBySlug( $Post->getSlug() ) ) + { + throw new Exception( 'Slug already exists' ); + } + + $stmt = $this->_PDO->prepare( + "INSERT INTO posts ( + title, slug, body, excerpt, featured_image, author_id, + status, published_at, view_count, created_at, updated_at + ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)" + ); + + $stmt->execute([ + $Post->getTitle(), + $Post->getSlug(), + $Post->getBody(), + $Post->getExcerpt(), + $Post->getFeaturedImage(), + $Post->getAuthorId(), + $Post->getStatus(), + $Post->getPublishedAt() ? $Post->getPublishedAt()->format( 'Y-m-d H:i:s' ) : null, + $Post->getViewCount(), + $Post->getCreatedAt()->format( 'Y-m-d H:i:s' ), + (new DateTimeImmutable())->format( 'Y-m-d H:i:s' ) + ]); + + $Post->setId( (int)$this->_PDO->lastInsertId() ); + + // Handle categories + if( count( $Post->getCategories() ) > 0 ) + { + $categoryIds = array_map( fn( $c ) => $c->getId(), $Post->getCategories() ); + $this->attachCategories( $Post->getId(), $categoryIds ); + } + + // Handle tags + if( count( $Post->getTags() ) > 0 ) + { + $tagIds = array_map( fn( $t ) => $t->getId(), $Post->getTags() ); + $this->attachTags( $Post->getId(), $tagIds ); + } + + return $Post; + } + + /** + * Update an existing post + */ + public function update( Post $Post ): bool + { + if( !$Post->getId() ) + { + return false; + } + + // Check for duplicate slug (excluding current post) + $ExistingBySlug = $this->findBySlug( $Post->getSlug() ); + if( $ExistingBySlug && $ExistingBySlug->getId() !== $Post->getId() ) + { + throw new Exception( 'Slug already exists' ); + } + + $stmt = $this->_PDO->prepare( + "UPDATE posts SET + title = ?, + slug = ?, + body = ?, + excerpt = ?, + featured_image = ?, + author_id = ?, + status = ?, + published_at = ?, + view_count = ?, + updated_at = ? + WHERE id = ?" + ); + + $result = $stmt->execute([ + $Post->getTitle(), + $Post->getSlug(), + $Post->getBody(), + $Post->getExcerpt(), + $Post->getFeaturedImage(), + $Post->getAuthorId(), + $Post->getStatus(), + $Post->getPublishedAt() ? $Post->getPublishedAt()->format( 'Y-m-d H:i:s' ) : null, + $Post->getViewCount(), + (new DateTimeImmutable())->format( 'Y-m-d H:i:s' ), + $Post->getId() + ]); + + // Update categories + $this->detachCategories( $Post->getId() ); + if( count( $Post->getCategories() ) > 0 ) + { + $categoryIds = array_map( fn( $c ) => $c->getId(), $Post->getCategories() ); + $this->attachCategories( $Post->getId(), $categoryIds ); + } + + // Update tags + $this->detachTags( $Post->getId() ); + if( count( $Post->getTags() ) > 0 ) + { + $tagIds = array_map( fn( $t ) => $t->getId(), $Post->getTags() ); + $this->attachTags( $Post->getId(), $tagIds ); + } + + return $result; + } + + /** + * Delete a post + */ + public function delete( int $Id ): bool + { + // Foreign key constraints will handle cascade delete of relationships + $stmt = $this->_PDO->prepare( "DELETE FROM posts WHERE id = ?" ); + $stmt->execute( [ $Id ] ); + + return $stmt->rowCount() > 0; + } + + /** + * Get all posts + */ + public function all( ?string $Status = null, int $Limit = 0, int $Offset = 0 ): array + { + $sql = "SELECT * FROM posts"; + $params = []; + + if( $Status ) + { + $sql .= " WHERE status = ?"; + $params[] = $Status; + } + + $sql .= " ORDER BY created_at DESC"; + + if( $Limit > 0 ) + { + $sql .= " LIMIT ? OFFSET ?"; + $params[] = $Limit; + $params[] = $Offset; + } + + $stmt = $this->_PDO->prepare( $sql ); + $stmt->execute( $params ); + $rows = $stmt->fetchAll(); + + return array_map( [ $this, 'mapRowToPost' ], $rows ); + } + + /** + * Get posts by author + */ + public function getByAuthor( int $AuthorId, ?string $Status = null ): array + { + $sql = "SELECT * FROM posts WHERE author_id = ?"; + $params = [ $AuthorId ]; + + if( $Status ) + { + $sql .= " AND status = ?"; + $params[] = $Status; + } + + $sql .= " ORDER BY created_at DESC"; + + $stmt = $this->_PDO->prepare( $sql ); + $stmt->execute( $params ); + $rows = $stmt->fetchAll(); + + return array_map( [ $this, 'mapRowToPost' ], $rows ); + } + + /** + * Get posts by category + */ + public function getByCategory( int $CategoryId, ?string $Status = null ): array + { + $sql = "SELECT p.* FROM posts p + INNER JOIN post_categories pc ON p.id = pc.post_id + WHERE pc.category_id = ?"; + $params = [ $CategoryId ]; + + if( $Status ) + { + $sql .= " AND p.status = ?"; + $params[] = $Status; + } + + $sql .= " ORDER BY p.created_at DESC"; + + $stmt = $this->_PDO->prepare( $sql ); + $stmt->execute( $params ); + $rows = $stmt->fetchAll(); + + return array_map( [ $this, 'mapRowToPost' ], $rows ); + } + + /** + * Get posts by tag + */ + public function getByTag( int $TagId, ?string $Status = null ): array + { + $sql = "SELECT p.* FROM posts p + INNER JOIN post_tags pt ON p.id = pt.post_id + WHERE pt.tag_id = ?"; + $params = [ $TagId ]; + + if( $Status ) + { + $sql .= " AND p.status = ?"; + $params[] = $Status; + } + + $sql .= " ORDER BY p.created_at DESC"; + + $stmt = $this->_PDO->prepare( $sql ); + $stmt->execute( $params ); + $rows = $stmt->fetchAll(); + + return array_map( [ $this, 'mapRowToPost' ], $rows ); + } + + /** + * Get published posts + */ + public function getPublished( int $Limit = 0, int $Offset = 0 ): array + { + return $this->all( Post::STATUS_PUBLISHED, $Limit, $Offset ); + } + + /** + * Get draft posts + */ + public function getDrafts(): array + { + return $this->all( Post::STATUS_DRAFT ); + } + + /** + * Get scheduled posts + */ + public function getScheduled(): array + { + return $this->all( Post::STATUS_SCHEDULED ); + } + + /** + * Count total posts + */ + public function count( ?string $Status = null ): int + { + $sql = "SELECT COUNT(*) as total FROM posts"; + $params = []; + + if( $Status ) + { + $sql .= " WHERE status = ?"; + $params[] = $Status; + } + + $stmt = $this->_PDO->prepare( $sql ); + $stmt->execute( $params ); + $row = $stmt->fetch(); + + return (int)$row['total']; + } + + /** + * Increment post view count + */ + public function incrementViewCount( int $Id ): bool + { + $stmt = $this->_PDO->prepare( "UPDATE posts SET view_count = view_count + 1 WHERE id = ?" ); + $stmt->execute( [ $Id ] ); + + return $stmt->rowCount() > 0; + } + + /** + * Attach categories to post + */ + public function attachCategories( int $PostId, array $CategoryIds ): bool + { + if( empty( $CategoryIds ) ) + { + return true; + } + + $stmt = $this->_PDO->prepare( + "INSERT INTO post_categories (post_id, category_id, created_at) VALUES (?, ?, ?)" + ); + + foreach( $CategoryIds as $categoryId ) + { + $stmt->execute([ + $PostId, + $categoryId, + (new DateTimeImmutable())->format( 'Y-m-d H:i:s' ) + ]); + } + + return true; + } + + /** + * Detach all categories from post + */ + public function detachCategories( int $PostId ): bool + { + $stmt = $this->_PDO->prepare( "DELETE FROM post_categories WHERE post_id = ?" ); + $stmt->execute( [ $PostId ] ); + + return true; + } + + /** + * Attach tags to post + */ + public function attachTags( int $PostId, array $TagIds ): bool + { + if( empty( $TagIds ) ) + { + return true; + } + + $stmt = $this->_PDO->prepare( + "INSERT INTO post_tags (post_id, tag_id, created_at) VALUES (?, ?, ?)" + ); + + foreach( $TagIds as $tagId ) + { + $stmt->execute([ + $PostId, + $tagId, + (new DateTimeImmutable())->format( 'Y-m-d H:i:s' ) + ]); + } + + return true; + } + + /** + * Detach all tags from post + */ + public function detachTags( int $PostId ): bool + { + $stmt = $this->_PDO->prepare( "DELETE FROM post_tags WHERE post_id = ?" ); + $stmt->execute( [ $PostId ] ); + + return true; + } + + /** + * Map database row to Post object + * + * @param array $Row Database row + * @return Post + */ + private function mapRowToPost( array $Row ): Post + { + $data = [ + 'id' => (int)$Row['id'], + 'title' => $Row['title'], + 'slug' => $Row['slug'], + 'body' => $Row['body'], + 'excerpt' => $Row['excerpt'], + 'featured_image' => $Row['featured_image'], + 'author_id' => (int)$Row['author_id'], + 'status' => $Row['status'], + 'view_count' => (int)$Row['view_count'], + 'published_at' => $Row['published_at'] ?? null, + 'created_at' => $Row['created_at'], + 'updated_at' => $Row['updated_at'] ?? null, + ]; + + $Post = Post::fromArray( $data ); + + // Load relationships + $Post->setCategories( $this->loadCategories( $Post->getId() ) ); + $Post->setTags( $this->loadTags( $Post->getId() ) ); + + return $Post; + } + + /** + * Load categories for a post + * + * @param int $PostId + * @return Category[] + */ + private function loadCategories( int $PostId ): array + { + $stmt = $this->_PDO->prepare( + "SELECT c.* FROM categories c + INNER JOIN post_categories pc ON c.id = pc.category_id + WHERE pc.post_id = ? + ORDER BY c.name ASC" + ); + $stmt->execute( [ $PostId ] ); + $rows = $stmt->fetchAll(); + + return array_map( fn( $row ) => Category::fromArray( $row ), $rows ); + } + + /** + * Load tags for a post + * + * @param int $PostId + * @return Tag[] + */ + private function loadTags( int $PostId ): array + { + $stmt = $this->_PDO->prepare( + "SELECT t.* FROM tags t + INNER JOIN post_tags pt ON t.id = pt.tag_id + WHERE pt.post_id = ? + ORDER BY t.name ASC" + ); + $stmt->execute( [ $PostId ] ); + $rows = $stmt->fetchAll(); + + return array_map( fn( $row ) => Tag::fromArray( $row ), $rows ); + } +} diff --git a/src/Cms/Repositories/DatabaseTagRepository.php b/src/Cms/Repositories/DatabaseTagRepository.php new file mode 100644 index 0000000..dcd1044 --- /dev/null +++ b/src/Cms/Repositories/DatabaseTagRepository.php @@ -0,0 +1,231 @@ + "sqlite:{$DatabaseConfig['name']}", + 'mysql' => sprintf( + "mysql:host=%s;port=%s;dbname=%s;charset=%s", + $DatabaseConfig['host'] ?? 'localhost', + $DatabaseConfig['port'] ?? 3306, + $DatabaseConfig['name'], + $DatabaseConfig['charset'] ?? 'utf8mb4' + ), + 'pgsql' => sprintf( + "pgsql:host=%s;port=%s;dbname=%s", + $DatabaseConfig['host'] ?? 'localhost', + $DatabaseConfig['port'] ?? 5432, + $DatabaseConfig['name'] + ), + default => throw new Exception( "Unsupported database adapter: $adapter" ) + }; + + $this->_PDO = new PDO( + $dsn, + $DatabaseConfig['user'] ?? null, + $DatabaseConfig['pass'] ?? null, + [ + PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION, + PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC + ] + ); + } + + /** + * Find tag by ID + */ + public function findById( int $Id ): ?Tag + { + $stmt = $this->_PDO->prepare( "SELECT * FROM tags WHERE id = ? LIMIT 1" ); + $stmt->execute( [ $Id ] ); + + $row = $stmt->fetch(); + + return $row ? Tag::fromArray( $row ) : null; + } + + /** + * Find tag by slug + */ + public function findBySlug( string $Slug ): ?Tag + { + $stmt = $this->_PDO->prepare( "SELECT * FROM tags WHERE slug = ? LIMIT 1" ); + $stmt->execute( [ $Slug ] ); + + $row = $stmt->fetch(); + + return $row ? Tag::fromArray( $row ) : null; + } + + /** + * Find tag by name + */ + public function findByName( string $Name ): ?Tag + { + $stmt = $this->_PDO->prepare( "SELECT * FROM tags WHERE name = ? LIMIT 1" ); + $stmt->execute( [ $Name ] ); + + $row = $stmt->fetch(); + + return $row ? Tag::fromArray( $row ) : null; + } + + /** + * Create a new tag + */ + public function create( Tag $Tag ): Tag + { + // Check for duplicate slug + if( $this->findBySlug( $Tag->getSlug() ) ) + { + throw new Exception( 'Slug already exists' ); + } + + // Check for duplicate name + if( $this->findByName( $Tag->getName() ) ) + { + throw new Exception( 'Tag name already exists' ); + } + + $stmt = $this->_PDO->prepare( + "INSERT INTO tags (name, slug, created_at, updated_at) + VALUES (?, ?, ?, ?)" + ); + + $stmt->execute([ + $Tag->getName(), + $Tag->getSlug(), + $Tag->getCreatedAt()->format( 'Y-m-d H:i:s' ), + (new DateTimeImmutable())->format( 'Y-m-d H:i:s' ) + ]); + + $Tag->setId( (int)$this->_PDO->lastInsertId() ); + + return $Tag; + } + + /** + * Update an existing tag + */ + public function update( Tag $Tag ): bool + { + if( !$Tag->getId() ) + { + return false; + } + + // Check for duplicate slug (excluding current tag) + $ExistingBySlug = $this->findBySlug( $Tag->getSlug() ); + if( $ExistingBySlug && $ExistingBySlug->getId() !== $Tag->getId() ) + { + throw new Exception( 'Slug already exists' ); + } + + // Check for duplicate name (excluding current tag) + $ExistingByName = $this->findByName( $Tag->getName() ); + if( $ExistingByName && $ExistingByName->getId() !== $Tag->getId() ) + { + throw new Exception( 'Tag name already exists' ); + } + + $stmt = $this->_PDO->prepare( + "UPDATE tags SET + name = ?, + slug = ?, + updated_at = ? + WHERE id = ?" + ); + + return $stmt->execute([ + $Tag->getName(), + $Tag->getSlug(), + (new DateTimeImmutable())->format( 'Y-m-d H:i:s' ), + $Tag->getId() + ]); + } + + /** + * Delete a tag + */ + public function delete( int $Id ): bool + { + // Foreign key constraints will handle cascade delete of post relationships + $stmt = $this->_PDO->prepare( "DELETE FROM tags WHERE id = ?" ); + $stmt->execute( [ $Id ] ); + + return $stmt->rowCount() > 0; + } + + /** + * Get all tags + */ + public function all(): array + { + $stmt = $this->_PDO->query( "SELECT * FROM tags ORDER BY name ASC" ); + $rows = $stmt->fetchAll(); + + return array_map( fn( $row ) => Tag::fromArray( $row ), $rows ); + } + + /** + * Count total tags + */ + public function count(): int + { + $stmt = $this->_PDO->query( "SELECT COUNT(*) as total FROM tags" ); + $row = $stmt->fetch(); + + return (int)$row['total']; + } + + /** + * Get tags with post count + */ + public function allWithPostCount(): array + { + $stmt = $this->_PDO->query( + "SELECT t.*, COUNT(pt.post_id) as post_count + FROM tags t + LEFT JOIN post_tags pt ON t.id = pt.tag_id + GROUP BY t.id + ORDER BY t.name ASC" + ); + + $rows = $stmt->fetchAll(); + + return array_map( function( $row ) { + $tag = Tag::fromArray( $row ); + return [ + 'tag' => $tag, + 'post_count' => (int)$row['post_count'] + ]; + }, $rows ); + } +} diff --git a/src/Cms/Repositories/DatabaseUserRepository.php b/src/Cms/Repositories/DatabaseUserRepository.php new file mode 100644 index 0000000..d36d295 --- /dev/null +++ b/src/Cms/Repositories/DatabaseUserRepository.php @@ -0,0 +1,277 @@ + "sqlite:{$DatabaseConfig['name']}", + 'mysql' => sprintf( + "mysql:host=%s;port=%s;dbname=%s;charset=%s", + $DatabaseConfig['host'] ?? 'localhost', + $DatabaseConfig['port'] ?? 3306, + $DatabaseConfig['name'], + $DatabaseConfig['charset'] ?? 'utf8mb4' + ), + 'pgsql' => sprintf( + "pgsql:host=%s;port=%s;dbname=%s", + $DatabaseConfig['host'] ?? 'localhost', + $DatabaseConfig['port'] ?? 5432, + $DatabaseConfig['name'] + ), + default => throw new Exception( "Unsupported database adapter: $adapter" ) + }; + + $this->_PDO = new PDO( + $dsn, + $DatabaseConfig['user'] ?? null, + $DatabaseConfig['pass'] ?? null, + [ + PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION, + PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC + ] + ); + } + + /** + * Find user by ID + */ + public function findById( int $Id ): ?User + { + $stmt = $this->_PDO->prepare( "SELECT * FROM users WHERE id = ? LIMIT 1" ); + $stmt->execute( [ $Id ] ); + + $row = $stmt->fetch(); + + return $row ? $this->mapRowToUser( $row ) : null; + } + + /** + * Find user by username + */ + public function findByUsername( string $Username ): ?User + { + $stmt = $this->_PDO->prepare( "SELECT * FROM users WHERE username = ? LIMIT 1" ); + $stmt->execute( [ $Username ] ); + + $row = $stmt->fetch(); + + return $row ? $this->mapRowToUser( $row ) : null; + } + + /** + * Find user by email + */ + public function findByEmail( string $Email ): ?User + { + $stmt = $this->_PDO->prepare( "SELECT * FROM users WHERE email = ? LIMIT 1" ); + $stmt->execute( [ $Email ] ); + + $row = $stmt->fetch(); + + return $row ? $this->mapRowToUser( $row ) : null; + } + + /** + * Find user by remember token + */ + public function findByRememberToken( string $Token ): ?User + { + $stmt = $this->_PDO->prepare( "SELECT * FROM users WHERE remember_token = ? LIMIT 1" ); + $stmt->execute( [ $Token ] ); + + $row = $stmt->fetch(); + + return $row ? $this->mapRowToUser( $row ) : null; + } + + /** + * Create a new user + */ + public function create( User $User ): User + { + // Check for duplicate username + if( $this->findByUsername( $User->getUsername() ) ) + { + throw new Exception( 'Username already exists' ); + } + + // Check for duplicate email + if( $this->findByEmail( $User->getEmail() ) ) + { + throw new Exception( 'Email already exists' ); + } + + $stmt = $this->_PDO->prepare( + "INSERT INTO users ( + username, email, password_hash, role, status, email_verified, + two_factor_secret, remember_token, failed_login_attempts, + locked_until, last_login_at, created_at, updated_at + ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)" + ); + + $stmt->execute([ + $User->getUsername(), + $User->getEmail(), + $User->getPasswordHash(), + $User->getRole(), + $User->getStatus(), + $User->isEmailVerified() ? 1 : 0, + $User->getTwoFactorSecret(), + $User->getRememberToken(), + $User->getFailedLoginAttempts(), + $User->getLockedUntil() ? $User->getLockedUntil()->format( 'Y-m-d H:i:s' ) : null, + $User->getLastLoginAt() ? $User->getLastLoginAt()->format( 'Y-m-d H:i:s' ) : null, + $User->getCreatedAt()->format( 'Y-m-d H:i:s' ), + (new DateTimeImmutable())->format( 'Y-m-d H:i:s' ) + ]); + + $User->setId( (int)$this->_PDO->lastInsertId() ); + + return $User; + } + + /** + * Update an existing user + */ + public function update( User $User ): bool + { + if( !$User->getId() ) + { + return false; + } + + // Check for duplicate username (excluding current user) + $ExistingByUsername = $this->findByUsername( $User->getUsername() ); + if( $ExistingByUsername && $ExistingByUsername->getId() !== $User->getId() ) + { + throw new Exception( 'Username already exists' ); + } + + // Check for duplicate email (excluding current user) + $ExistingByEmail = $this->findByEmail( $User->getEmail() ); + if( $ExistingByEmail && $ExistingByEmail->getId() !== $User->getId() ) + { + throw new Exception( 'Email already exists' ); + } + + $stmt = $this->_PDO->prepare( + "UPDATE users SET + username = ?, + email = ?, + password_hash = ?, + role = ?, + status = ?, + email_verified = ?, + two_factor_secret = ?, + remember_token = ?, + failed_login_attempts = ?, + locked_until = ?, + last_login_at = ?, + updated_at = ? + WHERE id = ?" + ); + + return $stmt->execute([ + $User->getUsername(), + $User->getEmail(), + $User->getPasswordHash(), + $User->getRole(), + $User->getStatus(), + $User->isEmailVerified() ? 1 : 0, + $User->getTwoFactorSecret(), + $User->getRememberToken(), + $User->getFailedLoginAttempts(), + $User->getLockedUntil() ? $User->getLockedUntil()->format( 'Y-m-d H:i:s' ) : null, + $User->getLastLoginAt() ? $User->getLastLoginAt()->format( 'Y-m-d H:i:s' ) : null, + (new DateTimeImmutable())->format( 'Y-m-d H:i:s' ), + $User->getId() + ]); + } + + /** + * Delete a user + */ + public function delete( int $Id ): bool + { + $stmt = $this->_PDO->prepare( "DELETE FROM users WHERE id = ?" ); + $stmt->execute( [ $Id ] ); + + return $stmt->rowCount() > 0; + } + + /** + * Get all users + */ + public function all(): array + { + $stmt = $this->_PDO->query( "SELECT * FROM users ORDER BY created_at DESC" ); + $rows = $stmt->fetchAll(); + + return array_map( [ $this, 'mapRowToUser' ], $rows ); + } + + /** + * Count total users + */ + public function count(): int + { + $stmt = $this->_PDO->query( "SELECT COUNT(*) as total FROM users" ); + $row = $stmt->fetch(); + + return (int)$row['total']; + } + + /** + * Map database row to User object + * + * @param array $Row Database row + * @return User + */ + private function mapRowToUser( array $Row ): User + { + $data = [ + 'id' => (int)$Row['id'], + 'username' => $Row['username'], + 'email' => $Row['email'], + 'password_hash' => $Row['password_hash'], + 'role' => $Row['role'], + 'status' => $Row['status'], + 'email_verified' => (bool)$Row['email_verified'], + 'two_factor_secret' => $Row['two_factor_secret'], + 'remember_token' => $Row['remember_token'], + 'failed_login_attempts' => (int)$Row['failed_login_attempts'], + 'locked_until' => $Row['locked_until'] ?? null, + 'last_login_at' => $Row['last_login_at'] ?? null, + 'created_at' => $Row['created_at'], + 'updated_at' => $Row['updated_at'] ?? null, + ]; + + return User::fromArray( $data ); + } +} diff --git a/src/Cms/Repositories/ICategoryRepository.php b/src/Cms/Repositories/ICategoryRepository.php new file mode 100644 index 0000000..c2317d3 --- /dev/null +++ b/src/Cms/Repositories/ICategoryRepository.php @@ -0,0 +1,62 @@ + Category, 'post_count' => int] + */ + public function allWithPostCount(): array; +} diff --git a/src/Cms/Repositories/IPasswordResetTokenRepository.php b/src/Cms/Repositories/IPasswordResetTokenRepository.php new file mode 100644 index 0000000..f8a8cf3 --- /dev/null +++ b/src/Cms/Repositories/IPasswordResetTokenRepository.php @@ -0,0 +1,54 @@ + Tag, 'post_count' => int] + */ + public function allWithPostCount(): array; +} diff --git a/src/Cms/Repositories/IUserRepository.php b/src/Cms/Repositories/IUserRepository.php new file mode 100644 index 0000000..0e63b16 --- /dev/null +++ b/src/Cms/Repositories/IUserRepository.php @@ -0,0 +1,58 @@ +_Settings = $Settings; + $this->_BasePath = $BasePath ?: getcwd(); + } + + /** + * Add recipient + */ + public function to( string $email, string $name = '' ): self + { + $this->_To[] = [ 'email' => $email, 'name' => $name ]; + return $this; + } + + /** + * Add CC recipient + */ + public function cc( string $email, string $name = '' ): self + { + $this->_Cc[] = [ 'email' => $email, 'name' => $name ]; + return $this; + } + + /** + * Add BCC recipient + */ + public function bcc( string $email, string $name = '' ): self + { + $this->_Bcc[] = [ 'email' => $email, 'name' => $name ]; + return $this; + } + + /** + * Set subject + */ + public function subject( string $subject ): self + { + $this->_Subject = $subject; + return $this; + } + + /** + * Set body content + */ + public function body( string $body, bool $isHtml = true ): self + { + $this->_Body = $body; + $this->_IsHtml = $isHtml; + return $this; + } + + /** + * Set reply-to address + */ + public function replyTo( string $email, string $name = '' ): self + { + $this->_ReplyTo = $email; + $this->_ReplyToName = $name; + return $this; + } + + /** + * Attach file + */ + public function attach( string $filePath, string $name = '' ): self + { + $this->_Attachments[] = [ 'path' => $filePath, 'name' => $name ]; + return $this; + } + + /** + * Render email template + */ + public function template( string $templatePath, array $data = [] ): self + { + try + { + $view = new Html(); + $view->setViewPath( $this->_BasePath . '/resources/views' ); + $view->setPage( $templatePath ); + + // Render the template + ob_start(); + foreach( $data as $key => $value ) + { + $$key = $value; + } + require $view->getViewPath() . '/' . $templatePath . '.php'; + $this->_Body = ob_get_clean(); + $this->_IsHtml = true; + + return $this; + } + catch( \Exception $e ) + { + Log::error( "Email template error: " . $e->getMessage() ); + throw new \RuntimeException( "Failed to render email template: {$templatePath}" ); + } + } + + /** + * Send the email + */ + public function send(): bool + { + // Check for test mode + if( $this->_Settings && $this->_Settings->get( 'email.test_mode' ) ) + { + return $this->logEmail(); + } + + try + { + $mail = $this->createMailer(); + + // Recipients + foreach( $this->_To as $recipient ) + { + $mail->addAddress( $recipient['email'], $recipient['name'] ); + } + + foreach( $this->_Cc as $recipient ) + { + $mail->addCC( $recipient['email'], $recipient['name'] ); + } + + foreach( $this->_Bcc as $recipient ) + { + $mail->addBCC( $recipient['email'], $recipient['name'] ); + } + + // Reply-To + if( $this->_ReplyTo ) + { + $mail->addReplyTo( $this->_ReplyTo, $this->_ReplyToName ?? '' ); + } + + // Attachments + foreach( $this->_Attachments as $attachment ) + { + $mail->addAttachment( $attachment['path'], $attachment['name'] ); + } + + // Content + $mail->Subject = $this->_Subject; + $mail->Body = $this->_Body; + $mail->isHTML( $this->_IsHtml ); + + // Send + $result = $mail->send(); + + if( $result ) + { + Log::info( "Email sent to: " . $this->_To[0]['email'] ); + } + + return $result; + } + catch( PHPMailerException $e ) + { + Log::error( "Email send failed: " . $e->getMessage() ); + return false; + } + } + + /** + * Create and configure PHPMailer instance + */ + private function createMailer(): PHPMailer + { + $mail = new PHPMailer( true ); + + // Get config + $driver = $this->_Settings?->get( 'email.driver' ) ?? 'mail'; + $host = $this->_Settings?->get( 'email.host' ) ?? ''; + $port = $this->_Settings?->get( 'email.port' ) ?? 587; + $username = $this->_Settings?->get( 'email.username' ) ?? ''; + $password = $this->_Settings?->get( 'email.password' ) ?? ''; + $encryption = $this->_Settings?->get( 'email.encryption' ) ?? 'tls'; + $fromAddress = $this->_Settings?->get( 'email.from_address' ) ?? 'noreply@example.com'; + $fromName = $this->_Settings?->get( 'email.from_name' ) ?? 'Neuron CMS'; + + // Configure based on driver + if( $driver === 'smtp' ) + { + $mail->isSMTP(); + $mail->Host = $host; + $mail->Port = $port; + $mail->SMTPAuth = !empty( $username ); + + if( $mail->SMTPAuth ) + { + $mail->Username = $username; + $mail->Password = $password; + } + + if( $encryption === 'tls' ) + { + $mail->SMTPSecure = PHPMailer::ENCRYPTION_STARTTLS; + } + elseif( $encryption === 'ssl' ) + { + $mail->SMTPSecure = PHPMailer::ENCRYPTION_SMTPS; + } + } + elseif( $driver === 'sendmail' ) + { + $mail->isSendmail(); + } + else + { + $mail->isMail(); + } + + // From + $mail->setFrom( $fromAddress, $fromName ); + + // Encoding + $mail->CharSet = 'UTF-8'; + + return $mail; + } + + /** + * Log email instead of sending (test mode) + */ + private function logEmail(): bool + { + $recipients = array_map( fn($r) => $r['email'], $this->_To ); + + Log::info( "TEST MODE - Email not sent" ); + Log::info( " To: " . implode( ', ', $recipients ) ); + Log::info( " Subject: " . $this->_Subject ); + Log::info( " Body: " . substr( strip_tags( $this->_Body ), 0, 100 ) . '...' ); + + return true; + } +} diff --git a/src/Cms/View/helpers.php b/src/Cms/View/helpers.php new file mode 100644 index 0000000..421ee18 --- /dev/null +++ b/src/Cms/View/helpers.php @@ -0,0 +1,56 @@ +', + htmlspecialchars($url), + $size, + $size, + $classes + ); + } +} diff --git a/tests/Cms/Auth/AuthManagerTest.php b/tests/Cms/Auth/AuthManagerTest.php new file mode 100644 index 0000000..f8617a7 --- /dev/null +++ b/tests/Cms/Auth/AuthManagerTest.php @@ -0,0 +1,346 @@ + 'sqlite', + 'name' => ':memory:' + ]; + + $this->userRepository = new DatabaseUserRepository($config); + + // Get PDO connection via reflection to create table + $reflection = new \ReflectionClass($this->userRepository); + $property = $reflection->getProperty('_PDO'); + $property->setAccessible(true); + $this->pdo = $property->getValue($this->userRepository); + + // Create users table + $this->createUsersTable(); + + $this->sessionManager = new SessionManager([ + 'cookie_secure' => false // Disable HTTPS requirement for tests + ]); + $this->passwordHasher = new PasswordHasher(); + + $this->authManager = new AuthManager( + $this->userRepository, + $this->sessionManager, + $this->passwordHasher + ); + } + + private function createUsersTable(): void + { + $sql = " + CREATE TABLE users ( + id INTEGER PRIMARY KEY AUTOINCREMENT, + username VARCHAR(255) UNIQUE NOT NULL, + email VARCHAR(255) UNIQUE NOT NULL, + password_hash VARCHAR(255) NOT NULL, + role VARCHAR(50) DEFAULT 'subscriber', + status VARCHAR(50) DEFAULT 'active', + email_verified BOOLEAN DEFAULT 0, + two_factor_secret VARCHAR(255) NULL, + remember_token VARCHAR(255) NULL, + failed_login_attempts INTEGER DEFAULT 0, + locked_until TIMESTAMP NULL, + last_login_at TIMESTAMP NULL, + created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP, + updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP + ) + "; + + $this->pdo->exec($sql); + } + + protected function tearDown(): void + { + // Clean up session + $_SESSION = []; + // In-memory database is automatically cleaned up + } + + private function createTestUser(string $username = 'testuser', string $password = 'TestPass123'): User + { + $user = new User(); + $user->setUsername($username); + $user->setEmail($username . '@example.com'); + $user->setPasswordHash($this->passwordHasher->hash($password)); + $user->setRole(User::ROLE_AUTHOR); + $user->setStatus(User::STATUS_ACTIVE); + return $this->userRepository->create($user); + } + + public function testAttemptWithCorrectCredentials(): void + { + $user = $this->createTestUser('testuser', 'TestPass123'); + + $result = $this->authManager->attempt('testuser', 'TestPass123'); + + $this->assertTrue($result); + $this->assertTrue($this->authManager->check()); + } + + public function testAttemptWithIncorrectPassword(): void + { + $user = $this->createTestUser('testuser', 'TestPass123'); + + $result = $this->authManager->attempt('testuser', 'WrongPassword'); + + $this->assertFalse($result); + $this->assertFalse($this->authManager->check()); + } + + public function testAttemptWithNonexistentUser(): void + { + $result = $this->authManager->attempt('nonexistent', 'password'); + + $this->assertFalse($result); + $this->assertFalse($this->authManager->check()); + } + + public function testAttemptWithInactiveUser(): void + { + $user = $this->createTestUser('suspended', 'TestPass123'); + $user->setStatus(User::STATUS_SUSPENDED); + $this->userRepository->update($user); + + $result = $this->authManager->attempt('suspended', 'TestPass123'); + + $this->assertFalse($result); + $this->assertFalse($this->authManager->check()); + } + + public function testAttemptWithLockedOutUser(): void + { + $user = $this->createTestUser('locked', 'TestPass123'); + $user->setLockedUntil((new DateTimeImmutable())->modify('+10 minutes')); + $this->userRepository->update($user); + + $result = $this->authManager->attempt('locked', 'TestPass123'); + + $this->assertFalse($result); + $this->assertFalse($this->authManager->check()); + } + + public function testFailedLoginAttemptsIncrement(): void + { + $user = $this->createTestUser('failtest', 'TestPass123'); + + $this->assertEquals(0, $user->getFailedLoginAttempts()); + + // First failed attempt + $this->authManager->attempt('failtest', 'WrongPassword'); + $user = $this->userRepository->findByUsername('failtest'); + $this->assertEquals(1, $user->getFailedLoginAttempts()); + + // Second failed attempt + $this->authManager->attempt('failtest', 'WrongPassword'); + $user = $this->userRepository->findByUsername('failtest'); + $this->assertEquals(2, $user->getFailedLoginAttempts()); + } + + public function testAccountLockoutAfterMaxAttempts(): void + { + $user = $this->createTestUser('locktest', 'TestPass123'); + + // Make 5 failed attempts (default max) + for ($i = 0; $i < 5; $i++) { + $this->authManager->attempt('locktest', 'WrongPassword'); + } + + $user = $this->userRepository->findByUsername('locktest'); + $this->assertTrue($user->isLockedOut()); + $this->assertNotNull($user->getLockedUntil()); + + // Should not be able to login even with correct password + $result = $this->authManager->attempt('locktest', 'TestPass123'); + $this->assertFalse($result); + } + + public function testSuccessfulLoginResetsFailedAttempts(): void + { + $user = $this->createTestUser('resettest', 'TestPass123'); + + // Make 3 failed attempts + for ($i = 0; $i < 3; $i++) { + $this->authManager->attempt('resettest', 'WrongPassword'); + } + + $user = $this->userRepository->findByUsername('resettest'); + $this->assertEquals(3, $user->getFailedLoginAttempts()); + + // Successful login should reset + $this->authManager->attempt('resettest', 'TestPass123'); + $user = $this->userRepository->findByUsername('resettest'); + $this->assertEquals(0, $user->getFailedLoginAttempts()); + } + + public function testLoginWithRememberMe(): void + { + $user = $this->createTestUser('remembertest', 'TestPass123'); + + $this->authManager->attempt('remembertest', 'TestPass123', true); + + $user = $this->userRepository->findByUsername('remembertest'); + $this->assertNotNull($user->getRememberToken()); + } + + public function testLoginWithoutRememberMe(): void + { + $user = $this->createTestUser('noremember', 'TestPass123'); + + $this->authManager->attempt('noremember', 'TestPass123', false); + + $user = $this->userRepository->findByUsername('noremember'); + $this->assertNull($user->getRememberToken()); + } + + public function testCheckReturnsTrue(): void + { + $user = $this->createTestUser('checktest', 'TestPass123'); + $this->authManager->attempt('checktest', 'TestPass123'); + + $this->assertTrue($this->authManager->check()); + } + + public function testCheckReturnsFalse(): void + { + $this->assertFalse($this->authManager->check()); + } + + public function testUserReturnsAuthenticatedUser(): void + { + $user = $this->createTestUser('usertest', 'TestPass123'); + $this->authManager->attempt('usertest', 'TestPass123'); + + $authUser = $this->authManager->user(); + + $this->assertNotNull($authUser); + $this->assertEquals('usertest', $authUser->getUsername()); + } + + public function testUserReturnsNullWhenNotAuthenticated(): void + { + $this->assertNull($this->authManager->user()); + } + + public function testLogout(): void + { + $user = $this->createTestUser('logouttest', 'TestPass123'); + $this->authManager->attempt('logouttest', 'TestPass123', true); + + $this->assertTrue($this->authManager->check()); + + $this->authManager->logout(); + + $this->assertFalse($this->authManager->check()); + $this->assertNull($this->authManager->user()); + + // Remember token should be removed + $user = $this->userRepository->findByUsername('logouttest'); + $this->assertNull($user->getRememberToken()); + } + + public function testLoginUsingRememberToken(): void + { + $user = $this->createTestUser('tokentest', 'TestPass123'); + + // Generate a plain token and its hash + $plainToken = bin2hex(random_bytes(32)); + $hashedToken = hash('sha256', $plainToken); + + // Manually set the hashed token on the user + $user->setRememberToken($hashedToken); + $this->userRepository->update($user); + + // Login using the plain token (as would come from cookie) + $result = $this->authManager->loginUsingRememberToken($plainToken); + + $this->assertTrue($result); + $this->assertTrue($this->authManager->check()); + } + + public function testLoginUsingInvalidRememberToken(): void + { + $result = $this->authManager->loginUsingRememberToken('invalid_token'); + + $this->assertFalse($result); + $this->assertFalse($this->authManager->check()); + } + + public function testPasswordRehashingOnLogin(): void + { + // Create user with old hash algorithm (simulated) + $user = $this->createTestUser('rehashtest', 'TestPass123'); + $oldHash = $user->getPasswordHash(); + + // Mock that hash needs rehashing (in reality this checks algorithm version) + // For testing, we'll just verify the hash is checked + $this->authManager->attempt('rehashtest', 'TestPass123'); + + // Password should be hashed with current algorithm + $user = $this->userRepository->findByUsername('rehashtest'); + $this->assertNotEmpty($user->getPasswordHash()); + } + + public function testIsAdmin(): void + { + $user = $this->createTestUser('admintest', 'TestPass123'); + $user->setRole(\Neuron\Cms\Models\User::ROLE_ADMIN); + $this->userRepository->update($user); + + $this->authManager->attempt('admintest', 'TestPass123'); + + $this->assertTrue($this->authManager->isAdmin()); + } + + public function testHasRole(): void + { + $user = $this->createTestUser('roletest', 'TestPass123'); + $user->setRole(\Neuron\Cms\Models\User::ROLE_EDITOR); + $this->userRepository->update($user); + + $this->authManager->attempt('roletest', 'TestPass123'); + + $this->assertTrue($this->authManager->hasRole(\Neuron\Cms\Models\User::ROLE_EDITOR)); + $this->assertFalse($this->authManager->hasRole(\Neuron\Cms\Models\User::ROLE_ADMIN)); + } + + public function testUpdateLastLoginTime(): void + { + $user = $this->createTestUser('lastlogin', 'TestPass123'); + + $this->assertNull($user->getLastLoginAt()); + + $this->authManager->attempt('lastlogin', 'TestPass123'); + + $user = $this->userRepository->findByUsername('lastlogin'); + $this->assertInstanceOf(DateTimeImmutable::class, $user->getLastLoginAt()); + } +} diff --git a/tests/Cms/Auth/CsrfTokenManagerTest.php b/tests/Cms/Auth/CsrfTokenManagerTest.php new file mode 100644 index 0000000..5c18d6e --- /dev/null +++ b/tests/Cms/Auth/CsrfTokenManagerTest.php @@ -0,0 +1,185 @@ +sessionManager = new SessionManager([ + 'cookie_secure' => false // Disable HTTPS requirement for tests + ]); + $this->csrfManager = new CsrfTokenManager($this->sessionManager); + + $_SESSION = []; // Clear session data + } + + protected function tearDown(): void + { + $_SESSION = []; // Clean up session data + } + + public function testGenerateToken(): void + { + $token = $this->csrfManager->generate(); + + $this->assertNotEmpty($token); + $this->assertIsString($token); + $this->assertGreaterThan(20, strlen($token)); // Should be reasonably long + } + + public function testGenerateTokenStoresInSession(): void + { + $token = $this->csrfManager->generate(); + + $storedToken = $this->sessionManager->get('csrf_token'); + + $this->assertEquals($token, $storedToken); + } + + public function testGenerateTokenIsRandom(): void + { + $token1 = $this->csrfManager->generate(); + + // Clear session to force new token + $_SESSION = []; + + $token2 = $this->csrfManager->generate(); + + $this->assertNotEquals($token1, $token2); + } + + public function testGetTokenReturnsExistingToken(): void + { + $generated = $this->csrfManager->generate(); + + $retrieved = $this->csrfManager->getToken(); + + $this->assertEquals($generated, $retrieved); + } + + public function testGetTokenGeneratesTokenIfNotExists(): void + { + $token = $this->csrfManager->getToken(); + + $this->assertNotEmpty($token); + $this->assertIsString($token); + } + + public function testValidateWithCorrectToken(): void + { + $token = $this->csrfManager->generate(); + + $result = $this->csrfManager->validate($token); + + $this->assertTrue($result); + } + + public function testValidateWithIncorrectToken(): void + { + $this->csrfManager->generate(); + + $result = $this->csrfManager->validate('incorrect_token'); + + $this->assertFalse($result); + } + + public function testValidateWithEmptyToken(): void + { + $this->csrfManager->generate(); + + $result = $this->csrfManager->validate(''); + + $this->assertFalse($result); + } + + public function testValidateWithNoStoredToken(): void + { + // Don't generate a token first + + $result = $this->csrfManager->validate('some_token'); + + $this->assertFalse($result); + } + + public function testValidateUsesTimingSafeComparison(): void + { + // This test verifies that validation uses hash_equals (timing-attack safe) + // We can't directly test timing, but we verify it accepts exact matches only + + $token = $this->csrfManager->generate(); + + // Slightly modified tokens should fail + $almostToken = substr($token, 0, -1) . 'x'; + + $this->assertTrue($this->csrfManager->validate($token)); + $this->assertFalse($this->csrfManager->validate($almostToken)); + } + + public function testRegenerateToken(): void + { + $firstToken = $this->csrfManager->generate(); + + $secondToken = $this->csrfManager->regenerate(); + + $this->assertNotEquals($firstToken, $secondToken); + $this->assertEquals($secondToken, $this->csrfManager->getToken()); + } + + public function testRegenerateTokenInvalidatesOldToken(): void + { + $oldToken = $this->csrfManager->generate(); + + $newToken = $this->csrfManager->regenerate(); + + // Old token should no longer be valid + $this->assertFalse($this->csrfManager->validate($oldToken)); + + // New token should be valid + $this->assertTrue($this->csrfManager->validate($newToken)); + } + + public function testTokenLength(): void + { + $token = $this->csrfManager->generate(); + + // Token should be URL-safe and reasonably long + $this->assertGreaterThanOrEqual(32, strlen($token)); + $this->assertMatchesRegularExpression('/^[a-zA-Z0-9]+$/', $token); + } + + public function testTokenPersistsAcrossMultipleValidations(): void + { + $token = $this->csrfManager->generate(); + + // Validate multiple times + $this->assertTrue($this->csrfManager->validate($token)); + $this->assertTrue($this->csrfManager->validate($token)); + $this->assertTrue($this->csrfManager->validate($token)); + + // Token should still be valid + $this->assertEquals($token, $this->csrfManager->getToken()); + } + + public function testTokenIsUrlSafe(): void + { + $token = $this->csrfManager->generate(); + + // Encode and decode should return same token + $encoded = urlencode($token); + $decoded = urldecode($encoded); + + $this->assertEquals($token, $decoded); + } +} diff --git a/tests/Cms/Auth/PasswordHasherTest.php b/tests/Cms/Auth/PasswordHasherTest.php new file mode 100644 index 0000000..9b35348 --- /dev/null +++ b/tests/Cms/Auth/PasswordHasherTest.php @@ -0,0 +1,128 @@ +hasher = new PasswordHasher(); + } + + public function testHashPassword(): void + { + $password = 'SecurePassword123!'; + $hash = $this->hasher->hash($password); + + $this->assertNotEquals($password, $hash); + $this->assertGreaterThan(50, strlen($hash)); + } + + public function testVerifyCorrectPassword(): void + { + $password = 'SecurePassword123!'; + $hash = $this->hasher->hash($password); + + $this->assertTrue($this->hasher->verify($password, $hash)); + } + + public function testVerifyIncorrectPassword(): void + { + $password = 'SecurePassword123!'; + $wrongPassword = 'WrongPassword123!'; + $hash = $this->hasher->hash($password); + + $this->assertFalse($this->hasher->verify($wrongPassword, $hash)); + } + + public function testPasswordMeetsRequirements(): void + { + $this->assertTrue($this->hasher->meetsRequirements('StrongPass1')); + $this->assertTrue($this->hasher->meetsRequirements('AnotherGood2')); + } + + public function testPasswordTooShort(): void + { + $this->assertFalse($this->hasher->meetsRequirements('Short1')); + } + + public function testPasswordNoUppercase(): void + { + $this->assertFalse($this->hasher->meetsRequirements('nouppercase1')); + } + + public function testPasswordNoLowercase(): void + { + $this->assertFalse($this->hasher->meetsRequirements('NOLOWERCASE1')); + } + + public function testPasswordNoNumbers(): void + { + $this->assertFalse($this->hasher->meetsRequirements('NoNumbers')); + } + + public function testGetValidationErrors(): void + { + $errors = $this->hasher->getValidationErrors('weak'); + + $this->assertIsArray($errors); + $this->assertNotEmpty($errors); + $this->assertStringContainsString('8 characters', $errors[0]); + } + + public function testConfigureMinLength(): void + { + $this->hasher->setMinLength(12); + + $this->assertFalse($this->hasher->meetsRequirements('Short1Pw')); // 8 chars + $this->assertTrue($this->hasher->meetsRequirements('LongerPass12')); // 12 chars + } + + public function testConfigureRequireSpecialChars(): void + { + $this->hasher->setRequireSpecialChars(true); + + $this->assertFalse($this->hasher->meetsRequirements('NoSpecial1')); + $this->assertTrue($this->hasher->meetsRequirements('HasSpecial1!')); + } + + public function testConfigureFromArray(): void + { + $this->hasher->configure([ + 'min_length' => 10, + 'require_special_chars' => true + ]); + + $this->assertFalse($this->hasher->meetsRequirements('Short1')); + $this->assertFalse($this->hasher->meetsRequirements('LongerPass1')); + $this->assertTrue($this->hasher->meetsRequirements('LongerPass1!')); + } + + public function testNeedsRehash(): void + { + $password = 'TestPassword1'; + $hash = $this->hasher->hash($password); + + // A newly created hash should not need rehashing + $this->assertFalse($this->hasher->needsRehash($hash)); + } + + public function testHashesAreDifferent(): void + { + $password = 'SamePassword1'; + $hash1 = $this->hasher->hash($password); + $hash2 = $this->hasher->hash($password); + + // Same password should produce different hashes (due to salt) + $this->assertNotEquals($hash1, $hash2); + + // But both should verify correctly + $this->assertTrue($this->hasher->verify($password, $hash1)); + $this->assertTrue($this->hasher->verify($password, $hash2)); + } +} diff --git a/tests/Cms/Auth/SessionManagerTest.php b/tests/Cms/Auth/SessionManagerTest.php new file mode 100644 index 0000000..45ff09f --- /dev/null +++ b/tests/Cms/Auth/SessionManagerTest.php @@ -0,0 +1,207 @@ +sessionManager = new SessionManager([ + 'cookie_secure' => false // Disable HTTPS requirement for tests + ]); + $_SESSION = []; // Clear session data + } + + protected function tearDown(): void + { + $_SESSION = []; // Clean up session data + } + + public function testSetAndGet(): void + { + $this->sessionManager->set('test_key', 'test_value'); + + $this->assertEquals('test_value', $this->sessionManager->get('test_key')); + } + + public function testGetWithDefault(): void + { + $value = $this->sessionManager->get('nonexistent', 'default_value'); + + $this->assertEquals('default_value', $value); + } + + public function testGetReturnsNullForNonexistent(): void + { + $value = $this->sessionManager->get('nonexistent'); + + $this->assertNull($value); + } + + public function testHasReturnsTrueForExisting(): void + { + $this->sessionManager->set('exists', 'value'); + + $this->assertTrue($this->sessionManager->has('exists')); + } + + public function testHasReturnsFalseForNonexistent(): void + { + $this->assertFalse($this->sessionManager->has('nonexistent')); + } + + public function testRemove(): void + { + $this->sessionManager->set('to_remove', 'value'); + $this->assertTrue($this->sessionManager->has('to_remove')); + + $this->sessionManager->remove('to_remove'); + + $this->assertFalse($this->sessionManager->has('to_remove')); + } + + public function testFlashMessage(): void + { + $this->sessionManager->flash('success', 'Operation completed'); + + // Flash message should be stored in _flash array + $this->assertTrue($this->sessionManager->has('_flash')); + $flash = $this->sessionManager->get('_flash'); + $this->assertEquals('Operation completed', $flash['success']); + } + + public function testGetFlashReturnsMessage(): void + { + $this->sessionManager->flash('info', 'Information message'); + + $message = $this->sessionManager->getFlash('info'); + + $this->assertEquals('Information message', $message); + } + + public function testGetFlashRemovesMessage(): void + { + $this->sessionManager->flash('info', 'Information message'); + + $this->sessionManager->getFlash('info'); + + // Second call should return null + $this->assertNull($this->sessionManager->getFlash('info')); + } + + public function testGetFlashReturnsDefaultForNonexistent(): void + { + $message = $this->sessionManager->getFlash('nonexistent', 'default'); + + $this->assertEquals('default', $message); + } + + public function testHasFlashReturnsTrueForExisting(): void + { + $this->sessionManager->flash('warning', 'Warning message'); + + $this->assertTrue($this->sessionManager->hasFlash('warning')); + } + + public function testHasFlashReturnsFalseForNonexistent(): void + { + $this->assertFalse($this->sessionManager->hasFlash('nonexistent')); + } + + public function testGetAllFlashReturnsAllMessages(): void + { + $this->sessionManager->flash('success', 'Success message'); + $this->sessionManager->flash('error', 'Error message'); + + $all = $this->sessionManager->getAllFlash(); + + $this->assertIsArray($all); + $this->assertEquals('Success message', $all['success']); + $this->assertEquals('Error message', $all['error']); + } + + public function testGetAllFlashClearsMessages(): void + { + $this->sessionManager->flash('info', 'Info message'); + + $this->sessionManager->getAllFlash(); + + // Should be cleared after retrieval + $this->assertFalse($this->sessionManager->hasFlash('info')); + } + + public function testRegenerateChangesSessionId(): void + { + $this->sessionManager->start(); + $oldId = session_id(); + + $result = $this->sessionManager->regenerate(); + + $newId = session_id(); + + $this->assertTrue($result); + $this->assertNotEquals($oldId, $newId); + } + + public function testRegeneratePreservesSessionData(): void + { + $this->sessionManager->set('preserved', 'data'); + + $this->sessionManager->regenerate(); + + $this->assertEquals('data', $this->sessionManager->get('preserved')); + } + + public function testGetId(): void + { + $sessionId = $this->sessionManager->getId(); + + $this->assertNotEmpty($sessionId); + $this->assertEquals(session_id(), $sessionId); + } + + public function testIsStarted(): void + { + $this->assertFalse($this->sessionManager->isStarted()); + + $this->sessionManager->start(); + + $this->assertTrue($this->sessionManager->isStarted()); + } + + public function testMultipleFlashMessages(): void + { + $this->sessionManager->flash('success', 'Success message'); + $this->sessionManager->flash('error', 'Error message'); + $this->sessionManager->flash('info', 'Info message'); + + $this->assertTrue($this->sessionManager->hasFlash('success')); + $this->assertTrue($this->sessionManager->hasFlash('error')); + $this->assertTrue($this->sessionManager->hasFlash('info')); + + $this->assertEquals('Success message', $this->sessionManager->getFlash('success')); + $this->assertEquals('Error message', $this->sessionManager->getFlash('error')); + $this->assertEquals('Info message', $this->sessionManager->getFlash('info')); + } + + public function testDestroyRemovesAllSessionData(): void + { + $this->sessionManager->set('test', 'value'); + $this->sessionManager->flash('message', 'flash value'); + + $result = $this->sessionManager->destroy(); + + $this->assertTrue($result); + // After destroy, session should be empty + $this->assertEmpty($_SESSION); + } +} diff --git a/tests/Cms/Auth/UserTest.php b/tests/Cms/Auth/UserTest.php new file mode 100644 index 0000000..a95c2a3 --- /dev/null +++ b/tests/Cms/Auth/UserTest.php @@ -0,0 +1,179 @@ +setUsername('testuser'); + $user->setEmail('test@example.com'); + $user->setPasswordHash('hashed_password'); + + $this->assertEquals('testuser', $user->getUsername()); + $this->assertEquals('test@example.com', $user->getEmail()); + $this->assertEquals('hashed_password', $user->getPasswordHash()); + } + + public function testDefaultRole(): void + { + $user = new User(); + $this->assertEquals(User::ROLE_SUBSCRIBER, $user->getRole()); + } + + public function testDefaultStatus(): void + { + $user = new User(); + $this->assertEquals(User::STATUS_ACTIVE, $user->getStatus()); + } + + public function testIsAdmin(): void + { + $user = new User(); + $user->setRole(User::ROLE_ADMIN); + + $this->assertTrue($user->isAdmin()); + $this->assertFalse($user->isEditor()); + $this->assertFalse($user->isAuthor()); + } + + public function testIsEditor(): void + { + $user = new User(); + $user->setRole(User::ROLE_EDITOR); + + $this->assertFalse($user->isAdmin()); + $this->assertTrue($user->isEditor()); + $this->assertFalse($user->isAuthor()); + } + + public function testIsActive(): void + { + $user = new User(); + $user->setStatus(User::STATUS_ACTIVE); + + $this->assertTrue($user->isActive()); + $this->assertFalse($user->isSuspended()); + } + + public function testIsSuspended(): void + { + $user = new User(); + $user->setStatus(User::STATUS_SUSPENDED); + + $this->assertFalse($user->isActive()); + $this->assertTrue($user->isSuspended()); + } + + public function testFailedLoginAttempts(): void + { + $user = new User(); + + $this->assertEquals(0, $user->getFailedLoginAttempts()); + + $user->incrementFailedLoginAttempts(); + $this->assertEquals(1, $user->getFailedLoginAttempts()); + + $user->incrementFailedLoginAttempts(); + $this->assertEquals(2, $user->getFailedLoginAttempts()); + + $user->resetFailedLoginAttempts(); + $this->assertEquals(0, $user->getFailedLoginAttempts()); + } + + public function testIsLockedOut(): void + { + $user = new User(); + + // Not locked by default + $this->assertFalse($user->isLockedOut()); + + // Lock until future + $futureTime = (new DateTimeImmutable())->modify('+10 minutes'); + $user->setLockedUntil($futureTime); + $this->assertTrue($user->isLockedOut()); + + // Lock until past (expired) + $pastTime = (new DateTimeImmutable())->modify('-10 minutes'); + $user->setLockedUntil($pastTime); + $this->assertFalse($user->isLockedOut()); + } + + public function testResetFailedLoginAttemptsRemovesLockout(): void + { + $user = new User(); + $user->setFailedLoginAttempts(5); + $user->setLockedUntil((new DateTimeImmutable())->modify('+10 minutes')); + + $this->assertTrue($user->isLockedOut()); + + $user->resetFailedLoginAttempts(); + + $this->assertEquals(0, $user->getFailedLoginAttempts()); + $this->assertFalse($user->isLockedOut()); + } + + public function testHasTwoFactorEnabled(): void + { + $user = new User(); + + $this->assertFalse($user->hasTwoFactorEnabled()); + + $user->setTwoFactorSecret('secret_key'); + $this->assertTrue($user->hasTwoFactorEnabled()); + } + + public function testToArray(): void + { + $user = new User(); + $user->setId(1); + $user->setUsername('testuser'); + $user->setEmail('test@example.com'); + $user->setPasswordHash('hash'); + $user->setRole(User::ROLE_ADMIN); + + $array = $user->toArray(); + + $this->assertIsArray($array); + $this->assertEquals(1, $array['id']); + $this->assertEquals('testuser', $array['username']); + $this->assertEquals('test@example.com', $array['email']); + $this->assertEquals(User::ROLE_ADMIN, $array['role']); + } + + public function testFromArray(): void + { + $data = [ + 'id' => 1, + 'username' => 'testuser', + 'email' => 'test@example.com', + 'password_hash' => 'hash', + 'role' => User::ROLE_EDITOR, + 'status' => User::STATUS_ACTIVE, + 'email_verified' => true, + 'failed_login_attempts' => 3 + ]; + + $user = User::fromArray($data); + + $this->assertEquals(1, $user->getId()); + $this->assertEquals('testuser', $user->getUsername()); + $this->assertEquals('test@example.com', $user->getEmail()); + $this->assertEquals(User::ROLE_EDITOR, $user->getRole()); + $this->assertEquals(User::STATUS_ACTIVE, $user->getStatus()); + $this->assertTrue($user->isEmailVerified()); + $this->assertEquals(3, $user->getFailedLoginAttempts()); + } + + public function testCreatedAtSetOnConstruct(): void + { + $user = new User(); + + $this->assertInstanceOf(DateTimeImmutable::class, $user->getCreatedAt()); + } +} diff --git a/tests/Cms/BlogControllerTest.php b/tests/Cms/BlogControllerTest.php index 4d4aba3..e4ccc01 100644 --- a/tests/Cms/BlogControllerTest.php +++ b/tests/Cms/BlogControllerTest.php @@ -2,33 +2,32 @@ namespace Tests\Cms; -use Blahg\Article; -use Blahg\Exception\ArticleMissingBody; -use Blahg\Exception\ArticleNotFound; -use Blahg\Repository; +use DateTimeImmutable; use Neuron\Cms\Controllers\Blog; -use Neuron\Data\Filter\Get; +use Neuron\Cms\Models\Post; +use Neuron\Cms\Models\Category; +use Neuron\Cms\Models\Tag; +use Neuron\Cms\Repositories\DatabasePostRepository; +use Neuron\Cms\Repositories\DatabaseCategoryRepository; +use Neuron\Cms\Repositories\DatabaseTagRepository; use Neuron\Data\Setting\Source\Memory; +use Neuron\Data\Setting\SettingManager; use Neuron\Mvc\Requests\Request; use Neuron\Patterns\Registry; -use Neuron\Routing\Router; +use PDO; use PHPUnit\Framework\TestCase; class BlogControllerTest extends TestCase { - private Blog $Blog; - private $MockRouter; - private $MockRepository; - private $MockGet; + private PDO $_PDO; + private DatabasePostRepository $_PostRepository; + private DatabaseCategoryRepository $_CategoryRepository; + private DatabaseTagRepository $_TagRepository; private $OriginalRegistry; - private $OriginalCwd; - + protected function setUp(): void { parent::setUp(); - - // Store original working directory - $this->OriginalCwd = getcwd(); // Store original registry values $this->OriginalRegistry = [ @@ -36,29 +35,43 @@ protected function setUp(): void 'Base.Path' => Registry::getInstance()->get( 'Base.Path' ), 'Views.Path' => Registry::getInstance()->get( 'Views.Path' ) ]; - - // Set up mock settings + + // Set up in-memory database + $this->_PDO = new PDO( + 'sqlite::memory:', + null, + null, + [ + PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION, + PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC + ] + ); + + // Create tables + $this->createTables(); + + // Set up Settings with database config $Settings = new Memory(); $Settings->set( 'site', 'name', 'Test Blog' ); $Settings->set( 'site', 'title', 'Test Blog Title' ); $Settings->set( 'site', 'description', 'Test Blog Description' ); $Settings->set( 'site', 'url', 'http://test.com' ); - Registry::getInstance()->set( 'Settings', $Settings ); - - // Set paths for views - Registry::getInstance()->set( 'Base.Path', __DIR__ . '/..' ); - Registry::getInstance()->set( 'Views.Path', __DIR__ . '/../resources/views' ); - - // Create mock router - $this->MockRouter = $this->createMock( Router::class ); - - // Create mock repository - $this->MockRepository = $this->createMock( Repository::class ); - - // Create mock Get filter - $this->MockGet = $this->createMock( Get::class ); + $Settings->set( 'database', 'adapter', 'sqlite' ); + $Settings->set( 'database', 'name', ':memory:' ); + + // Wrap in SettingManager + $SettingManager = new SettingManager( $Settings ); + + Registry::getInstance()->set( 'Settings', $SettingManager ); + + // Set paths for views - point to CMS component's resources + Registry::getInstance()->set( 'Base.Path', __DIR__ . '/../..' ); + Registry::getInstance()->set( 'Views.Path', __DIR__ . '/../../resources/views' ); + + // Initialize repositories with our test PDO + $this->initializeRepositories(); } - + protected function tearDown(): void { // Restore original registry values @@ -66,415 +79,279 @@ protected function tearDown(): void { Registry::getInstance()->set( $Key, $Value ); } - // Restore original working directory - chdir( $this->OriginalCwd ); parent::tearDown(); } - - /** - * Create a Blog instance with mocked dependencies - */ - private function createBlogWithMockedRepository(): Blog + + private function createTables(): void + { + // Create posts table + $this->_PDO->exec( " + CREATE TABLE posts ( + id INTEGER PRIMARY KEY AUTOINCREMENT, + title VARCHAR(255) NOT NULL, + slug VARCHAR(255) NOT NULL UNIQUE, + body TEXT NOT NULL, + excerpt TEXT, + featured_image VARCHAR(255), + author_id INTEGER NOT NULL, + status VARCHAR(20) DEFAULT 'draft', + published_at TIMESTAMP, + view_count INTEGER DEFAULT 0, + created_at TIMESTAMP NOT NULL, + updated_at TIMESTAMP + ) + " ); + + // Create categories table + $this->_PDO->exec( " + CREATE TABLE categories ( + id INTEGER PRIMARY KEY AUTOINCREMENT, + name VARCHAR(255) NOT NULL, + slug VARCHAR(255) NOT NULL UNIQUE, + description TEXT, + created_at TIMESTAMP NOT NULL, + updated_at TIMESTAMP + ) + " ); + + // Create tags table + $this->_PDO->exec( " + CREATE TABLE tags ( + id INTEGER PRIMARY KEY AUTOINCREMENT, + name VARCHAR(100) NOT NULL, + slug VARCHAR(100) NOT NULL UNIQUE, + created_at TIMESTAMP NOT NULL, + updated_at TIMESTAMP + ) + " ); + + // Create junction tables + $this->_PDO->exec( " + CREATE TABLE post_categories ( + post_id INTEGER NOT NULL, + category_id INTEGER NOT NULL, + created_at TIMESTAMP NOT NULL, + PRIMARY KEY (post_id, category_id), + FOREIGN KEY (post_id) REFERENCES posts(id) ON DELETE CASCADE, + FOREIGN KEY (category_id) REFERENCES categories(id) ON DELETE CASCADE + ) + " ); + + $this->_PDO->exec( " + CREATE TABLE post_tags ( + post_id INTEGER NOT NULL, + tag_id INTEGER NOT NULL, + created_at TIMESTAMP NOT NULL, + PRIMARY KEY (post_id, tag_id), + FOREIGN KEY (post_id) REFERENCES posts(id) ON DELETE CASCADE, + FOREIGN KEY (tag_id) REFERENCES tags(id) ON DELETE CASCADE + ) + " ); + } + + private function initializeRepositories(): void { - // We'll use reflection to inject the mock repository + $pdo = $this->_PDO; + + // Create repositories using reflection to inject PDO + $this->_PostRepository = new class( $pdo ) extends DatabasePostRepository + { + public function __construct( PDO $PDO ) + { + $reflection = new \ReflectionClass( DatabasePostRepository::class ); + $property = $reflection->getProperty( '_PDO' ); + $property->setAccessible( true ); + $property->setValue( $this, $PDO ); + } + }; + + $this->_CategoryRepository = new class( $pdo ) extends DatabaseCategoryRepository + { + public function __construct( PDO $PDO ) + { + $reflection = new \ReflectionClass( DatabaseCategoryRepository::class ); + $property = $reflection->getProperty( '_PDO' ); + $property->setAccessible( true ); + $property->setValue( $this, $PDO ); + } + }; + + $this->_TagRepository = new class( $pdo ) extends DatabaseTagRepository + { + public function __construct( PDO $PDO ) + { + $reflection = new \ReflectionClass( DatabaseTagRepository::class ); + $property = $reflection->getProperty( '_PDO' ); + $property->setAccessible( true ); + $property->setValue( $this, $PDO ); + } + }; + } + + private function createBlogWithInjectedRepositories(): Blog + { + // Create Blog controller $Blog = new Blog(); - - // Use reflection to replace the private $repository property - $Reflection = new \ReflectionClass( $Blog ); - $RepoProperty = $Reflection->getProperty( 'repository' ); - $RepoProperty->setAccessible( true ); - $RepoProperty->setValue( $Blog, $this->MockRepository ); - + + // Inject our test repositories using reflection + $reflection = new \ReflectionClass( $Blog ); + + $postRepoProp = $reflection->getProperty( '_PostRepository' ); + $postRepoProp->setAccessible( true ); + $postRepoProp->setValue( $Blog, $this->_PostRepository ); + + $categoryRepoProp = $reflection->getProperty( '_CategoryRepository' ); + $categoryRepoProp->setAccessible( true ); + $categoryRepoProp->setValue( $Blog, $this->_CategoryRepository ); + + $tagRepoProp = $reflection->getProperty( '_TagRepository' ); + $tagRepoProp->setAccessible( true ); + $tagRepoProp->setValue( $Blog, $this->_TagRepository ); + return $Blog; } - - /** - * Create sample articles for testing - */ - private function createSampleArticle( string $Title = 'Test Article', string $Slug = 'test-article' ): Article + + private function createTestPost( + string $title, + string $slug, + string $status = Post::STATUS_PUBLISHED, + int $authorId = 1 + ): Post { - $Article = new Article(); - $Article->setTitle( $Title ); - $Article->setSlug( $Slug ); - $Article->setBody( 'This is test content.' ); - $Article->setTags( [ 'test', 'php' ] ); - $Article->setCategory( 'Testing' ); - $Article->setDatePublished( '2024-01-15' ); - $Article->setAuthor( 'Test Author' ); - - return $Article; + $post = new Post(); + $post->setTitle( $title ); + $post->setSlug( $slug ); + $post->setBody( 'This is test content for ' . $title ); + $post->setAuthorId( $authorId ); + $post->setStatus( $status ); + + if( $status === Post::STATUS_PUBLISHED ) + { + $post->setPublishedAt( new DateTimeImmutable() ); + } + + return $this->_PostRepository->create( $post ); } - - /** - * Test index method returns all articles - */ - public function testIndexReturnsAllArticles() + + private function createTestCategory( string $name, string $slug ): Category { - $Blog = $this->createBlogWithMockedRepository(); - - // Set up mock data - $Articles = [ - $this->createSampleArticle( 'Article 1', 'article-1' ), - $this->createSampleArticle( 'Article 2', 'article-2' ), - $this->createSampleArticle( 'Article 3', 'article-3' ) - ]; - - $Categories = [ 'Testing', 'Development', 'News' ]; - $Tags = [ 'test', 'php', 'coding' ]; - - // Configure mock repository - $this->MockRepository->expects( $this->once() ) - ->method( 'getArticles' ) - ->willReturn( $Articles ); - - $this->MockRepository->expects( $this->once() ) - ->method( 'getCategories' ) - ->willReturn( $Categories ); - - $this->MockRepository->expects( $this->once() ) - ->method( 'getTags' ) - ->willReturn( $Tags ); - - // Call the method - $Result = $Blog->index( [], null ); - - // Verify the result is a string (HTML output) - $this->assertIsString( $Result ); + $category = new Category(); + $category->setName( $name ); + $category->setSlug( $slug ); + + return $this->_CategoryRepository->create( $category ); } - - /** - * Test show method with valid article slug - */ - public function testShowWithValidSlug() + + private function createTestTag( string $name, string $slug ): Tag { - $Blog = $this->createBlogWithMockedRepository(); - - $Article = $this->createSampleArticle( 'Test Article', 'test-article' ); - $Categories = [ 'Testing' ]; - $Tags = [ 'test', 'php' ]; - - // Configure mock repository - $this->MockRepository->expects( $this->once() ) - ->method( 'getArticleBySlug' ) - ->with( 'test-article' ) - ->willReturn( $Article ); - - $this->MockRepository->expects( $this->once() ) - ->method( 'getCategories' ) - ->willReturn( $Categories ); - - $this->MockRepository->expects( $this->once() ) - ->method( 'getTags' ) - ->willReturn( $Tags ); - - // Call the method - $Parameters = [ 'title' => 'test-article' ]; - $Result = $Blog->show( $Parameters, null ); - - // Verify the result is a string - $this->assertIsString( $Result ); + $tag = new Tag(); + $tag->setName( $name ); + $tag->setSlug( $slug ); + + return $this->_TagRepository->create( $tag ); } - - /** - * Test show method when article is not found - */ - public function testShowWithArticleNotFound() + + public function testIndexReturnsPublishedPosts(): void { - $Blog = $this->createBlogWithMockedRepository(); - - $Categories = [ 'Testing' ]; - $Tags = [ 'test', 'php' ]; - - // Configure mock repository to throw ArticleNotFound - $this->MockRepository->expects( $this->once() ) - ->method( 'getArticleBySlug' ) - ->with( 'non-existent' ) - ->willThrowException( new ArticleNotFound( 'Article not found' ) ); - - $this->MockRepository->expects( $this->once() ) - ->method( 'getCategories' ) - ->willReturn( $Categories ); - - $this->MockRepository->expects( $this->once() ) - ->method( 'getTags' ) - ->willReturn( $Tags ); - - // Call the method - $Parameters = [ 'title' => 'non-existent' ]; - $Result = $Blog->show( $Parameters, null ); - - // Verify the result is a string (should show error article) - $this->assertIsString( $Result ); - // The error article would have 'Character Not Found' as title + $this->createTestPost( 'Published Post 1', 'published-1', Post::STATUS_PUBLISHED ); + $this->createTestPost( 'Published Post 2', 'published-2', Post::STATUS_PUBLISHED ); + $this->createTestPost( 'Draft Post', 'draft-1', Post::STATUS_DRAFT ); + + $blog = $this->createBlogWithInjectedRepositories(); + $result = $blog->index( [], null ); + + $this->assertIsString( $result ); + // Should contain published posts but not drafts } - - /** - * Test show method when article is missing body - */ - public function testShowWithArticleMissingBody() + + public function testShowWithValidSlug(): void { - $Blog = $this->createBlogWithMockedRepository(); - - $Categories = [ 'Testing' ]; - $Tags = [ 'test', 'php' ]; - - // Configure mock repository to throw ArticleMissingBody - $this->MockRepository->expects( $this->once() ) - ->method( 'getArticleBySlug' ) - ->with( 'no-body' ) - ->willThrowException( new ArticleMissingBody( 'Article body missing' ) ); - - $this->MockRepository->expects( $this->once() ) - ->method( 'getCategories' ) - ->willReturn( $Categories ); - - $this->MockRepository->expects( $this->once() ) - ->method( 'getTags' ) - ->willReturn( $Tags ); - - // Call the method - $Parameters = [ 'title' => 'no-body' ]; - $Result = $Blog->show( $Parameters, null ); - - // Verify the result is a string (should show error article) - $this->assertIsString( $Result ); - // The error article would have 'Article Body Not Found' as title + $post = $this->createTestPost( 'Test Article', 'test-article', Post::STATUS_PUBLISHED ); + + $blog = $this->createBlogWithInjectedRepositories(); + $result = $blog->show( [ 'title' => 'test-article' ], null ); + + $this->assertIsString( $result ); } - - /** - * Test tag method filters articles by tag - */ - public function testTagFiltersArticlesByTag() + + public function testShowWithNonexistentSlug(): void { - $Blog = $this->createBlogWithMockedRepository(); - - $Tag = 'php'; - $Articles = [ - $this->createSampleArticle( 'PHP Article 1', 'php-article-1' ), - $this->createSampleArticle( 'PHP Article 2', 'php-article-2' ) - ]; - $Categories = [ 'Testing', 'Development' ]; - $Tags = [ 'test', 'php', 'coding' ]; - - // Configure mock repository - $this->MockRepository->expects( $this->once() ) - ->method( 'getArticlesByTag' ) - ->with( $Tag ) - ->willReturn( $Articles ); - - $this->MockRepository->expects( $this->once() ) - ->method( 'getCategories' ) - ->willReturn( $Categories ); - - $this->MockRepository->expects( $this->once() ) - ->method( 'getTags' ) - ->willReturn( $Tags ); - - // Call the method - $Parameters = [ 'tag' => $Tag ]; - $Result = $Blog->tag( $Parameters, null ); - - // Verify the result is a string - $this->assertIsString( $Result ); + $blog = $this->createBlogWithInjectedRepositories(); + $result = $blog->show( [ 'title' => 'nonexistent' ], null ); + + $this->assertIsString( $result ); + // Should handle gracefully } - - /** - * Test category method filters articles by category - */ - public function testCategoryFiltersArticlesByCategory() + + public function testTagFiltersPostsByTag(): void { - $Blog = $this->createBlogWithMockedRepository(); - - $Category = 'Development'; - $Articles = [ - $this->createSampleArticle( 'Dev Article 1', 'dev-article-1' ), - $this->createSampleArticle( 'Dev Article 2', 'dev-article-2' ), - $this->createSampleArticle( 'Dev Article 3', 'dev-article-3' ) - ]; - $Categories = [ 'Testing', 'Development', 'News' ]; - $Tags = [ 'test', 'php', 'coding' ]; - - // Configure mock repository - $this->MockRepository->expects( $this->once() ) - ->method( 'getArticlesByCategory' ) - ->with( $Category ) - ->willReturn( $Articles ); - - $this->MockRepository->expects( $this->once() ) - ->method( 'getCategories' ) - ->willReturn( $Categories ); - - $this->MockRepository->expects( $this->once() ) - ->method( 'getTags' ) - ->willReturn( $Tags ); - - // Call the method - $Parameters = [ 'category' => $Category ]; - $Result = $Blog->category( $Parameters, null ); - - // Verify the result is a string - $this->assertIsString( $Result ); + $tag = $this->createTestTag( 'PHP', 'php' ); + + $post1 = $this->createTestPost( 'PHP Post', 'php-post', Post::STATUS_PUBLISHED ); + $post1->addTag( $tag ); + $this->_PostRepository->update( $post1 ); + + $this->createTestPost( 'Other Post', 'other-post', Post::STATUS_PUBLISHED ); + + $blog = $this->createBlogWithInjectedRepositories(); + $result = $blog->tag( [ 'tag' => $tag->getSlug() ], null ); + + $this->assertIsString( $result ); } - - /** - * Test feed method generates RSS feed - */ - public function testFeedGeneratesRssFeed() + + public function testCategoryFiltersPostsByCategory(): void { - // Create a temporary directory for test articles - $TestDir = sys_get_temp_dir() . '/test_blog_' . uniqid(); - mkdir( $TestDir, 0777, true ); - - // Create test article files in YAML format (Repository expects .yaml files) - // The Repository requires 'datePublished' and 'path' fields - // Body content is stored in separate markdown files - // IMPORTANT: 'path' should be relative to the repository root, not absolute - - // Create body content files - file_put_contents( $TestDir . '/feed-article-1-body.md', 'This is test content.' ); - file_put_contents( $TestDir . '/feed-article-2-body.md', 'This is test content.' ); - - $Article1Content = [ - 'title' => 'Feed Article 1', - 'slug' => 'feed-article-1', - 'datePublished' => '2024-01-15', - 'path' => 'feed-article-1-body.md', // Relative path from repository root - 'tags' => ['test', 'php'], - 'category' => 'Testing', - 'author' => 'Test Author' - ]; - - $Article2Content = [ - 'title' => 'Feed Article 2', - 'slug' => 'feed-article-2', - 'datePublished' => '2024-01-15', - 'path' => 'feed-article-2-body.md', // Relative path from repository root - 'tags' => ['test', 'php'], - 'category' => 'Testing', - 'author' => 'Test Author' - ]; - - file_put_contents( $TestDir . '/feed-article-1.yaml', \Symfony\Component\Yaml\Yaml::dump( $Article1Content ) ); - file_put_contents( $TestDir . '/feed-article-2.yaml', \Symfony\Component\Yaml\Yaml::dump( $Article2Content ) ); - - // Create a Blog with a real Repository pointing to our test directory - $Blog = new Blog(); - $Repository = new Repository( $TestDir, false ); - $Blog->setRepository( $Repository ); - - // Call the feed method - $Parameters = []; - $Result = $Blog->feed( $Parameters, null ); - - // Verify the result is a string (RSS feed) - $this->assertIsString( $Result ); - - // Verify it's valid RSS - $this->assertStringContainsString( 'assertStringContainsString( '