@taon-dev/cms 21.0.24 → 21.0.25

package/ts-source/websql-code/taon-cms-content/i18n/taon-cms-content.controller.ts.pl-PL.po

@@ -4,34 +4,36 @@ msgstr ""
 "Content-Type: text/plain; charset=UTF-8\n"
 "Content-Transfer-Encoding: 8bit\n"
 
-#: src/lib/taon-cms-content/taon-cms-content.controller.ts:147
+#: src/lib/taon-cms-content/taon-cms-content.controller.ts:157
 msgid "You can't manage posts"
 msgstr "Nie możesz zarządzać wpisami"
 
-#: src/lib/taon-cms-content/taon-cms-content.controller.ts:261
+#: src/lib/taon-cms-content/taon-cms-content.controller.ts:271
 msgid "Content was not found."
 msgstr "Zawartość nie została znaleziona."
 
-#: src/lib/taon-cms-content/taon-cms-content.controller.ts:274
+#: src/lib/taon-cms-content/taon-cms-content.controller.ts:284
 msgid "Content has no [[ type ]] media."
 msgstr "Treść nie zawiera multimediów typu [[ type ]]."
 
-#: src/lib/taon-cms-content/taon-cms-content.controller.ts:281
+#: src/lib/taon-cms-content/taon-cms-content.controller.ts:291
 msgid "The media file was not found in storage."
 msgstr "Nie znaleziono pliku multimedialnego w magazynie danych."
 
-#: src/lib/taon-cms-content/taon-cms-content.controller.ts:319
+#: src/lib/taon-cms-content/taon-cms-content.controller.ts:329
 msgid "This content is not publicly accessible."
 msgstr "Zawartość ta nie jest dostępna publicznie."
 
-#: src/lib/taon-cms-content/taon-cms-content.controller.ts:334
+#: src/lib/taon-cms-content/taon-cms-content.controller.ts:344
 msgid "You do not have access to this content."
 msgstr "Nie masz dostępu do tej treści."
 
-#: src/lib/taon-cms-content/taon-cms-content.controller.ts:366
+#: src/lib/taon-cms-content/taon-cms-content.controller.ts:391
+#: src/lib/taon-cms-content/taon-cms-content.controller.ts:419
 msgid "The post slug is invalid."
 msgstr "Nieprawidłowy slug wpisu."
 
-#: src/lib/taon-cms-content/taon-cms-content.controller.ts:373
+#: src/lib/taon-cms-content/taon-cms-content.controller.ts:398
+#: src/lib/taon-cms-content/taon-cms-content.controller.ts:426
 msgid "The post was not found."
 msgstr "Nie znaleziono wpisu."

package/ts-source/websql-code/taon-cms-content/taon-cms-content-api.service.ts

@@ -21,7 +21,7 @@ import type { TaonCmsContentRevisionEntity } from '../taon-cms-content-revision/
 import { TaonCmsContentStorageController } from './taon-cms-content-storage.controller';
 import { TaonCmsContentController } from './taon-cms-content.controller';
 import type { TaonCmsContentEntity } from './taon-cms-content.entity';
-import type { TaonCmsCreateContent, TaonCmsRestoreContent, TaonCmsUpdateContent, TaonCmsPermissionConfiguration, TaonCmsPostVersionKind, TaonCmsPostVersionLinks, TaonCmsVisibilityConfiguration, } from './taon-cms-content.models';
+import type { TaonCmsCreateContent, TaonCmsCreateRelatedChildInput, TaonCmsCreateRelatedChildResult, TaonCmsPublicVideoChild, TaonCmsRestoreContent, TaonCmsUpdateContent, TaonCmsPermissionConfiguration, TaonCmsPostVersionKind, TaonCmsPostVersionLinks, TaonCmsVisibilityConfiguration, } from './taon-cms-content.models';
 import { trackCmsUpload } from './taon-cms-upload-progress';
 @Injectable()
 export class TaonCmsContentApiService<HOOKS extends TaonCmsApplicationHook = TaonCmsApplicationHook> extends TaonBaseAngularService {
@@ -52,6 +52,15 @@ export class TaonCmsContentApiService<HOOKS extends TaonCmsApplicationHook = Tao
         }
         return response.body.json;
     }
