Custom shows API checkpoint

server/api/v2/customShowsApiV2.ts

@@ -1,6 +1,14 @@
+import { isContentProgram } from 'dizquetv-types';
+import { CreateCustomShowRequestSchema } from 'dizquetv-types/api';
+import { CustomShowSchema } from 'dizquetv-types/schemas';
+import { chain, isNull, map, partition, reduce } from 'lodash-es';
+import { z } from 'zod';
 import { CustomShow } from '../../dao/entities/CustomShow.js';
+import { CustomShowContent } from '../../dao/entities/CustomShowContent.js';
+import { Program } from '../../dao/entities/Program.js';
 import createLogger from '../../logger.js';
 import { RouterPluginAsyncCallback } from '../../types/serverType.js';
+import { ProgramMinterFactory } from '../../util/programMinter.js';
 
 const logger = createLogger(import.meta);
 
@@ -11,15 +19,136 @@ export const customShowsApiV2: RouterPluginAsyncCallback = async (fastify) => {
     done();
   });
 
-  fastify.get('/custom-shows', async (req, res) => {
-    const customShows = await req.entityManager.find(
-      CustomShow,
-      {},
-      {
-        // populate: ['content'],
+  fastify.get(
+    '/custom-shows',
+    {
+      schema: {
+        response: {
+          200: z.array(CustomShowSchema),
+        },
       },
-    );
+    },
+    async (req, res) => {
+      const customShows = await req.entityManager
+        .repo(CustomShow)
+        .findAll({ populate: ['content.uuid'] });
 
-    return res.send(customShows);
-  });
+      return res.send(
+        map(customShows, (cs) => ({
+          id: cs.uuid,
+          name: cs.name,
+          contentCount: cs.content.length,
+        })),
+      );
+    },
+  );
+
+  fastify.get(
+    '/custom-shows/:id',
+    {
+      schema: {
+        params: z.object({
+          id: z.string(),
+        }),
+        response: {
+          200: CustomShowSchema,
+          404: z.void(),
+        },
+      },
+    },
+    async (req, res) => {
+      const customShow = await req.entityManager
+        .repo(CustomShow)
+        .findOne({ uuid: req.params.id }, { populate: ['content.uuid'] });
+      if (isNull(customShow)) {
+        return res.status(404).send();
+      }
+
+      return res.status(200).send({
+        id: customShow.uuid,
+        name: customShow.name,
+        contentCount: customShow.content.length,
+      });
+    },
+  );
+
+  fastify.post(
+    '/custom-shows',
+    {
+      schema: {
+        body: CreateCustomShowRequestSchema,
+        response: {
+          201: z.object({ id: z.string() }),
+        },
+      },
+    },
+    async (req, res) => {
+      const show = req.entityManager.repo(CustomShow).create({
+        name: req.body.name,
+      });
+
+      let idx = 0;
+      const programIndexById = reduce(
+        req.body.programs,
+        (acc, p) => {
+          if (p.persisted) {
+            acc[p.id!] = idx++;
+          } else if (isContentProgram(p)) {
+            acc[
+              `${p.externalSourceType}_${p.externalSourceName!}_${p
+                .originalProgram?.key}`
+            ] = idx++;
+          }
+          return acc;
+        },
+        {} as Record<string, number>,
+      );
+
+      const [nonPersisted, persisted] = partition(
+        req.body.programs,
+        (p) => !p.persisted,
+      );
+      const minter = ProgramMinterFactory.create(req.entityManager);
+
+      // TODO handle custom shows
+      const programsToPersist = chain(nonPersisted)
+        .filter(isContentProgram)
+        .map((p) => minter.mint(p.externalSourceName!, p.originalProgram!))
+        .value();
+
+      const upsertedPrograms = await req.entityManager.upsertMany(
+        Program,
+        programsToPersist,
+        {
+          batchSize: 10,
+          onConflictAction: 'merge',
+          onConflictFields: ['sourceType', 'externalSourceId', 'externalKey'],
+          onConflictExcludeFields: ['uuid'],
+        },
+      );
+
+      await req.entityManager.persist(show).flush();
+
+      const persistedCustomShowContent = map(persisted, (p) =>
+        req.entityManager.create(CustomShowContent, {
+          customShow: show.uuid,
+          content: p.id!,
+          index: programIndexById[p.id!],
+        }),
+      );
+      const newCustomShowContent = map(upsertedPrograms, (p) =>
+        req.entityManager.create(CustomShowContent, {
+          customShow: show.uuid,
+          content: p.uuid,
+          index: programIndexById[p.uniqueId()],
+        }),
+      );
+
+      await req.entityManager
+        .persist([...persistedCustomShowContent, ...newCustomShowContent])
+        .flush();
+
+      return res.status(201).send({ id: show.uuid });
+    },
+  );
 };

types/index.ts

@@ -6,3 +6,4 @@ export * from './src/FfmpegSettings.js';
 export * from './src/misc.js';
 export * from './src/PlexSettings.js';
 export * from './src/HdhrSettings.js';
+export * from './src/CustomShow.js';

types/src/CustomShow.ts

