Ty Clifford
647 lines
21 KiB
PHP
Executable File
647 lines
21 KiB
PHP
Executable File
#!/usr/bin/env php
|
|
<?php
|
|
declare(strict_types=1);
|
|
|
|
use NeonBlog\ContentRepository;
|
|
|
|
$app = require dirname(__DIR__) . '/app/bootstrap.php';
|
|
$repo = $app->repository();
|
|
$comments = $app->comments();
|
|
|
|
[$args, $opts] = parseArguments(array_slice($_SERVER['argv'] ?? [], 1));
|
|
|
|
if (isset($opts['help']) || isset($opts['h']) || ($args === [] && !isset($opts['source']))) {
|
|
help();
|
|
exit(isset($opts['help']) || isset($opts['h']) ? 0 : 1);
|
|
}
|
|
|
|
$source = (string) ($opts['source'] ?? $args[0]);
|
|
$dryRun = isset($opts['dry-run']);
|
|
$overwrite = isset($opts['overwrite']);
|
|
$skipUploads = isset($opts['skip-uploads']);
|
|
$skipComments = isset($opts['skip-comments']);
|
|
|
|
try {
|
|
$paths = resolveBluditSource($source);
|
|
$siteDb = readDatabase($paths['databases'] . '/site.php')
|
|
?: readDatabase($paths['databases'] . '/site.json');
|
|
$timezone = (string) ($opts['source-timezone'] ?? $siteDb['timezone'] ?? date_default_timezone_get());
|
|
|
|
$pagesDb = readDatabase($paths['databases'] . '/pages.php')
|
|
?: readDatabase($paths['databases'] . '/pages.json');
|
|
$categoriesDb = readDatabase($paths['databases'] . '/categories.php')
|
|
?: readDatabase($paths['databases'] . '/categories.json');
|
|
$tagsDb = readDatabase($paths['databases'] . '/tags.php')
|
|
?: readDatabase($paths['databases'] . '/tags.json');
|
|
|
|
$entries = discoverPages($paths['pages'], $pagesDb);
|
|
if ($entries === []) {
|
|
fail('No Bludit pages were found in ' . $paths['pages']);
|
|
}
|
|
|
|
$summary = [
|
|
'source' => $paths['content'],
|
|
'dry_run' => $dryRun,
|
|
'pages_found' => count($entries),
|
|
'content_imported' => 0,
|
|
'uploads_copied' => 0,
|
|
'page_assets_copied' => 0,
|
|
'comments_imported' => 0,
|
|
'skipped' => [],
|
|
];
|
|
|
|
$slugMap = [];
|
|
$reservedSlugs = [];
|
|
foreach ($entries as $entry) {
|
|
$oldKey = (string) $entry['key'];
|
|
$row = is_array($entry['db']) ? $entry['db'] : [];
|
|
$contentPath = $entry['path'];
|
|
$markdown = is_file($contentPath) ? (string) file_get_contents($contentPath) : '';
|
|
$baseSlug = slugFromBluditKey($oldKey);
|
|
$slug = uniqueSlug($repo, $baseSlug, $reservedSlugs, $overwrite);
|
|
$reservedSlugs[$slug] = true;
|
|
$metadata = metadataFromBludit($oldKey, $row, $markdown, $categoriesDb, $tagsDb, $timezone);
|
|
|
|
$slugMap[$oldKey] = $slug;
|
|
if (!$dryRun) {
|
|
$repo->saveImported($slug, $metadata, $markdown, false);
|
|
}
|
|
$summary['page_assets_copied'] += copyPageAssets(dirname($contentPath), BLOG_ROOT . '/bl-content/pages/' . $slug, $dryRun);
|
|
$summary['content_imported']++;
|
|
|
|
printf(
|
|
"%s %-10s %-10s %s -> %s\n",
|
|
$dryRun ? 'Would import' : 'Imported',
|
|
$metadata['type'],
|
|
$metadata['status'],
|
|
$oldKey,
|
|
$slug
|
|
);
|
|
}
|
|
|
|
if (!$skipUploads && is_dir($paths['uploads'])) {
|
|
$summary['uploads_copied'] = copyTree($paths['uploads'], BLOG_ROOT . '/bl-content/uploads', $dryRun);
|
|
line(($dryRun ? 'Would copy' : 'Copied') . ' uploads from ' . $paths['uploads']);
|
|
}
|
|
|
|
if (!$skipComments) {
|
|
$commentFiles = [];
|
|
if (isset($opts['comments'])) {
|
|
$commentFiles[] = (string) $opts['comments'];
|
|
}
|
|
$commentFiles = array_merge($commentFiles, discoverCommentFiles($paths['content']));
|
|
$seenCommentFiles = [];
|
|
foreach ($commentFiles as $commentFile) {
|
|
$real = realpath($commentFile);
|
|
if ($real === false || isset($seenCommentFiles[$real])) {
|
|
continue;
|
|
}
|
|
$seenCommentFiles[$real] = true;
|
|
$records = readComments($real);
|
|
foreach ($records as $record) {
|
|
$oldSlug = (string) ($record['slug'] ?? '');
|
|
$slug = $slugMap[$oldSlug] ?? $slugMap[str_replace('-', '/', $oldSlug)] ?? ContentRepository::slugify($oldSlug);
|
|
$body = trim((string) ($record['body'] ?? $record['content'] ?? $record['comment'] ?? ''));
|
|
if ($slug === '' || $body === '') {
|
|
continue;
|
|
}
|
|
if (!$dryRun) {
|
|
$comments->import($slug, [
|
|
'author' => $record['author'] ?? $record['name'] ?? 'Imported',
|
|
'email' => $record['email'] ?? '',
|
|
'website' => $record['website'] ?? $record['url'] ?? '',
|
|
'body' => $body,
|
|
'status' => $record['status'] ?? 'approved',
|
|
'created_at' => normalizeDate((string) ($record['date'] ?? $record['created_at'] ?? ''), $timezone),
|
|
'updated_at' => normalizeDate((string) ($record['modified'] ?? $record['updated_at'] ?? $record['date'] ?? ''), $timezone),
|
|
'user_agent' => $record['user_agent'] ?? $record['agent'] ?? 'bludit-import',
|
|
]);
|
|
}
|
|
$summary['comments_imported']++;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!$dryRun) {
|
|
$repo->rebuildIndex();
|
|
}
|
|
|
|
line('');
|
|
line('Import summary:');
|
|
foreach ($summary as $key => $value) {
|
|
if (is_array($value)) {
|
|
continue;
|
|
}
|
|
line(' ' . $key . ': ' . (is_bool($value) ? ($value ? 'yes' : 'no') : (string) $value));
|
|
}
|
|
} catch (Throwable $error) {
|
|
fail($error->getMessage());
|
|
}
|
|
|
|
function help(): void
|
|
{
|
|
echo <<<TEXT
|
|
Import Bludit content from a local directory on this server.
|
|
|
|
Usage:
|
|
php cli/import-bludit.php /var/www/old-bludit
|
|
php cli/import-bludit.php /var/www/old-bludit/bl-content
|
|
php cli/import-bludit.php --source=/var/www/old-bludit --dry-run
|
|
|
|
Options:
|
|
--source=/path Local Bludit root or bl-content directory.
|
|
--dry-run Show what would import without writing files.
|
|
--overwrite Reuse matching slugs instead of adding numeric suffixes.
|
|
--skip-uploads Do not copy bl-content/uploads.
|
|
--skip-comments Do not scan/import local comment data.
|
|
--comments=/path/file Extra local JSON/PHP/CSV comment export to import.
|
|
--source-timezone=Zone Timezone for Bludit database dates without offsets.
|
|
|
|
Preserves:
|
|
Original publish dates, modified dates, static pages, post status, categories,
|
|
tags, authors, cover image metadata, allow-comments flags, page order, uploads,
|
|
page-local files, and best-effort local comments.
|
|
|
|
TEXT;
|
|
}
|
|
|
|
/** @return array{0: array<int, string>, 1: array<string, mixed>} */
|
|
function parseArguments(array $argv): array
|
|
{
|
|
$args = [];
|
|
$opts = [];
|
|
foreach ($argv as $arg) {
|
|
if (str_starts_with($arg, '--')) {
|
|
$option = substr($arg, 2);
|
|
if (str_contains($option, '=')) {
|
|
[$key, $value] = explode('=', $option, 2);
|
|
$opts[$key] = $value;
|
|
} else {
|
|
$opts[$option] = true;
|
|
}
|
|
} elseif (str_starts_with($arg, '-')) {
|
|
$opts[ltrim($arg, '-')] = true;
|
|
} else {
|
|
$args[] = $arg;
|
|
}
|
|
}
|
|
|
|
return [$args, $opts];
|
|
}
|
|
|
|
/** @return array{root: string, content: string, pages: string, databases: string, uploads: string} */
|
|
function resolveBluditSource(string $source): array
|
|
{
|
|
$path = realpath($source);
|
|
if ($path === false || !is_dir($path)) {
|
|
fail('Source directory not found or not readable: ' . $source);
|
|
}
|
|
|
|
if (is_dir($path . '/bl-content')) {
|
|
$root = $path;
|
|
$content = $path . '/bl-content';
|
|
} elseif (basename($path) === 'bl-content' || is_dir($path . '/pages')) {
|
|
$content = $path;
|
|
$root = dirname($path);
|
|
} else {
|
|
fail('Source must be a Bludit root or a bl-content directory: ' . $source);
|
|
}
|
|
|
|
$pages = $content . '/pages';
|
|
$databases = $content . '/databases';
|
|
if (!is_dir($pages)) {
|
|
fail('Bludit pages directory not found: ' . $pages);
|
|
}
|
|
|
|
return [
|
|
'root' => $root,
|
|
'content' => $content,
|
|
'pages' => $pages,
|
|
'databases' => is_dir($databases) ? $databases : $content,
|
|
'uploads' => $content . '/uploads',
|
|
];
|
|
}
|
|
|
|
/** @return array<string, mixed> */
|
|
function readDatabase(string $path): array
|
|
{
|
|
if (!is_file($path)) {
|
|
return [];
|
|
}
|
|
|
|
$raw = (string) file_get_contents($path);
|
|
$json = trim($raw);
|
|
$firstObject = strpos($json, '{');
|
|
$firstArray = strpos($json, '[');
|
|
$start = false;
|
|
if ($firstObject !== false && $firstArray !== false) {
|
|
$start = min($firstObject, $firstArray);
|
|
} elseif ($firstObject !== false) {
|
|
$start = $firstObject;
|
|
} elseif ($firstArray !== false) {
|
|
$start = $firstArray;
|
|
}
|
|
if ($start !== false) {
|
|
$json = substr($json, $start);
|
|
}
|
|
|
|
$decoded = json_decode($json, true);
|
|
return is_array($decoded) ? $decoded : [];
|
|
}
|
|
|
|
/** @return array<int, array{key: string, path: string, db: array<string, mixed>}> */
|
|
function discoverPages(string $pagesRoot, array $pagesDb): array
|
|
{
|
|
$entries = [];
|
|
if ($pagesDb !== []) {
|
|
foreach ($pagesDb as $key => $row) {
|
|
$file = $pagesRoot . '/' . $key . '/index.txt';
|
|
if (is_file($file)) {
|
|
$entries[] = [
|
|
'key' => (string) $key,
|
|
'path' => $file,
|
|
'db' => is_array($row) ? $row : [],
|
|
];
|
|
}
|
|
}
|
|
}
|
|
|
|
if ($entries !== []) {
|
|
return $entries;
|
|
}
|
|
|
|
$iterator = new RecursiveIteratorIterator(
|
|
new RecursiveDirectoryIterator($pagesRoot, FilesystemIterator::SKIP_DOTS)
|
|
);
|
|
foreach ($iterator as $file) {
|
|
if (!$file->isFile() || $file->getFilename() !== 'index.txt') {
|
|
continue;
|
|
}
|
|
$directory = dirname($file->getPathname());
|
|
$key = trim(str_replace($pagesRoot, '', $directory), DIRECTORY_SEPARATOR);
|
|
$entries[] = [
|
|
'key' => str_replace(DIRECTORY_SEPARATOR, '/', $key),
|
|
'path' => $file->getPathname(),
|
|
'db' => [],
|
|
];
|
|
}
|
|
|
|
usort($entries, static fn (array $a, array $b): int => strcmp($a['key'], $b['key']));
|
|
return $entries;
|
|
}
|
|
|
|
/** @param array<string, mixed> $row @param array<string, mixed> $categories @param array<string, mixed> $tags */
|
|
function metadataFromBludit(string $key, array $row, string $markdown, array $categories, array $tags, string $timezone): array
|
|
{
|
|
$bluditType = (string) ($row['type'] ?? 'published');
|
|
$type = $bluditType === 'static' ? 'page' : 'post';
|
|
$status = in_array($bluditType, ['published', 'static', 'sticky'], true) ? 'published' : 'draft';
|
|
$categoryKey = (string) ($row['category'] ?? '');
|
|
$coverImage = (string) ($row['coverImage'] ?? '');
|
|
if ($coverImage !== '' && !filter_var($coverImage, FILTER_VALIDATE_URL)) {
|
|
$uuid = (string) ($row['uuid'] ?? '');
|
|
$coverImage = $uuid !== ''
|
|
? '/bl-content/uploads/pages/' . $uuid . '/' . ltrim($coverImage, '/')
|
|
: '/bl-content/uploads/' . ltrim($coverImage, '/');
|
|
}
|
|
|
|
return [
|
|
'title' => trim((string) ($row['title'] ?? '')) !== ''
|
|
? (string) $row['title']
|
|
: titleFromMarkdownOrKey($markdown, $key),
|
|
'type' => $type,
|
|
'status' => $status,
|
|
'date' => normalizeDate((string) ($row['date'] ?? ''), $timezone),
|
|
'modified' => normalizeDate((string) ($row['dateModified'] ?? $row['date'] ?? ''), $timezone),
|
|
'category' => categoryName($categoryKey, $categories),
|
|
'tags' => tagNames($row['tags'] ?? [], $tags),
|
|
'summary' => (string) ($row['description'] ?? ''),
|
|
'author' => (string) ($row['username'] ?? 'Imported'),
|
|
'cover' => $coverImage,
|
|
'allow_comments' => (bool) ($row['allowComments'] ?? true),
|
|
'menu_order' => (int) ($row['position'] ?? 0),
|
|
];
|
|
}
|
|
|
|
function normalizeDate(string $value, string $timezone): string
|
|
{
|
|
$value = trim($value);
|
|
if ($value === '') {
|
|
return date('c');
|
|
}
|
|
|
|
try {
|
|
$zone = new DateTimeZone($timezone);
|
|
} catch (Throwable) {
|
|
$zone = new DateTimeZone(date_default_timezone_get());
|
|
}
|
|
|
|
try {
|
|
$date = DateTimeImmutable::createFromFormat('Y-m-d H:i:s', $value, $zone)
|
|
?: DateTimeImmutable::createFromFormat(DateTimeInterface::ATOM, $value)
|
|
?: new DateTimeImmutable($value, $zone);
|
|
} catch (Throwable) {
|
|
$date = new DateTimeImmutable('now', $zone);
|
|
}
|
|
|
|
return $date->format(DateTimeInterface::ATOM);
|
|
}
|
|
|
|
function categoryName(string $key, array $categories): string
|
|
{
|
|
if ($key !== '' && isset($categories[$key]) && is_array($categories[$key])) {
|
|
return (string) ($categories[$key]['name'] ?? $key);
|
|
}
|
|
|
|
return $key !== '' ? ucwords(str_replace('-', ' ', $key)) : 'Notes';
|
|
}
|
|
|
|
function tagNames(mixed $rawTags, array $tagsDb): array
|
|
{
|
|
if (is_string($rawTags)) {
|
|
return ContentRepository::normalizeList($rawTags);
|
|
}
|
|
if (!is_array($rawTags)) {
|
|
return [];
|
|
}
|
|
|
|
$tags = [];
|
|
foreach ($rawTags as $key => $value) {
|
|
if (is_string($value) && $value !== '') {
|
|
$tags[] = $value;
|
|
} elseif (is_string($key) && isset($tagsDb[$key]) && is_array($tagsDb[$key])) {
|
|
$tags[] = (string) ($tagsDb[$key]['name'] ?? $key);
|
|
} elseif (is_string($key)) {
|
|
$tags[] = ucwords(str_replace('-', ' ', $key));
|
|
}
|
|
}
|
|
|
|
return ContentRepository::normalizeList($tags);
|
|
}
|
|
|
|
function titleFromMarkdownOrKey(string $markdown, string $key): string
|
|
{
|
|
foreach (explode("\n", $markdown) as $line) {
|
|
if (preg_match('/^#\s+(.+)$/', trim($line), $matches)) {
|
|
return trim($matches[1]);
|
|
}
|
|
}
|
|
|
|
return ucwords(str_replace(['-', '/'], ' ', $key));
|
|
}
|
|
|
|
function slugFromBluditKey(string $key): string
|
|
{
|
|
return ContentRepository::slugify(str_replace('/', '-', $key));
|
|
}
|
|
|
|
/** @param array<string, bool> $reserved */
|
|
function uniqueSlug(ContentRepository $repo, string $baseSlug, array $reserved, bool $overwrite): string
|
|
{
|
|
$baseSlug = $baseSlug !== '' ? $baseSlug : 'imported-page';
|
|
if ($overwrite) {
|
|
return $baseSlug;
|
|
}
|
|
|
|
$slug = $baseSlug;
|
|
$i = 2;
|
|
while (isset($reserved[$slug]) || $repo->find($slug, true) !== null) {
|
|
$slug = $baseSlug . '-' . $i;
|
|
$i++;
|
|
}
|
|
|
|
return $slug;
|
|
}
|
|
|
|
function copyPageAssets(string $sourceDir, string $targetDir, bool $dryRun): int
|
|
{
|
|
$count = 0;
|
|
foreach (glob($sourceDir . '/*') ?: [] as $path) {
|
|
if (basename($path) === 'index.txt') {
|
|
continue;
|
|
}
|
|
$count += copyTree($path, $targetDir . '/' . basename($path), $dryRun);
|
|
}
|
|
|
|
return $count;
|
|
}
|
|
|
|
function copyTree(string $source, string $target, bool $dryRun): int
|
|
{
|
|
if (!file_exists($source)) {
|
|
return 0;
|
|
}
|
|
$sourceReal = realpath($source);
|
|
$targetReal = realpath($target);
|
|
if ($sourceReal !== false && $targetReal !== false && $sourceReal === $targetReal) {
|
|
return 0;
|
|
}
|
|
if ($dryRun) {
|
|
if (is_file($source) || is_link($source)) {
|
|
return 1;
|
|
}
|
|
$count = 0;
|
|
$iterator = new RecursiveIteratorIterator(
|
|
new RecursiveDirectoryIterator($source, FilesystemIterator::SKIP_DOTS)
|
|
);
|
|
foreach ($iterator as $file) {
|
|
if ($file->isFile() || $file->isLink()) {
|
|
$count++;
|
|
}
|
|
}
|
|
return $count;
|
|
}
|
|
|
|
if (is_link($source)) {
|
|
$real = realpath($source);
|
|
return $real === false ? 0 : copyTree($real, $target, false);
|
|
}
|
|
if (is_file($source)) {
|
|
if (!is_dir(dirname($target))) {
|
|
mkdir(dirname($target), 0775, true);
|
|
}
|
|
copy($source, $target);
|
|
touch($target, filemtime($source) ?: time());
|
|
return 1;
|
|
}
|
|
|
|
if (!is_dir($target)) {
|
|
mkdir($target, 0775, true);
|
|
}
|
|
|
|
$count = 0;
|
|
$iterator = new RecursiveIteratorIterator(
|
|
new RecursiveDirectoryIterator($source, FilesystemIterator::SKIP_DOTS),
|
|
RecursiveIteratorIterator::SELF_FIRST
|
|
);
|
|
foreach ($iterator as $item) {
|
|
$relative = substr($item->getPathname(), strlen($source) + 1);
|
|
$destination = $target . '/' . $relative;
|
|
if ($item->isDir() && !$item->isLink()) {
|
|
if (!is_dir($destination)) {
|
|
mkdir($destination, 0775, true);
|
|
}
|
|
} else {
|
|
$count += copyTree($item->getPathname(), $destination, false);
|
|
}
|
|
}
|
|
|
|
return $count;
|
|
}
|
|
|
|
/** @return array<int, string> */
|
|
function discoverCommentFiles(string $contentRoot): array
|
|
{
|
|
$files = [];
|
|
foreach ([$contentRoot . '/databases', $contentRoot . '/workspaces'] as $root) {
|
|
if (!is_dir($root)) {
|
|
continue;
|
|
}
|
|
$iterator = new RecursiveIteratorIterator(
|
|
new RecursiveDirectoryIterator($root, FilesystemIterator::SKIP_DOTS)
|
|
);
|
|
foreach ($iterator as $file) {
|
|
if (!$file->isFile()) {
|
|
continue;
|
|
}
|
|
$name = strtolower($file->getFilename());
|
|
$extension = strtolower(pathinfo($name, PATHINFO_EXTENSION));
|
|
if (str_contains($name, 'comment') && in_array($extension, ['php', 'json', 'csv', 'sqlite', 'db'], true)) {
|
|
$files[] = $file->getPathname();
|
|
}
|
|
}
|
|
}
|
|
|
|
return $files;
|
|
}
|
|
|
|
/** @return array<int, array<string, mixed>> */
|
|
function readComments(string $path): array
|
|
{
|
|
$extension = strtolower(pathinfo($path, PATHINFO_EXTENSION));
|
|
if ($extension === 'csv') {
|
|
return readCommentCsv($path);
|
|
}
|
|
if (in_array($extension, ['sqlite', 'db'], true)) {
|
|
return readCommentSqlite($path);
|
|
}
|
|
|
|
return collectComments(readDatabase($path));
|
|
}
|
|
|
|
/** @return array<int, array<string, mixed>> */
|
|
function readCommentCsv(string $path): array
|
|
{
|
|
$handle = fopen($path, 'rb');
|
|
if (!$handle) {
|
|
return [];
|
|
}
|
|
$header = fgetcsv($handle, null, ',', '"', '') ?: [];
|
|
$records = [];
|
|
while (($row = fgetcsv($handle, null, ',', '"', '')) !== false) {
|
|
$record = array_combine($header, $row);
|
|
if (is_array($record)) {
|
|
$records[] = normalizeCommentRecord($record);
|
|
}
|
|
}
|
|
fclose($handle);
|
|
|
|
return $records;
|
|
}
|
|
|
|
/** @return array<int, array<string, mixed>> */
|
|
function readCommentSqlite(string $path): array
|
|
{
|
|
if (!class_exists(PDO::class)) {
|
|
return [];
|
|
}
|
|
|
|
try {
|
|
$pdo = new PDO('sqlite:' . $path);
|
|
$tables = $pdo->query("SELECT name FROM sqlite_master WHERE type='table'")->fetchAll(PDO::FETCH_COLUMN);
|
|
$records = [];
|
|
foreach ($tables as $table) {
|
|
if (!str_contains(strtolower((string) $table), 'comment')) {
|
|
continue;
|
|
}
|
|
$rows = $pdo->query('SELECT * FROM "' . str_replace('"', '""', (string) $table) . '"')->fetchAll(PDO::FETCH_ASSOC);
|
|
foreach ($rows as $row) {
|
|
$records[] = normalizeCommentRecord($row);
|
|
}
|
|
}
|
|
return $records;
|
|
} catch (Throwable) {
|
|
return [];
|
|
}
|
|
}
|
|
|
|
/** @return array<int, array<string, mixed>> */
|
|
function collectComments(mixed $value, string $slugHint = ''): array
|
|
{
|
|
if (!is_array($value)) {
|
|
return [];
|
|
}
|
|
if (isCommentRecord($value)) {
|
|
$record = normalizeCommentRecord($value);
|
|
if (($record['slug'] ?? '') === '' && $slugHint !== '') {
|
|
$record['slug'] = $slugHint;
|
|
}
|
|
return [$record];
|
|
}
|
|
|
|
$records = [];
|
|
foreach ($value as $key => $child) {
|
|
$nextHint = is_string($key) && $key !== '' && !is_numeric($key) ? $key : $slugHint;
|
|
foreach (collectComments($child, $nextHint) as $record) {
|
|
$records[] = $record;
|
|
}
|
|
}
|
|
|
|
return $records;
|
|
}
|
|
|
|
function isCommentRecord(array $value): bool
|
|
{
|
|
$bodyKeys = ['body', 'content', 'comment', 'message', 'text'];
|
|
$identityKeys = ['author', 'name', 'email', 'username'];
|
|
return array_intersect($bodyKeys, array_keys($value)) !== []
|
|
&& array_intersect($identityKeys, array_keys($value)) !== [];
|
|
}
|
|
|
|
/** @param array<string, mixed> $record @return array<string, mixed> */
|
|
function normalizeCommentRecord(array $record): array
|
|
{
|
|
$slug = (string) (
|
|
$record['slug']
|
|
?? $record['page']
|
|
?? $record['pageKey']
|
|
?? $record['page_key']
|
|
?? $record['post']
|
|
?? $record['post_slug']
|
|
?? ''
|
|
);
|
|
|
|
return [
|
|
'slug' => $slug,
|
|
'author' => $record['author'] ?? $record['name'] ?? $record['username'] ?? 'Imported',
|
|
'email' => $record['email'] ?? '',
|
|
'website' => $record['website'] ?? $record['url'] ?? $record['site'] ?? '',
|
|
'body' => $record['body'] ?? $record['content'] ?? $record['comment'] ?? $record['message'] ?? $record['text'] ?? '',
|
|
'status' => $record['status'] ?? $record['state'] ?? 'approved',
|
|
'date' => $record['date'] ?? $record['created'] ?? $record['created_at'] ?? '',
|
|
'modified' => $record['modified'] ?? $record['updated'] ?? $record['updated_at'] ?? '',
|
|
'user_agent' => $record['user_agent'] ?? $record['agent'] ?? '',
|
|
];
|
|
}
|
|
|
|
function line(string $message): void
|
|
{
|
|
echo $message . PHP_EOL;
|
|
}
|
|
|
|
function fail(string $message): never
|
|
{
|
|
fwrite(STDERR, $message . PHP_EOL);
|
|
exit(1);
|
|
}
|