+    public async getPublicVideoChildrenBySlug(slug: string): Promise<TaonCmsPublicVideoChild[]> {
+        const response = await this.taonCmsContentController
+            .getPublicVideoChildrenBySlug(slug)
+            .request();
+        if (response.statusCode >= 400 || !Array.isArray(response.body?.json)) {
+            throw new Error(response.responseText || 'Public video children could not be loaded.');
+        }
+        return response.body.json;
+    }
     public getVideoLinkBySlug(slug: string): Observable<string> {
         return this.taonCmsContentController
             .getVideoLinkBySlug(slug)
@@ -123,6 +132,11 @@ export class TaonCmsContentApiService<HOOKS extends TaonCmsApplicationHook = Tao
             stopTracking?.();
         }
     }
+    public async deleteUnattachedMedia(key: string): Promise<boolean> {
+        return (await this.taonCmsContentStorageController
+            .deleteUnattachedMedia(key)
+            .request()).body.json;
+    }
     public listAssets(): Observable<TaonStorageObject[]> {
         return this.taonCmsContentStorageController
             .list({})
@@ -154,6 +168,11 @@ export class TaonCmsContentApiService<HOOKS extends TaonCmsApplicationHook = Tao
         return this.taonCmsContentController.createContent(input)
             .request!().observable.pipe(map(res => res.body.json));
     }
+    public async createRelatedChild(parentId: number, input: TaonCmsCreateRelatedChildInput): Promise<TaonCmsCreateRelatedChildResult> {
+        return (await this.taonCmsContentController
+            .createRelatedChild(parentId, input)
+            .request()).body.json;
+    }
     public duplicateContent(id: number, includeChildren = false): Observable<TaonCmsContentEntity> {
         return this.taonCmsContentController.duplicateContent(id, includeChildren)
             .request!().observable.pipe(map(res => res.body.json));

package/ts-source/websql-code/taon-cms-content/taon-cms-content-storage.controller.ts

@@ -12,7 +12,7 @@
 
 import { TaonSessionProvider, TaonSessionRepository, } from '@taon-dev/session/websql';
 import { TaonAuthContextRepository } from '@taon-dev/session/websql';
-import { ExpressRequest, ExpressResponse, TaonBaseStorageController, TaonController, TaonStorageObject, TaonUploadedFile, ClassHelpers, apiPrefix, Models, Taon, } from 'taon/websql';
+import { ExpressRequest, ExpressResponse, TaonBaseStorageController, TaonController, DELETE, Query, TaonStorageObject, TaonUploadedFile, ClassHelpers, apiPrefix, Models, Taon, } from 'taon/websql';
 import { UtilsJwt } from 'tnp-core/websql';
 import { TaonCmsContentRepository } from './taon-cms-content.repository';
 import { contentError } from './taon-cms-content.validation';
@@ -34,6 +34,15 @@ export class TaonCmsContentStorageController extends TaonBaseStorageController<{
     async isMediaObjectAvailable(key: string): Promise<boolean> {
         return (void 0);
     }
+    async isPublicMediaObject(key: string): Promise<boolean> {
+        return (void 0);
+    }
+    @DELETE()
+    deleteUnattachedMedia(
+    @Query('key')
+    key: string): Taon.Response<boolean> {
+        return (void 0);
+    }
     async copyMediaObjectForDuplication(sourceKey: string): Promise<string> {
         return (void 0);
     }

package/ts-source/websql-code/taon-cms-content/taon-cms-content.controller.ts

@@ -18,16 +18,19 @@ import type { TaonCmsApplicationHookEntity } from '../taon-cms-application-hook/
 import type { TaonCmsContentRevisionEntity } from '../taon-cms-content-revision/taon-cms-content-revision.entity';
 import { TaonCmsContentStorageController } from './taon-cms-content-storage.controller';
 import { TaonCmsContentEntity } from './taon-cms-content.entity';
-import type { TaonCmsCreateContent, TaonCmsRestoreContent, TaonCmsUpdateContent, TaonCmsPermissionConfiguration, TaonCmsPostVersionKind, TaonCmsPostVersionLinks, TaonCmsVisibilityConfiguration, } from './taon-cms-content.models';
+import type { TaonCmsCreateContent, TaonCmsCreateRelatedChildInput, TaonCmsCreateRelatedChildResult, TaonCmsPublicVideoChild, TaonCmsRestoreContent, TaonCmsUpdateContent, TaonCmsPermissionConfiguration, TaonCmsPostVersionKind, TaonCmsPostVersionLinks, TaonCmsVisibilityConfiguration, } from './taon-cms-content.models';
 import { TaonCmsContentRepository } from './taon-cms-content.repository';
 import { contentError } from './taon-cms-content.validation';
+import { defaultThumbnailKey, defaultThumbnailUrl, } from '../taon-posts/taon-cms-post/taon-cms-thumbnail';
 @TaonController<TaonCmsContentController>({
     className: 'TaonCmsContentController',
     allowedMethods: [
         'getAll',
         'getBy',
         'getPublicBySlug',
+        'getPublicVideoChildrenBySlug',
         'createContent',
+        'createRelatedChild',
         'duplicateContent',
         'permanentlyDeleteContent',
         'updateContent',
@@ -181,6 +184,18 @@ export class TaonCmsContentController extends TaonBaseCrudController<TaonCmsCont
         }
     }
     @GET()
+    getBy(
+    @Query('id')
+    id: number | string): Taon.Response<TaonCmsContentEntity> {
+        return () => {
+            const contentId = Number(id);
+            if (!Number.isSafeInteger(contentId) || contentId <= 0) {
+                contentError('contentId must be a positive integer.');
+            }
+            return this.taonCmsContentRepository.connection.transaction(manager => this.taonCmsContentRepository.requireContent(contentId, manager));
+        };
+    }
+    @GET()
     getBySlug(
     @Query(`slug`)
     slug: string): Taon.Response<TaonCmsContentEntity> {
@@ -214,12 +229,101 @@ export class TaonCmsContentController extends TaonBaseCrudController<TaonCmsCont
             });
         };
     }
