podverse-parser 5.0.0-beta.2 → 5.0.0-beta.3

package/src/lib/rss/channel/channelTrailer.ts

@@ -1,31 +0,0 @@
-import { FeedObject } from "podcast-partytime";
-import { Channel, ChannelSeason, ChannelTrailerDto, ChannelTrailerService, EntityManager } from "podverse-orm";
-import { compatChannelTrailerDtos } from "@parser/lib/compat/partytime/channel";
-
-export const handleParsedChannelTrailer = async (
-  parsedFeed: FeedObject,
-  channel: Channel,
-  channelSeasonIndex: Record<number, ChannelSeason>,
-  transactionalEntityManager: EntityManager
-) => {
-  const channelTrailerService = new ChannelTrailerService(transactionalEntityManager);
-  const channelTrailerDtos = compatChannelTrailerDtos(parsedFeed);
-
-  const enrichedChannelTrailerDtos: ChannelTrailerDto[] = channelTrailerDtos.map((channelTrailerDto) => {
-    const channel_season = channelTrailerDto.season ? channelSeasonIndex[channelTrailerDto.season] : null;
-    return {
-      url: channelTrailerDto.url,
-      pubdate: channelTrailerDto.pubdate,
-      title: channelTrailerDto.title,
-      length: channelTrailerDto.length,
-      type: channelTrailerDto.type,
-      channel_season
-    };
-  });
-
-  if (channelTrailerDtos.length > 0) {
-    await channelTrailerService.updateMany(channel, enrichedChannelTrailerDtos);
-  } else {
-    await channelTrailerService.deleteAll(channel);
-  }
-};

package/src/lib/rss/channel/channelTxt.ts

@@ -1,14 +0,0 @@
-import { FeedObject } from "podcast-partytime";
-import { Channel, ChannelTxtService, EntityManager } from "podverse-orm";
-import { compatChannelTxtDtos } from "@parser/lib/compat/partytime/channel";
-import { handleParsedManyData } from "../base/handleParsedManyData";
-
-export const handleParsedChannelTxt = async (
-  parsedFeed: FeedObject,
-  channel: Channel,
-  transactionalEntityManager: EntityManager
-) => {
-  const channelTxtService = new ChannelTxtService(transactionalEntityManager);
-  const channelTxtDtos = compatChannelTxtDtos(parsedFeed);
-  await handleParsedManyData(channel, channelTxtService, channelTxtDtos);
-};

package/src/lib/rss/channel/channelValue.ts

@@ -1,30 +0,0 @@
-import { FeedObject } from "podcast-partytime";
-import { Channel, ChannelValueService, ChannelValueRecipientService, EntityManager } from "podverse-orm";
-import { compatChannelValueDtos } from "@parser/lib/compat/partytime/channel";
-
-export const handleParsedChannelValue = async (
-  parsedFeed: FeedObject,
-  channel: Channel,
-  transactionalEntityManager: EntityManager
-) => {
-  const channelValueService = new ChannelValueService(transactionalEntityManager);
-  const channelValueDtos = compatChannelValueDtos(parsedFeed);
-  const channelValueRecipientService = new ChannelValueRecipientService(transactionalEntityManager);
-  
-  if (channelValueDtos.length > 0) {
-    for (const channelValueDto of channelValueDtos) {
-      const channel_value = await channelValueService.update(channel, channelValueDto.channel_value);
-      
-      const channelValueRecipientDtos = channelValueDto.channel_value_recipients;
-      if (channelValueRecipientDtos.length > 0) {
-        for (const channelValueRecipientDto of channelValueRecipientDtos) {
-          await channelValueRecipientService.update(channel_value, channelValueRecipientDto);
-        }
-      } else {
-        await channelValueService.deleteAll(channel);
-      }
-    }
-  } else {
-    await channelValueService.deleteAll(channel);
-  }
-};

package/src/lib/rss/feed/feed.ts