@@ -0,0 +1,6 @@
+import { z } from 'zod';
+import { CustomShowSchema } from './schemas/customShowsSchema.js';
+
+type Alias<T> = T & { _?: never };
+
+export type CustomShow = Alias<z.infer<typeof CustomShowSchema>>;

types/src/api/index.ts

@@ -1,4 +1,8 @@
 import { z } from 'zod';
+import {
+  ContentProgramSchema,
+  CustomProgramSchema,
+} from '../schemas/programmingSchema.js';
 
 export const ChannelNumberParamSchema = z.object({
   number: z.coerce.number(),
@@ -32,3 +36,10 @@ export const BatchLookupExternalProgrammingSchema = z.object({
   //   );
   // }),
 });
+
+export const CreateCustomShowRequestSchema = z.object({
+  name: z.string(),
+  programs: z.array(
+    z.discriminatedUnion('type', [ContentProgramSchema, CustomProgramSchema]),
+  ),
+});

types/src/schemas/customShowsSchema.ts

@@ -0,0 +1,7 @@
+import { z } from 'zod';
+
+export const CustomShowSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  contentCount: z.number(),
+});

types/src/schemas/index.ts

@@ -4,3 +4,4 @@ export * from './guideApiSchemas.js';
 export * from './miscSchemas.js';
 export * from './settingsSchemas.js';
 export * from './programmingSchema.js';
+export * from './customShowsSchema.js';

web2/src/components/base/PaddedPaper.tsx

@@ -0,0 +1,10 @@
+import Paper, { PaperProps } from '@mui/material/Paper';
+import { styled } from '@mui/material/styles';
+
+const PaddedPaper = styled(Paper, {
+  shouldForwardProp: () => true,
+})<PaperProps & { to?: string }>(() => ({
+  padding: 16,
+}));
+
+export default PaddedPaper;

web2/src/components/channel_config/AddSelectedMediaButton.tsx

@@ -0,0 +1,37 @@
+import { flattenDeep } from 'lodash-es';
+import { sequentialPromises } from '../../helpers/util.ts';
+import { enumeratePlexItem } from '../../hooks/plexHooks.ts';
+import { addPlexMediaToCurrentChannel } from '../../store/channelEditor/actions.ts';
+import useStore from '../../store/index.ts';
+import Button from '@mui/material/Button';
+
+type Props = {
+  onSuccess: () => void;
+};
+
+export default function AddSelectedMediaButton({ onSuccess }: Props) {
+  const knownMedia = useStore((s) => s.knownMediaByServer);
+  const selectedMedia = useStore((s) => s.selectedMedia);
+
+  const addSelectedItems = () => {
+    sequentialPromises(selectedMedia, (selected) => {
+      const media = knownMedia[selected.server][selected.guid];
+      return enumeratePlexItem(selected.server, media)();
+    })
+      .then(flattenDeep)
+      .then(addPlexMediaToCurrentChannel)
+      .then(() => {
+        onSuccess();
+      })
+      .catch(console.error);
+  };
+
+  return (
+    <Button
+      onClick={() => addSelectedItems()}
+      disabled={selectedMedia.length === 0}
+    >
+      Add
+    </Button>
+  );
+}

web2/src/components/channel_config/ChannelProgrammingConfig.tsx

@@ -43,7 +43,7 @@ import {
 } from '../../store/channelEditor/actions.ts';
 import useStore from '../../store/index.ts';
 import AddRedirectModal from '../programming_controls/AddRedirectModal.tsx';
-import ProgrammingSelector from './ProgrammingSelector.tsx';
+import ProgrammingSelectorDialog from './ProgrammingSelectorDialog.tsx';
 import AddFlexModal from '../programming_controls/AddFlexModal.tsx';
 
 // dayjs.extend(duration);
@@ -293,7 +293,7 @@ export function ChannelProgrammingConfig() {
           </Box>
         </Box>
       </Paper>
-      <ProgrammingSelector
+      <ProgrammingSelectorDialog
         open={programmingModalOpen}
         onClose={() => setProgrammingModalOpen(false)}
       />

web2/src/components/channel_config/PlexMovieListItem.tsx

@@ -3,7 +3,7 @@ import { PlexMovie } from 'dizquetv-types/plex';
 import { prettyItemDuration } from '../../helpers/util.ts';
 import useStore from '../../store/index.ts';
 import { addSelectedMedia } from '../../store/programmingSelector/actions.ts';
-import { PlexListItemProps } from './ProgrammingSelector.tsx';
+import { PlexListItemProps } from './ProgrammingSelectorDialog.tsx';
 
 export function PlexMovieListItem(props: PlexListItemProps<PlexMovie>) {
   const { item, index } = props;

web2/src/components/channel_config/PlexShowListItem.tsx

@@ -27,7 +27,7 @@ import {
   addKnownMediaForServer,
   addSelectedMedia,
 } from '../../store/programmingSelector/actions.ts';
-import { PlexListItemProps } from './ProgrammingSelector.tsx';
+import { PlexListItemProps } from './ProgrammingSelectorDialog.tsx';
 import { prettyItemDuration } from '../../helpers/util.ts';
 
 export function PlexTvListItem(