+    @GET()
+    getPublicVideoChildrenBySlug(
+    @Query('slug')
+    slug: string): Taon.Response<TaonCmsPublicVideoChild[]> {
+        return async (req, _res, { t }) => {
+            const normalizedSlug = typeof slug === 'string' ? slug.trim() : '';
+            if (!normalizedSlug || normalizedSlug.length > 255) {
+                contentError(t.gettext('The post slug is invalid.'), 400);
+            }
+            const parent = await this.taonCmsContentRepository.getContentBySlugForMedia(normalizedSlug);
+            if (!parent) {
+                contentError(t.gettext('The post was not found.'), 404);
+            }
+            await this.requireReadAccess(parent, true, req, t);
+            const children = await this.taonCmsContentRepository.listPublicVideoChildren(parent.id);
+            const publicVideos: TaonCmsPublicVideoChild[] = [];
+            for (const child of children) {
+                if (!child.videoKey) {
+                    continue;
+                }
+                if (!(await this.taonCmsContentStorageController.isPublicMediaObject(child.videoKey))) {
+                    continue;
+                }
+                const fallbackThumbnail = defaultThumbnailUrl(defaultThumbnailKey(child.type));
+                const posterUrl = child.thumbnailKey &&
+                    !child.thumbnailKey.startsWith('cms-placeholder:') &&
+                    (await this.taonCmsContentStorageController.isPublicMediaObject(child.thumbnailKey))
+                    ? this.taonCmsContentStorageController.buildStorageDownloadUrl({
+                        req,
+                        key: child.thumbnailKey,
+                        private: false,
+                    })
+                    : (fallbackThumbnail ?? '');
+                publicVideos.push({
+                    slug: child.slug,
+                    title: child.title,
+                    excerpt: child.excerpt,
+                    videoUrl: this.taonCmsContentStorageController.buildStorageDownloadUrl({
+                        req,
+                        key: child.videoKey,
+                        private: false,
+                    }),
+                    posterUrl,
+                });
+            }
+            return publicVideos;
+        };
+    }
     @POST()
     createContent(
     @Body()
     input: TaonCmsCreateContent): Taon.Response<TaonCmsContentEntity> {
         return async () => this.taonCmsContentRepository.createContent(input);
     }