@@ -1,79 +0,0 @@
-import { FeedObject } from "podcast-partytime";
-import { throwRequestError } from "podverse-helpers";
-import { checkIfFeedFlagStatusShouldParse, Feed, FeedService, FeedLogService } from "podverse-orm";
-import { getParsedFeedMd5Hash } from "../hash/parsedFeed";
-import { getAndParseRSSFeed } from "../parser";
-
-export const handleGetRSSFeed = async (feed: Feed): Promise<FeedObject> => {
-  const feedLogService = new FeedLogService();
-  let parsedFeed: FeedObject | null = null;
-  
-  try {
-    parsedFeed = await getAndParseRSSFeed(feed.url);
-    await feedLogService.update(feed, {
-      last_http_status: 200,
-      last_good_http_status_time: new Date()
-    });
-  } catch (error) {
-    // TODO: how to handle errors?
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const statusCode = (error as any).statusCode as number;
-    const feedLog = await feedLogService.get(feed);
-    if (statusCode) {
-      await feedLogService.update(feed, {
-        last_http_status: statusCode,
-        parse_errors: (feedLog?.parse_errors || 0) + 1,
-      });
-    }
-    return throwRequestError(error);
-  }
-  
-  if (!parsedFeed) {
-    const feedLog = await feedLogService.get(feed);
-    await feedLogService.update(feed, {
-      last_http_status: 200,
-      last_finished_parse_time: new Date(),
-      parse_errors: (feedLog?.parse_errors || 0) + 1,
-    });
-    return throwRequestError('parsedFeed no data found');
-  }
-
-  return parsedFeed;
-};
-
-export const handleParsedFeed = async (parsedFeed: FeedObject, url: string, podcast_index_id: number): Promise<Feed> => {
-  const feedService = new FeedService();
-  const feed = await feedService.getOrCreate({ url, podcast_index_id });
-  
-  // TODO: move before partytime parsing
-  if (!checkIfFeedFlagStatusShouldParse(feed.feed_flag_status.id)) {
-    throw new Error(`parseRSSFeedAndSaveToDatabase: feed_flag_status.status is not None or AlwaysAllow for ${url}`);
-  }
-
-  checkIfFeedIsParsing(feed);
- 
-  const currentFeedFileHash = getParsedFeedMd5Hash(parsedFeed);
-
-  if (feed.last_parsed_file_hash === currentFeedFileHash) {
-    throw new Error(`Feed ${feed.id} has no changes since last parsed.`);
-  }
-
-  return feedService.update(feed.id, { last_parsed_file_hash: currentFeedFileHash });
-};
-
-const checkIfFeedIsParsing = (feed: Feed): void => {
-  // TODO: handle with caching db / redis instead of database?
-  if (feed.is_parsing) {
-    const parsingDate = new Date(feed.is_parsing);
-    const currentDate = new Date();
-    const timeDifference = (currentDate.getTime() - parsingDate.getTime()) / (1000 * 60);
-  
-    if (isNaN(parsingDate.getTime())) {
-      throw new Error(`Feed ${feed.id} has an invalid parsing date`);
-    }
-  
-    if (timeDifference <= 30) {
-      throw new Error(`Feed ${feed.id} is already parsing`);
-    }
-  }
-};

package/src/lib/rss/hash/parsedFeed.ts

@@ -1,9 +0,0 @@
-import { getMd5Hash } from "podverse-helpers";
-import { FeedObject } from "podcast-partytime";
-
-export const getParsedFeedMd5Hash = (parsedFeed: FeedObject): string => {
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  const { lastUpdate, lastBuildDate, pubDate, ...parsedFeedPruned } = parsedFeed;
-  const currentFeedFileHash = getMd5Hash(parsedFeedPruned);
-  return currentFeedFileHash;
-};

package/src/lib/rss/item/item.ts

