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

package/src/lib/rss/base/handleParsedOneData.ts

@@ -1,17 +0,0 @@
-interface Service<T, P> {
-  update(parentEntity: P, dto: Partial<T>): Promise<T>;
-  _delete?(parentEntity: P): Promise<void>;
-}
-
-export const handleParsedOneData = async <T, P>(
-  parentEntity: P,
-  service: Service<T, P>,
-  dto: Partial<T> | null
-) => {
-  if (dto) {
-    await service.update(parentEntity, dto);
-  } else if (service._delete) {
-    await service._delete(parentEntity);
-  }
-};
-

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

@@ -1,55 +0,0 @@
-import { FeedObject } from "podcast-partytime";
-import { AppDataSource, Channel, ChannelService, ChannelSeasonIndex } from "podverse-orm";
-import { compatChannelDto } from "@parser/lib/compat/partytime/channel";
-import { handleParsedChannelAbout } from "@parser/lib/rss/channel/channelAbout";
-import { handleParsedChannelChat } from "@parser/lib/rss/channel/channelChat";
-import { handleParsedChannelDescription } from "@parser/lib/rss/channel/channelDescription";
-import { handleParsedChannelFunding } from "@parser/lib/rss/channel/channelFunding";
-import { handleParsedChannelImage } from "@parser/lib/rss/channel/channelImage";
-import { handleParsedChannelLicense } from "@parser/lib/rss/channel/channelLicense";
-import { handleParsedChannelLocation } from "@parser/lib/rss/channel/channelLocation";
-import { handleParsedChannelPerson } from "@parser/lib/rss/channel/channelPerson";
-import { handleParsedChannelPodroll } from "@parser/lib/rss/channel/channelPodroll";
-import { handleParsedChannelRemoteItem } from "@parser/lib/rss/channel/channelRemoteItem";
-import { handleParsedChannelSocialInteract } from "@parser/lib/rss/channel/channelSocialInteract";
-import { handleParsedChannelTrailer } from "@parser/lib/rss/channel/channelTrailer";
-import { handleParsedChannelTxt } from "@parser/lib/rss/channel/channelTxt";
-import { handleParsedChannelValue } from "@parser/lib/rss/channel/channelValue";
-
-export const handleParsedChannel = async (parsedFeed: FeedObject, channel: Channel, channelSeasonIndex: ChannelSeasonIndex) => {
-  const channelService = new ChannelService();
-  const channelDto = compatChannelDto(parsedFeed);
-  await channelService.update(channel.id, channelDto);
-  
-  // TODO: add channelCategory support
-  
-  await AppDataSource.manager.transaction(async transactionalEntityManager => {
-    await handleParsedChannelAbout(parsedFeed, channel, transactionalEntityManager);
-    await handleParsedChannelChat(parsedFeed, channel, transactionalEntityManager);
-    await handleParsedChannelDescription(parsedFeed, channel, transactionalEntityManager);
-    await handleParsedChannelFunding(parsedFeed, channel, transactionalEntityManager);
-    await handleParsedChannelImage(parsedFeed, channel, transactionalEntityManager);
-    await handleParsedChannelLicense(parsedFeed, channel, transactionalEntityManager);
-    await handleParsedChannelLocation(parsedFeed, channel, transactionalEntityManager);
-    await handleParsedChannelPerson(parsedFeed, channel, transactionalEntityManager);
-    await handleParsedChannelPodroll(parsedFeed, channel, transactionalEntityManager);
-  
-    // PTDO: add channelPublisher support
-    // const channelPublisherService = new ChannelPublisherService();
-    // const channelPublisherRemoteItemService = new ChannelPublisherRemoteItemService();
-  
-    // const channelPublisherRemoteItemDtos = compatChannelPublisherRemoteItemDtos(parsedFeed);
-    // if (channelPublisherRemoteItemDtos.length > 0) {
-    //   const channel_publisher = await channelPublisherService.update(channel);
-    //   await channelPublisherRemoteItemService.updateMany(channel_publisher, channelPodrollRemoteItemDtos);
-    // } else {
-    //   await channelPublisherService.delete(channel);
-    // }
-  
-    await handleParsedChannelRemoteItem(parsedFeed, channel, transactionalEntityManager);
-    await handleParsedChannelSocialInteract(parsedFeed, channel, transactionalEntityManager);
-    await handleParsedChannelTrailer(parsedFeed, channel, channelSeasonIndex, transactionalEntityManager);
-    await handleParsedChannelTxt(parsedFeed, channel, transactionalEntityManager);
-    await handleParsedChannelValue(parsedFeed, channel, transactionalEntityManager);
-  });
-};

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

@@ -1,13 +0,0 @@
-import { FeedObject } from "podcast-partytime";
-import { ChannelAboutService, Channel, EntityManager } from "podverse-orm";
-import { compatChannelAboutDto } from "@parser/lib/compat/partytime/channel";
-
-export const handleParsedChannelAbout = async (
-  parsedFeed: FeedObject,
-  channel: Channel,
-  transactionalEntityManager: EntityManager
-) => {
-  const channelAboutService = new ChannelAboutService(transactionalEntityManager);
-  const channelAboutDto = compatChannelAboutDto(parsedFeed);
-  await channelAboutService.update(channel, channelAboutDto);
-};

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