+    @POST()
+    createRelatedChild(
+    @Query('parentId')
+    parentId: number, 
+    @Body()
+    input: TaonCmsCreateRelatedChildInput): Taon.Response<TaonCmsCreateRelatedChildResult> {
+        return async () => {
+            if (!input || typeof input !== 'object') {
+                contentError('The child post input is invalid.');
+            }
+            if (typeof input.sourceKey !== 'string') {
+                contentError('The uploaded source media key is invalid.');
+            }
+            for (const key of [
+                input.videoKey,
+                input.audioKey,
+                input.attachmentKey,
+                input.thumbnailKey,
+            ]) {
+                if (key !== null && typeof key !== 'string') {
+                    contentError('The uploaded media key is invalid.');
+                }
+            }
+            if (!(await this.taonCmsContentStorageController.isMediaObjectAvailable(input.sourceKey))) {
+                contentError('The uploaded source file was not found.', 404);
+            }
+            for (const key of [
+                input.videoKey,
+                input.audioKey,
+                input.attachmentKey,
+                input.thumbnailKey,
+            ]) {
+                if (key &&
+                    !key.startsWith('cms-placeholder:') &&
+                    !(await this.taonCmsContentStorageController.isMediaObjectAvailable(key))) {
+                    contentError('The uploaded media file was not found.', 404);
+                }
+            }
+            return this.taonCmsContentRepository.createRelatedChild(parentId, input);
+        };
+    }
     @PUT()
     updateContent(
     @Query('id')

package/ts-source/websql-code/taon-cms-content/taon-cms-content.models.ts

@@ -64,6 +64,30 @@ export interface TaonCmsCreateContent extends Pick<TaonCmsContentFields, 'title'
     permissionIds?: number[];
     applicationHook?: TaonCmsApplicationHook | null;
 }