@@ -1,85 +0,0 @@
-import { Episode } from "podcast-partytime";
-import { chunkArray } from "podverse-helpers";
-import { AppDataSource, Channel, ChannelSeasonIndex, EntityManager, ItemService } from "podverse-orm";
-import { compatItemDto } from "@parser/lib/compat/partytime/item";
-import { handleParsedItemAbout } from "@parser/lib/rss/item/itemAbout";
-import { handleParsedItemChaptersFeed } from "@parser/lib/rss/item/itemChaptersFeed";
-import { handleParsedItemDescription } from "@parser/lib/rss/item/itemDescription";
-import { handleParsedItemEnclosure } from "@parser/lib/rss/item/itemEnclosure";
-import { handleParsedItemImage } from "@parser/lib/rss/item/itemImage";
-import { handleParsedItemLicense } from "@parser/lib/rss/item/itemLicense";
-import { handleParsedItemLocation } from "@parser/lib/rss/item/itemLocation";
-import { handleParsedItemPerson } from "@parser/lib/rss/item/itemPerson";
-import { handleParsedItemSeason } from "@parser/lib/rss/item/itemSeason";
-import { handleParsedItemSeasonEpisode } from "@parser/lib/rss/item/itemSeasonEpisode";
-import { handleParsedItemSocialInteract } from "@parser/lib/rss/item/itemSocialInteract";
-import { handleParsedItemSoundbite } from "@parser/lib/rss/item/itemSoundbite";
-import { handleParsedItemTranscript } from "@parser/lib/rss/item/itemTranscript";
-import { handleParsedItemTxt } from "@parser/lib/rss/item/itemTxt";
-import { handleParsedItemValue } from "@parser/lib/rss/item/itemValue";
-import { handleParsedItemChat } from "@parser/lib/rss/item/itemChat";
-
-export const handleParsedItems = async (parsedItems: Episode[], channel: Channel, channelSeasonIndex: ChannelSeasonIndex) => {
-  const itemService = new ItemService();
-  const existingItems = await itemService.getAllItemsByChannel(channel, { select: ['id'] });
-  const existingItemIds = existingItems.map(item => item.id);
-  const updatedItemIds: number[] = [];
-
-  const parsedItemBatchs = chunkArray(parsedItems, 100);
-  for (const parsedItemBatch of parsedItemBatchs) {
-    await AppDataSource.manager.transaction(async transactionalEntityManager => {
-      for (const parsedItem of parsedItemBatch) {
-        const item = await handleParsedItem(
-          parsedItem,
-          channel,
-          channelSeasonIndex,
-          transactionalEntityManager
-        );
-        updatedItemIds.push(item.id);
-      }
-    });
-  }
-
-  const itemIdsToDelete = existingItemIds.filter(id => !updatedItemIds.includes(id));
-  await itemService.deleteMany(itemIdsToDelete);
-};
-
-export const handleParsedItem = async (
-  parsedItem: Episode,
-  channel: Channel,
-  channelSeasonIndex: ChannelSeasonIndex,
-  transactionalEntityManager: EntityManager
-) => {
-  const itemService = new ItemService();
-  const itemDto = compatItemDto(parsedItem);
-  const item = await itemService.update(channel, itemDto);
-
-  await handleParsedItemAbout(parsedItem, item, transactionalEntityManager);
-  await handleParsedItemChaptersFeed(parsedItem, item, transactionalEntityManager);
-  await handleParsedItemChat(parsedItem, item, transactionalEntityManager);
-
-  // // PTDO: add itemContentLinkService support after partytime adds chat support
-  // const itemContentLinkService = new ItemContentLinkService();
-  // const itemContentLinkDtos = compatItemContentLinkDtos(parsedItem);
-  // if (itemContentLinkDtos.length) {
-  //   await itemContentLinkService.updateMany(item, itemContentLinkDtos);
-  // } else {
-  //   await itemContentLinkService._deleteAll(item);
-  // }
-
-  await handleParsedItemDescription(parsedItem, item, transactionalEntityManager);
-  await handleParsedItemEnclosure(parsedItem, item, transactionalEntityManager);
-  await handleParsedItemImage(parsedItem, item, transactionalEntityManager);
-  await handleParsedItemLicense(parsedItem, item, transactionalEntityManager);
-  await handleParsedItemLocation(parsedItem, item, transactionalEntityManager);
-  await handleParsedItemPerson(parsedItem, item, transactionalEntityManager);
-  await handleParsedItemSeason(parsedItem, item, channelSeasonIndex, transactionalEntityManager);
-  await handleParsedItemSeasonEpisode(parsedItem, item, transactionalEntityManager);
-  await handleParsedItemSocialInteract(parsedItem, item, transactionalEntityManager);
-  await handleParsedItemSoundbite(parsedItem, item, transactionalEntityManager);
-  await handleParsedItemTranscript(parsedItem, item, transactionalEntityManager);
-  await handleParsedItemTxt(parsedItem, item, transactionalEntityManager);
-  await handleParsedItemValue(parsedItem, item, transactionalEntityManager);
-
-  return item;
-};