@@ -1,14 +0,0 @@
-import { FeedObject } from "podcast-partytime";
-import { Channel, ChannelChatService, EntityManager } from "podverse-orm";
-import { compatChannelChatDto } from "@parser/lib/compat/partytime/channel";
-import { handleParsedOneData } from "../base/handleParsedOneData";
-
-export const handleParsedChannelChat = async (
-  parsedFeed: FeedObject,
-  channel: Channel,
-  transactionalEntityManager: EntityManager
-) => {
-  const channelChatService = new ChannelChatService(transactionalEntityManager);
-  const channelChatDto = compatChannelChatDto(parsedFeed);
-  await handleParsedOneData(channel, channelChatService, channelChatDto);
-};

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

@@ -1,14 +0,0 @@
-import { FeedObject } from "podcast-partytime";
-import { Channel, ChannelDescriptionService, EntityManager } from "podverse-orm";
-import { compatChannelDescriptionDto } from "@parser/lib/compat/partytime/channel";
-import { handleParsedOneData } from "../base/handleParsedOneData";
-
-export const handleParsedChannelDescription = async (
-  parsedFeed: FeedObject,
-  channel: Channel,
-  transactionalEntityManager: EntityManager
-) => {
-  const channelDescriptionService = new ChannelDescriptionService(transactionalEntityManager);
-  const channelDescriptionDto = compatChannelDescriptionDto(parsedFeed);
-  await handleParsedOneData(channel, channelDescriptionService, channelDescriptionDto);
-};

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

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

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

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

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

@@ -1,14 +0,0 @@
-import { FeedObject } from "podcast-partytime";
-import { Channel, ChannelLicenseService, EntityManager } from "podverse-orm";
-import { compatChannelLicenseDto } from "@parser/lib/compat/partytime/channel";
-import { handleParsedOneData } from "../base/handleParsedOneData";
-
-export const handleParsedChannelLicense = async (
-  parsedFeed: FeedObject,
-  channel: Channel,
-  transactionalEntityManager: EntityManager
-) => {
-  const channelLicenseService = new ChannelLicenseService(transactionalEntityManager);
-  const channelLicenseDtos = compatChannelLicenseDto(parsedFeed);
-  await handleParsedOneData(channel, channelLicenseService, channelLicenseDtos);
-};

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

@@ -1,14 +0,0 @@
-import { FeedObject } from "podcast-partytime";
-import { Channel, ChannelLocationService, EntityManager } from "podverse-orm";
-import { compatChannelLocationDto } from "@parser/lib/compat/partytime/channel";
-import { handleParsedOneData } from "../base/handleParsedOneData";
-
-export const handleParsedChannelLocation = async (
-  parsedFeed: FeedObject,
-  channel: Channel,
-  transactionalEntityManager: EntityManager
-) => {
-  const channelLocationService = new ChannelLocationService(transactionalEntityManager);
-  const channelLocationDtos = compatChannelLocationDto(parsedFeed);
-  await handleParsedOneData(channel, channelLocationService, channelLocationDtos);
-};

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

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

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

@@ -1,21 +0,0 @@
-import { FeedObject } from "podcast-partytime";
-import { Channel, ChannelPodrollService, ChannelPodrollRemoteItemService, EntityManager } from "podverse-orm";
-import { compatChannelPodrollRemoteItemDtos } from "@parser/lib/compat/partytime/channel";
-
-export const handleParsedChannelPodroll = async (
-  parsedFeed: FeedObject,
-  channel: Channel,
-  transactionalEntityManager: EntityManager
-) => {
-  const channelPodrollService = new ChannelPodrollService(transactionalEntityManager);
-  const channelPodrollDto = {};
-  const channelPodrollRemoteItemService = new ChannelPodrollRemoteItemService(transactionalEntityManager);
-  const channelPodrollRemoteItemDtos = compatChannelPodrollRemoteItemDtos(parsedFeed);
-  
-  if (channelPodrollRemoteItemDtos.length > 0) {
-    const channel_podroll = await channelPodrollService.update(channel, channelPodrollDto);
-    await channelPodrollRemoteItemService.updateMany(channel_podroll, channelPodrollRemoteItemDtos);
-  } else {
-    await channelPodrollService.delete(channel);
-  }
-};

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

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

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

@@ -1,14 +0,0 @@
-import { FeedObject } from "podcast-partytime";
-import { Channel, ChannelSeasonService } from "podverse-orm";
-import { compatChannelSeasonDtos } from "@parser/lib/compat/partytime/channel";
-
-export const handleParsedChannelSeasons = async (parsedFeed: FeedObject, channel: Channel): Promise<void> => {
-  const channelSeasonService = new ChannelSeasonService();
-  const channelSeasonDtos = compatChannelSeasonDtos(parsedFeed);
-  
-  if (channelSeasonDtos.length > 0) {
-    await channelSeasonService.updateMany(channel, channelSeasonDtos);
-  } else {
-    await channelSeasonService.deleteAll(channel);
-  }
-};

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

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

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);
-};