+export interface TaonCmsCreateRelatedChildInput {
+    titlePrefix: string;
+    expectedTitle: string;
+    fileName: string;
+    mimeType: string;
+    sourceKey: string;
+    type: TaonCmsContentType;
+    body: string | null;
+    videoKey: string | null;
+    audioKey: string | null;
+    attachmentKey: string | null;
+    thumbnailKey: string;
+}
+export interface TaonCmsCreateRelatedChildResult {
+    child: TaonCmsContentEntity;
+    parentVersion: number;
+}
+export interface TaonCmsPublicVideoChild {
+    slug: string;
+    title: string;
+    excerpt: string | null;
+    videoUrl: string;
+    posterUrl: string;
+}
 export interface TaonCmsUpdateContent extends Partial<TaonCmsContentFields> {
     tagIds?: number[];
     relatedPostIds?: number[];
@@ -78,6 +102,7 @@ export interface TaonCmsRestoreContent {
 export interface TaonCmsContentSnapshot extends TaonCmsContentFields {
     tagIds: number[];
     relatedPostIds?: number[];
+    relatedPostOrderSaved?: boolean;
     permissionIds: number[];
 }
 import type { TaonCmsApplicationHook } from '../taon-cms-application-hooks';

package/ts-source/websql-code/taon-cms-content/taon-cms-content.repository.ts

@@ -22,9 +22,11 @@ import { TaonCmsContentRevisionRepository } from '../taon-cms-content-revision/t
 import { TaonCmsContentTagRepository } from '../taon-cms-content-tag/taon-cms-content-tag.repository';
 import { TaonCmsTagRepository } from '../taon-cms-tag/taon-cms-tag.repository';
 import { TaonCmsContentAssetEntity } from '../taon-cms-content-asset/taon-cms-content-asset.entity';
+import { _ } from 'tnp-core/websql';
 import { TaonCmsContentEntity } from './taon-cms-content.entity';
 import { TaonCmsContentType } from './taon-cms-content.models';
-import type { TaonCmsContentFields, TaonCmsContentSnapshot, TaonCmsCreateContent, TaonCmsRestoreContent, TaonCmsUpdateContent, TaonCmsPermissionConfiguration, TaonCmsPostVersionKind, TaonCmsPostVersionLinks, TaonCmsVisibilityConfiguration, } from './taon-cms-content.models';
+import { TaonCmsContentUtils } from './taon-cms-content.utils';
+import type { TaonCmsContentFields, TaonCmsContentSnapshot, TaonCmsCreateContent, TaonCmsCreateRelatedChildInput, TaonCmsCreateRelatedChildResult, TaonCmsRestoreContent, TaonCmsUpdateContent, TaonCmsPermissionConfiguration, TaonCmsPostVersionKind, TaonCmsPostVersionLinks, TaonCmsVisibilityConfiguration, } from './taon-cms-content.models';
 import { contentError, requireContentId, requireContentVersion, validateContentInput, } from './taon-cms-content.validation';
 @TaonRepository({
     className: 'TaonCmsContentRepository',
@@ -53,6 +55,248 @@ export class TaonCmsContentRepository extends TaonBaseRepository<TaonCmsContentE
         validateContentInput(input, true);
         return this.connection.transaction('SERIALIZABLE', manager => this.createContentWithManager(input, manager));
     }
+    async createRelatedChild(parentId: number, input: TaonCmsCreateRelatedChildInput): Promise<TaonCmsCreateRelatedChildResult> {
+        requireContentId(parentId, 'parentId');
+        this.validateRelatedChildInput(input);
+        return this.connection.transaction('SERIALIZABLE', async (manager) => {
+            const parent = await this.requireContent(parentId, manager);
+            const prefix = input.titlePrefix.trim();
+            const requestedTitle = input.expectedTitle.trim();
+            const matchingChild = parent.relatedPosts.find(child => child.title === requestedTitle &&
+                this.relatedChildMatchesInput(child, input));
+            if (matchingChild) {
+                return { child: matchingChild, parentVersion: parent.version };
+            }
+            const uploadedKeys = [
+                input.sourceKey,
+                ...(input.thumbnailKey.startsWith('cms-placeholder:')
+                    ? []
+                    : [input.thumbnailKey]),
+            ];
+            for (const key of new Set(uploadedKeys)) {
+                if (await this.isMediaKeyInUseWithinManager(key, manager)) {
+                    contentError('An uploaded media file is already assigned to a post.', 409);
+                }
+            }
+            const title = this.nextRelatedChildTitle(prefix, parent.relatedPosts);
+            if (requestedTitle !== title) {
+                contentError('The child title sequence changed. Reload related posts and retry.', 409);
+            }
+            const inheritedVisibility = await this.resolveVisibilityConfiguration(parent, manager);
+            const status = parent.applyVisibilityToRelatedPosts
+                ? this.contentStatus(parent.status)
+                : inheritedVisibility.source
+                    ? inheritedVisibility.status
+                    : 'draft';
+            const repository = manager.getRepository<TaonCmsContentEntity>(this.target);
+            const baseSlug = _.kebabCase(title);
+            if (!baseSlug) {
+                contentError('The child title cannot be converted into a URL slug.');
+            }
+            let slug = baseSlug;
+            let suffix = 2;
+            while (await repository.findOneBy({ slug })) {
+                slug = `${baseSlug}-${suffix}`;
+                suffix += 1;
+            }
+            const child = await this.createContentWithManager({
+                title,
+                slug,
+                type: input.type,
+                body: input.body,
+                videoKey: input.videoKey,
+                audioKey: input.audioKey,
+                attachmentKey: input.attachmentKey,
+                thumbnailKey: input.thumbnailKey,
+                status,
+                publishedAt: status === 'published' ? new Date() : null,
+                relatedPostIds: [],
+                tagIds: [],
+                permissionIds: [],
+                applicationHook: null,
+            }, manager);
+            const snapshot = await this.snapshotOf(parent, manager);
+            snapshot.relatedPostIds = [
+                ...parent.relatedPosts.map(relatedPost => relatedPost.id),
+                child.id,
+            ];
+            const updatedParent = await this.commitUpdate(parent, parent.version, snapshot, manager, undefined, false);
+            return { child, parentVersion: updatedParent.version };
+        });
+    }
+    private validateRelatedChildInput(input: TaonCmsCreateRelatedChildInput): void {
+        if (!input || typeof input !== 'object') {
+            contentError('The child post input is invalid.');
+        }
+        const prefix = typeof input.titlePrefix === 'string' ? input.titlePrefix.trim() : '';
+        if (!prefix || prefix.length > 240 || /[\r\n]/.test(prefix)) {
+            contentError('The child title prefix is invalid.');
+        }
+        if (typeof input.expectedTitle !== 'string' ||
+            !input.expectedTitle.trim() ||
+            input.expectedTitle.trim().length > 255) {
+            contentError('The child title is invalid.');
+        }
+        if (typeof input.fileName !== 'string' ||
+            !input.fileName.trim() ||
+            input.fileName.length > 255 ||
+            typeof input.mimeType !== 'string' ||
+            input.mimeType.length > 127) {
+            contentError('The uploaded file information is invalid.');
+        }
+        if ((input.body !== null && typeof input.body !== 'string') ||
+            (typeof input.body === 'string' && input.body.length > 10000000)) {
+            contentError('The document content is invalid or too large.');
+        }
+        for (const key of [
+            input.videoKey,
+            input.audioKey,
+            input.attachmentKey,
+        ]) {
+            if (key !== null && typeof key !== 'string') {
+                contentError('The uploaded media key is invalid.');
+            }
+        }
+        if (typeof input.sourceKey !== 'string' ||
+            !input.sourceKey.trim() ||
+            input.sourceKey.length > 1024 ||
+            typeof input.thumbnailKey !== 'string' ||
+            !input.thumbnailKey.trim() ||
+            input.thumbnailKey.length > 1024) {
+            contentError('The uploaded media key is invalid.');
+        }
+        const fileName = input.fileName.split(/[\\/]/).pop() ?? '';
+        const keyFileName = input.sourceKey.split('/').pop() ?? '';
+        const storedFileName = keyFileName.replace(/^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}__/i, '');
+        if (storedFileName === keyFileName) {
+            contentError('The uploaded source media key is invalid.');
+        }
+        const extension = fileName.match(/\.([^.]+)$/)?.[1]?.toLowerCase() ?? '';
+        const keyExtension = storedFileName.match(/\.([^.]+)$/)?.[1]?.toLowerCase() ?? '';
+        if (extension !== keyExtension) {
+            contentError('The uploaded file extension does not match its media key.');
+        }
+        const documentExtensions = new Set(['doc', 'docx', 'rtf', 'txt']);
+        const videoExtensions = new Set([
+            '3gp',
+            'avi',
+            'm4v',
+            'mkv',
+            'mov',
+            'mp4',
+            'mpeg',
+            'mpg',
+            'ogv',
+            'webm',
+        ]);
+        const audioExtensions = new Set([
+            'aac',
+            'flac',
+            'm4a',
+            'mp3',
+            'oga',
+            'ogg',
+            'opus',
+            'wav',
+            'weba',
+            'wma',
+        ]);
+        const mimeType = input.mimeType.toLowerCase();
+        const expectedType = documentExtensions.has(extension)
+            ? TaonCmsContentType.Normal
+            : mimeType.startsWith('video/')
+                ? TaonCmsContentType.Video
+                : mimeType.startsWith('audio/')
+                    ? TaonCmsContentType.Audio
+                    : videoExtensions.has(extension)
+                        ? TaonCmsContentType.Video
+                        : audioExtensions.has(extension)
+                            ? TaonCmsContentType.Audio
+                            : TaonCmsContentType.Attachment;
+        if (input.type !== expectedType) {
+            contentError('The uploaded file type does not match the child post type.');
+        }
+        if (input.type === TaonCmsContentType.Video) {
+            if (input.videoKey !== input.sourceKey ||
+                input.audioKey !== null ||
+                input.attachmentKey !== null ||
+                input.body !== null ||
+                input.thumbnailKey === 'cms-placeholder:video') {
+                contentError('The video child media mapping is invalid.');
+            }
+            if (!/\.(?:avif|gif|jpe?g|png|webp)$/i.test(input.thumbnailKey)) {
+                contentError('The video thumbnail file type is invalid.');
+            }
+        }
+        else if (input.type === TaonCmsContentType.Audio) {
+            if (input.audioKey !== input.sourceKey ||
+                input.videoKey !== null ||
+                input.attachmentKey !== null ||
+                input.body !== null ||
+                input.thumbnailKey !== 'cms-placeholder:audio') {
+                contentError('The audio child media mapping is invalid.');
+            }
+        }
+        else if (input.type === TaonCmsContentType.Normal) {
+            if (!input.body?.trim() ||
+                input.videoKey !== null ||
+                input.audioKey !== null ||
+                input.attachmentKey !== null ||
+                input.thumbnailKey !== 'cms-placeholder:normal') {
+                contentError('The document child content mapping is invalid.');
+            }
+        }
+        else if (input.attachmentKey !== input.sourceKey ||
+            input.videoKey !== null ||
+            input.audioKey !== null ||
+            input.body !== null ||
+            input.thumbnailKey !== 'cms-placeholder:normal') {
+            contentError('The attachment child media mapping is invalid.');
+        }
+    }
+    private relatedChildMatchesInput(child: TaonCmsContentEntity, input: TaonCmsCreateRelatedChildInput): boolean {
+        return (child.type === input.type &&
+            child.body === input.body &&
+            child.videoKey === input.videoKey &&
+            child.audioKey === input.audioKey &&
+            child.attachmentKey === input.attachmentKey &&
+            child.thumbnailKey === input.thumbnailKey);
+    }
+    private nextRelatedChildTitle(prefix: string, children: TaonCmsContentEntity[]): string {
+        let highest = 0;
+        for (const child of children) {
+            const candidatePrefix = `${prefix} `;
+            if (!child.title.startsWith(candidatePrefix)) {
+                continue;
+            }
+            const suffix = child.title.slice(candidatePrefix.length);
+            if (!/^\d+$/.test(suffix)) {
+                continue;
+            }
+            const number = Number(suffix);
+            if (Number.isSafeInteger(number)) {
+                highest = Math.max(highest, number);
+            }
+        }
+        const next = highest + 1;
+        if (!Number.isSafeInteger(next)) {
+            contentError('No available child title number could be generated.', 409);
+        }
+        return `${prefix} ${String(next).padStart(2, '0')}`;
+    }
+    private async isMediaKeyInUseWithinManager(key: string, manager: EntityManager): Promise<boolean> {
+        return !!(await manager
+            .getRepository<TaonCmsContentEntity>(this.target)
+            .findOne({
+            where: [
+                { videoKey: key },
+                { audioKey: key },
+                { attachmentKey: key },
+                { thumbnailKey: key },
+            ],
+            select: { id: true },
+        }));
+    }
     private async resolveVisibilityConfiguration(post: TaonCmsContentEntity, manager: EntityManager): Promise<TaonCmsVisibilityConfiguration> {
         const repository = manager.getRepository<TaonCmsContentEntity>(this.target);
         let childId = post.id;
@@ -227,7 +471,7 @@ export class TaonCmsContentRepository extends TaonBaseRepository<TaonCmsContentE
         await this.validatePermissionInheritance(manager);
         await this.replacePermissions(content.id, permissionIds, [], manager);
         await this.replaceApplicationHook(content.id, input.applicationHook ?? null, manager);
-        await this.taonCmsContentRevisionRepository.recordContent(content, { ...fields, tagIds, relatedPostIds, permissionIds }, manager);
+        await this.taonCmsContentRevisionRepository.recordContent(content, { ...fields, tagIds, relatedPostIds, relatedPostOrderSaved: true, permissionIds }, manager);
         return this.requireContent(content.id, manager);
     }
     async updateContent(id: number, input: TaonCmsUpdateContent): Promise<TaonCmsContentEntity> {
@@ -421,6 +665,25 @@ export class TaonCmsContentRepository extends TaonBaseRepository<TaonCmsContentE
         requireContentId(id);
         return this.connection.transaction(async (manager) => (await this.requireContent(id, manager)).relatedPosts);
     }
+    async listPublicVideoChildren(parentId: number): Promise<TaonCmsContentEntity[]> {
+        requireContentId(parentId, 'parentId');
+        return this.connection.transaction(async (manager) => {
+            const parent = await this.requireContent(parentId, manager);
+            const publicChildren: TaonCmsContentEntity[] = [];
+            for (const child of parent.relatedPosts) {
+                if (child.type !== TaonCmsContentType.Video ||
+                    child.status !== 'published' ||
+                    !child.videoKey) {
+                    continue;
+                }
+                const permissions = await this.resolvePermissionConfiguration(child, manager);
+                if (!permissions.permissions?.length) {
+                    publicChildren.push(child);
+                }
+            }
+            return publicChildren;
+        });
+    }
     async getParentPost(id: number): Promise<TaonCmsContentEntity | null> {
         requireContentId(id);
         return this.connection.transaction(async (manager) => {
@@ -616,6 +879,19 @@ export class TaonCmsContentRepository extends TaonBaseRepository<TaonCmsContentE
         }
         return true;
     }
+    async isMediaKeyInUse(key: string): Promise<boolean> {
+        return !!(await this.connection
+            .getRepository<TaonCmsContentEntity>(this.target)
+            .findOne({
+            where: [
+                { videoKey: key },
+                { audioKey: key },
+                { attachmentKey: key },
+                { thumbnailKey: key },
+            ],
+            select: { id: true },
+        }));
+    }
     async addRelatedPost(id: number, relatedPostId: number, expectedVersion: number): Promise<TaonCmsContentEntity> {
         return this.changeRelatedPost(id, relatedPostId, expectedVersion, true);
     }
@@ -775,7 +1051,7 @@ export class TaonCmsContentRepository extends TaonBaseRepository<TaonCmsContentE
             return this.commitUpdate(current, expectedVersion, snapshot, manager);
         });
     }