package/src/lib/rss/item/itemAbout.ts

@@ -1,13 +0,0 @@
-import { Episode } from "podcast-partytime";
-import { EntityManager, Item, ItemAboutService } from "podverse-orm";
-import { compatItemAboutDto } from "@parser/lib/compat/partytime/item";
-
-export const handleParsedItemAbout = async (
-  parsedItem: Episode,
-  item: Item,
-  transactionalEntityManager: EntityManager
-) => {
-  const itemAboutService = new ItemAboutService(transactionalEntityManager);
-  const itemAboutDto = compatItemAboutDto(parsedItem);
-  await itemAboutService.update(item, itemAboutDto);
-};

package/src/lib/rss/item/itemChaptersFeed.ts

@@ -1,14 +0,0 @@
-import { Episode } from "podcast-partytime";
-import { EntityManager, Item, ItemChaptersFeedService } from "podverse-orm";
-import { compatItemChaptersFeedDto } from "@parser/lib/compat/partytime/item";
-import { handleParsedOneData } from "../base/handleParsedOneData";
-
-export const handleParsedItemChaptersFeed = async (
-  parsedItem: Episode,
-  item: Item,
-  transactionalEntityManager: EntityManager
-) => {
-  const itemChaptersFeedService = new ItemChaptersFeedService(transactionalEntityManager);
-  const itemChaptersFeedDto = compatItemChaptersFeedDto(parsedItem);
-  await handleParsedOneData(item, itemChaptersFeedService, itemChaptersFeedDto);
-};

package/src/lib/rss/item/itemChat.ts

@@ -1,14 +0,0 @@
-import { Episode } from "podcast-partytime";
-import { EntityManager, Item, ItemChatService } from "podverse-orm";
-import { compatItemChatDto } from "@parser/lib/compat/partytime/item";
-import { handleParsedOneData } from "../base/handleParsedOneData";
-
-export const handleParsedItemChat = async (
-  parsedItem: Episode,
-  item: Item,
-  transactionalEntityManager: EntityManager
-) => {
-  const itemChatService = new ItemChatService(transactionalEntityManager);
-  const itemChatDto = compatItemChatDto(parsedItem);
-  await handleParsedOneData(item, itemChatService, itemChatDto);
-};

package/src/lib/rss/item/itemDescription.ts

@@ -1,14 +0,0 @@
-import { Episode } from "podcast-partytime";
-import { EntityManager, Item, ItemDescriptionService } from "podverse-orm";
-import { compatItemDescriptionDto } from "@parser/lib/compat/partytime/item";
-import { handleParsedOneData } from "../base/handleParsedOneData";
-
-export const handleParsedItemDescription = async (
-  parsedItem: Episode,
-  item: Item,
-  transactionalEntityManager: EntityManager
-) => {
-  const itemDescriptionService = new ItemDescriptionService(transactionalEntityManager);
-  const itemDescriptionDto = compatItemDescriptionDto(parsedItem);
-  await handleParsedOneData(item, itemDescriptionService, itemDescriptionDto);
-};

package/src/lib/rss/item/itemEnclosure.ts

@@ -1,35 +0,0 @@
-import { Episode } from "podcast-partytime";
-import { EntityManager, Item, ItemEnclosureService, ItemEnclosureSourceService,
-  ItemEnclosureIntegrityService } from "podverse-orm";
-import { compatItemEnclosureDtos } from "@parser/lib/compat/partytime/item";
-
-export const handleParsedItemEnclosure = async (
-  parsedItem: Episode,
-  item: Item,
-  transactionalEntityManager: EntityManager
-) => {
-  const itemEnclosureService = new ItemEnclosureService(transactionalEntityManager);
-  const itemEnclosureDtos = compatItemEnclosureDtos(parsedItem);
-  
-  if (itemEnclosureDtos.length > 0) {
-    for (const itemEnclosureDto of itemEnclosureDtos) {
-      const item_enclosure = await itemEnclosureService.update(item, itemEnclosureDto.item_enclosure);
-      
-      const itemEnclosureSourceDtos = itemEnclosureDto.item_enclosure_sources;
-      if (itemEnclosureSourceDtos.length > 0) {
-        const itemEnclosureSourceService = new ItemEnclosureSourceService(transactionalEntityManager);
-        await itemEnclosureSourceService.updateMany(item_enclosure, itemEnclosureSourceDtos);
-      } else {
-        await itemEnclosureService.deleteAll(item);
-      }
-
-      const itemEnclosureIntegrityDto = itemEnclosureDto.item_enclosure_integrity;
-      if (itemEnclosureIntegrityDto) {
-        const itemEnclosureIntegrityService = new ItemEnclosureIntegrityService(transactionalEntityManager);
-        await itemEnclosureIntegrityService.update(item_enclosure, itemEnclosureIntegrityDto);
-      }
-    }
-  } else {
-    await itemEnclosureService.deleteAll(item);
-  }
-};

package/src/lib/rss/item/itemImage.ts

@@ -1,14 +0,0 @@
-import { Episode } from "podcast-partytime";
-import { EntityManager, Item, ItemImageService } from "podverse-orm";
-import { compatItemImageDtos } from "@parser/lib/compat/partytime/item";
-import { handleParsedManyData } from "../base/handleParsedManyData";
-
-export const handleParsedItemImage = async (
-  parsedItem: Episode,
-  item: Item,
-  transactionalEntityManager: EntityManager
-) => {
-  const itemImageService = new ItemImageService(transactionalEntityManager);
-  const itemImageDtos = compatItemImageDtos(parsedItem);
-  await handleParsedManyData(item, itemImageService, itemImageDtos);
-};

package/src/lib/rss/item/itemLicense.ts

@@ -1,14 +0,0 @@
-import { Episode } from "podcast-partytime";
-import { EntityManager, Item, ItemLicenseService } from "podverse-orm";
-import { compatItemLicenseDto } from "@parser/lib/compat/partytime/item";
-import { handleParsedOneData } from "../base/handleParsedOneData";
-
-export const handleParsedItemLicense = async (
-  parsedItem: Episode,
-  item: Item,
-  transactionalEntityManager: EntityManager
-) => {
-  const itemLicenseService = new ItemLicenseService(transactionalEntityManager);
-  const itemLicenseDto = compatItemLicenseDto(parsedItem);
-  await handleParsedOneData(item, itemLicenseService, itemLicenseDto);
-};

package/src/lib/rss/item/itemLocation.ts

@@ -1,14 +0,0 @@
-import { Episode } from "podcast-partytime";
-import { EntityManager, Item, ItemLocationService } from "podverse-orm";
-import { compatItemLocationDto } from "@parser/lib/compat/partytime/item";
-import { handleParsedOneData } from "../base/handleParsedOneData";
-
-export const handleParsedItemLocation = async (
-  parsedItem: Episode,
-  item: Item,
-  transactionalEntityManager: EntityManager
-) => {
-  const itemLocationService = new ItemLocationService(transactionalEntityManager);
-  const itemLocationDto = compatItemLocationDto(parsedItem);
-  await handleParsedOneData(item, itemLocationService, itemLocationDto);
-};