-    private async requireContent(id: number, manager: EntityManager): Promise<TaonCmsContentEntity> {
+    async requireContent(id: number, manager: EntityManager): Promise<TaonCmsContentEntity> {
         const content = await manager
             .getRepository<TaonCmsContentEntity>(this.target)
             .findOne({
@@ -789,6 +1065,7 @@ export class TaonCmsContentRepository extends TaonBaseRepository<TaonCmsContentE
         if (!content) {
             contentError(`Content ${id} does not exist.`, 404);
         }
+        await this.taonCmsContentRevisionRepository.applyRelatedPostOrder(content, manager);
         return content;
     }
     private contentFields(input: Partial<TaonCmsContentFields>, current?: TaonCmsContentFields): TaonCmsContentFields {
@@ -1005,10 +1282,13 @@ export class TaonCmsContentRepository extends TaonBaseRepository<TaonCmsContentE
             await this.replaceApplicationHook(current.id, applicationHook, manager);
         }
         const updated = await this.requireContent(current.id, manager);
+        const relatedPostIds = [...new Set(snapshot.relatedPostIds ?? [])];
+        TaonCmsContentUtils.orderRelatedPosts(updated.relatedPosts, relatedPostIds);
         await this.taonCmsContentRevisionRepository.recordContent(updated, {
             ...fields,
             tagIds: snapshot.tagIds,
-            relatedPostIds: updated.relatedPosts.map(post => post.id),
+            relatedPostIds,
+            relatedPostOrderSaved: true,
             permissionIds: updated.permissions.map(permission => permission.id),
         }, manager);
         if (propagateVisibility) {

package/ts-source/websql-code/taon-cms-content/taon-cms-content.utils.ts

@@ -11,7 +11,13 @@
  * ========================================================================== */
 
 import { TaonCmsContentState } from './taon-cms-content.models';
+import type { TaonCmsContentEntity } from './taon-cms-content.entity';
 export namespace TaonCmsContentUtils {
+    export function orderRelatedPosts(posts: TaonCmsContentEntity[], ids: number[]): void {
+        const positions = new Map(ids.map((id, index) => [id, index]));
+        posts.sort((a, b) => (positions.get(a.id) ?? ids.length) -
+            (positions.get(b.id) ?? ids.length));
+    }
     export function isActive(state: string): state is TaonCmsContentState {
         return state === 'active';
     }