package/src/lib/rss/item/itemPerson.ts

@@ -1,14 +0,0 @@
-import { Episode } from "podcast-partytime";
-import { EntityManager, Item, ItemPersonService } from "podverse-orm";
-import { compatItemPersonDtos } from "@parser/lib/compat/partytime/item";
-import { handleParsedManyData } from "../base/handleParsedManyData";
-
-export const handleParsedItemPerson = async (
-  parsedItem: Episode,
-  item: Item,
-  transactionalEntityManager: EntityManager
-) => {
-  const itemPersonService = new ItemPersonService(transactionalEntityManager);
-  const itemPersonDtos = compatItemPersonDtos(parsedItem);
-  await handleParsedManyData(item, itemPersonService, itemPersonDtos);
-};

package/src/lib/rss/item/itemSeason.ts

@@ -1,26 +0,0 @@
-import { Episode } from "podcast-partytime";
-import { ChannelSeasonIndex, EntityManager, Item, ItemSeasonDto,
-  ItemSeasonService } from "podverse-orm";
-import { compatItemSeasonDto } from "@parser/lib/compat/partytime/item";
-import { handleParsedOneData } from "../base/handleParsedOneData";
-
-export const handleParsedItemSeason = async (
-  parsedItem: Episode,
-  item: Item,
-  channelSeasonIndex: ChannelSeasonIndex,
-  transactionalEntityManager: EntityManager
-) => {
-  const itemSeasonService = new ItemSeasonService(transactionalEntityManager);
-  const itemSeasonDto = compatItemSeasonDto(parsedItem);
-
-  if (itemSeasonDto) {
-    const channel_season = itemSeasonDto.number ? channelSeasonIndex[itemSeasonDto.number] : null;
-    if (channel_season) {
-      const enrichedItemSeasonDto: ItemSeasonDto = {
-        title: itemSeasonDto.title,
-        channel_season
-      };
-      await handleParsedOneData(item, itemSeasonService, enrichedItemSeasonDto);
-    }
-  }
-};

package/src/lib/rss/item/itemSeasonEpisode.ts

@@ -1,14 +0,0 @@
-import { Episode } from "podcast-partytime";
-import { EntityManager, Item, ItemSeasonEpisodeService } from "podverse-orm";
-import { compatItemSeasonEpisodeDto } from "@parser/lib/compat/partytime/item";
-import { handleParsedOneData } from "../base/handleParsedOneData";
-
-export const handleParsedItemSeasonEpisode = async (
-  parsedItem: Episode,
-  item: Item,
-  transactionalEntityManager: EntityManager
-) => {
-  const itemSeasonEpisodeService = new ItemSeasonEpisodeService(transactionalEntityManager);
-  const itemSeasonEpisodeDto = compatItemSeasonEpisodeDto(parsedItem);
-  await handleParsedOneData(item, itemSeasonEpisodeService, itemSeasonEpisodeDto);
-};

package/src/lib/rss/item/itemSocialInteract.ts

@@ -1,14 +0,0 @@
-import { Episode } from "podcast-partytime";
-import { EntityManager, Item, ItemSocialInteractService } from "podverse-orm";
-import { compatItemSocialInteractDtos } from "@parser/lib/compat/partytime/item";
-import { handleParsedManyData } from "../base/handleParsedManyData";
-
-export const handleParsedItemSocialInteract = async (
-  parsedItem: Episode,
-  item: Item,
-  transactionalEntityManager: EntityManager
-) => {
-  const itemSocialInteractService = new ItemSocialInteractService(transactionalEntityManager);
-  const itemSocialInteractDtos = compatItemSocialInteractDtos(parsedItem);
-  await handleParsedManyData(item, itemSocialInteractService, itemSocialInteractDtos);
-};

package/src/lib/rss/item/itemSoundbite.ts

@@ -1,14 +0,0 @@
-import { Episode } from "podcast-partytime";
-import { EntityManager, Item, ItemSoundbiteService } from "podverse-orm";
-import { compatItemSoundbiteDtos } from "@parser/lib/compat/partytime/item";
-import { handleParsedManyData } from "../base/handleParsedManyData";
-
-export const handleParsedItemSoundbite = async (
-  parsedItem: Episode,
-  item: Item,
-  transactionalEntityManager: EntityManager
-) => {
-  const itemSoundbiteService = new ItemSoundbiteService(transactionalEntityManager);
-  const itemSoundbiteDtos = compatItemSoundbiteDtos(parsedItem);
-  await handleParsedManyData(item, itemSoundbiteService, itemSoundbiteDtos);
-};

package/src/lib/rss/item/itemTranscript.ts

@@ -1,14 +0,0 @@
-import { Episode } from "podcast-partytime";
-import { EntityManager, Item, ItemTranscriptService } from "podverse-orm";
-import { compatItemTranscriptDtos } from "@parser/lib/compat/partytime/item";
-import { handleParsedManyData } from "../base/handleParsedManyData";
-
-export const handleParsedItemTranscript = async (
-  parsedItem: Episode,
-  item: Item,
-  transactionalEntityManager: EntityManager
-) => {
-  const itemTranscriptService = new ItemTranscriptService(transactionalEntityManager);
-  const itemTranscriptDtos = compatItemTranscriptDtos(parsedItem);
-  await handleParsedManyData(item, itemTranscriptService, itemTranscriptDtos);
-};

package/src/lib/rss/item/itemTxt.ts

@@ -1,14 +0,0 @@
-import { Episode } from "podcast-partytime";
-import { EntityManager, Item, ItemTxtService } from "podverse-orm";
-import { compatItemTxtDtos } from "@parser/lib/compat/partytime/item";
-import { handleParsedManyData } from "../base/handleParsedManyData";
-
-export const handleParsedItemTxt = async (
-  parsedItem: Episode,
-  item: Item,
-  transactionalEntityManager: EntityManager
-) => {
-  const itemTxtService = new ItemTxtService(transactionalEntityManager);
-  const itemTxtDtos = compatItemTxtDtos(parsedItem);
-  await handleParsedManyData(item, itemTxtService, itemTxtDtos);
-};

package/src/lib/rss/item/itemValue.ts

@@ -1,60 +0,0 @@
-import { Episode } from "podcast-partytime";
-import { EntityManager, Item, ItemValueService, ItemValueRecipientService, ItemValueTimeSplitService,
-  ItemValueTimeSplitRecipientService, ItemValueTimeSplitRemoteItemService
-} from "podverse-orm";
-import { compatItemValueDtos } from "@parser/lib/compat/partytime/item";
-
-export const handleParsedItemValue = async (
-  parsedItem: Episode,
-  item: Item,
-  transactionalEntityManager: EntityManager
-) => {
-  const itemValueService = new ItemValueService(transactionalEntityManager);
-  const itemValueDtos = compatItemValueDtos(parsedItem);
-  const itemValueRecipientService = new ItemValueRecipientService(transactionalEntityManager);
-  const itemValueTimeSplitService = new ItemValueTimeSplitService(transactionalEntityManager);
-  const itemValueTimeSplitRecipientService = new ItemValueTimeSplitRecipientService(transactionalEntityManager);
-  const itemValueTimeSplitRemoteItemService = new ItemValueTimeSplitRemoteItemService(transactionalEntityManager);
-
-  if (itemValueDtos.length > 0) {
-    for (const itemValueDto of itemValueDtos) {
-      const item_value = await itemValueService.update(item, itemValueDto.item_value);
-
-      const itemValueRecipientDtos = itemValueDto.item_value_recipients;
-      if (itemValueRecipientDtos.length > 0) {
-        for (const itemValueRecipientDto of itemValueRecipientDtos) {
-          await itemValueRecipientService.update(item_value, itemValueRecipientDto);
-        }
-      } else {
-        await itemValueRecipientService.deleteAll(item_value);
-      }
-
-      const itemValueTimeSplitDtos = itemValueDto.item_value_time_splits;
-      if (itemValueTimeSplitDtos.length > 0) {
-        for (const itemValueTimeSplitDto of itemValueTimeSplitDtos) {
-          const item_value_time_split = await itemValueTimeSplitService.update(item_value, itemValueTimeSplitDto.meta);
-
-          const itemValueTimeSplitRecipientDtos = itemValueTimeSplitDto.item_value_time_splits_recipients;
-          if (itemValueTimeSplitRecipientDtos.length > 0) {
-            for (const itemValueTimeSplitRecipientDto of itemValueTimeSplitRecipientDtos) {
-              await itemValueTimeSplitRecipientService.update(item_value_time_split, itemValueTimeSplitRecipientDto);
-            }
-          } else {
-            await itemValueTimeSplitRecipientService.deleteAll(item_value_time_split);
-          }
-
-          const itemValueTimeSplitRemoteItemDto = itemValueTimeSplitDto.item_value_time_splits_remote_item;
-          if (itemValueTimeSplitRemoteItemDto) {
-            await itemValueTimeSplitRemoteItemService.update(item_value_time_split, itemValueTimeSplitRemoteItemDto);
-          } else {
-            await itemValueTimeSplitRemoteItemService.deleteAll(item_value_time_split);
-          }
-        }
-      } else {
-        await itemValueTimeSplitService.deleteAll(item_value);
-      }
-    }
-  } else {
-    await itemValueService.deleteAll(item);
-  }
-};

package/src/lib/rss/liveItem/liveItem.ts

@@ -1,34 +0,0 @@
-import { chunkArray } from "podverse-helpers";
-import { Phase4PodcastLiveItem } from "podcast-partytime/dist/parser/phase/phase-4";
-import { AppDataSource, Channel, ChannelSeasonIndex, ItemService, LiveItemService } from "podverse-orm";
-import { compatLiveItemsDtos } from "@parser/lib/compat/partytime/liveItem";
-import { handleParsedItem } from "../item/item";
-
-export const handleParsedLiveItems = async (parsedLiveItems: Phase4PodcastLiveItem[], channel: Channel, channelSeasonIndex: ChannelSeasonIndex) => {
-  const itemService = new ItemService();
-  const existingLiveItems = await itemService.getAllItemsWithLiveItemByChannel(channel, { select: ['id'] });
-  const existingLiveItemIds = existingLiveItems.map(live_item => live_item.id);
-  const updatedLiveItemIds: number[] = [];
-  const liveItemObjDtos = compatLiveItemsDtos(parsedLiveItems);
-
-  const liveItemObjDtosBatchs = chunkArray(liveItemObjDtos, 100);
-  for (const liveItemObjDtosBatch of liveItemObjDtosBatchs) {
-    await AppDataSource.manager.transaction(async transactionalEntityManager => {
-      for (const liveItemObjDto of liveItemObjDtosBatch) {
-        // PTDO: how to make any unnecessary?
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        const itemDto = liveItemObjDto.item as any;
-    
-        const item = await handleParsedItem(itemDto, channel, channelSeasonIndex, transactionalEntityManager);
-        updatedLiveItemIds.push(item.id);
-    
-        const liveItemService = new LiveItemService();
-        const liveItemDto = liveItemObjDto.liveItem;
-        await liveItemService.update(item, liveItemDto);
-      }
-    });
-  }
-
-  const itemIdsToDelete = existingLiveItemIds.filter(id => !updatedLiveItemIds.includes(id));
-  await itemService.deleteMany(itemIdsToDelete);
-};