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

package/src/services/feed/feed.ts

@@ -1,97 +0,0 @@
-import { AppDataSource } from '@orm/db';
-import { Feed } from '@orm/entities/feed/feed';
-import { FeedFlagStatusStatusEnum } from '@orm/entities/feed/feedFlagStatus';
-import { ChannelService } from '@orm/services/channel/channel';
-import { FeedFlagStatusService } from './feedFlagStatus';
-import { applyProperties } from '@orm/lib/applyProperties';
-
-const channelService = new ChannelService();
-
-type FeedCreateDto = {
-  url: string,
-  podcast_index_id: number
-}
-
-type FeedUpdateDto = {
-  url?: string
-  feed_flag_status_id?: number
-  is_parsing?: Date | null
-  parsing_priority?: number
-  last_parsed_file_hash?: string | null
-  container_id?: string | null
-}
-
-export class FeedService {
-  private repository = AppDataSource.getRepository(Feed);
-
-  async get(id: number): Promise<Feed | null> {
-    return this.repository.findOne({ where: { id }});
-  }
-
-  async getAll(): Promise<Feed[]> {
-    return await this.repository.find({
-      relations: ['channel']
-    });
-  }
-
-  async getBy({ url, podcast_index_id }: FeedCreateDto): Promise<Feed | null> {
-    return this.repository.findOne({
-      where: {
-        url,
-        channel: {
-          podcast_index_id
-        }
-      }
-    });
-  }
-
-  async getOrCreate({ url, podcast_index_id }: FeedCreateDto): Promise<Feed> {
-    const feed = await this.repository.findOne({
-      where: { url },
-      relations: ['feed_flag_status', 'feed_log'],
-    });
-
-    if (feed) {
-      return feed;
-    }
-
-    return this.create({ url, podcast_index_id });
-  }
-
-  async create({ url, podcast_index_id }: FeedCreateDto): Promise<Feed> {
-    const feed = new Feed();
-    feed.url = url;
-
-    const feedFlagStatusService = new FeedFlagStatusService();
-    const feed_flag_status = await feedFlagStatusService.get(FeedFlagStatusStatusEnum.None);
-    if (feed_flag_status) {
-      feed.feed_flag_status = feed_flag_status;
-    }
-
-    feed.is_parsing = null;
-    feed.parsing_priority = 1;
-    feed.container_id = '';
-
-    const newFeed = await this.repository.save(feed);
-
-    const channel = await channelService.getOrCreateByPodcastIndexId({
-      feed: newFeed,
-      podcast_index_id
-    });
-    
-    newFeed.channel = channel;
-    return this.repository.save(newFeed);
-  }
-
-  async update(id: number, dto: FeedUpdateDto): Promise<Feed> {
-    let feed = await this.get(id);
-
-    if (!feed) {
-      throw new Error(`FeedService.update: feed ${id} not found`);
-    }
-
-    feed = applyProperties(feed, dto);
-
-    return this.repository.save(feed);
-  }
-}

package/src/services/feed/feedFlagStatus.ts

@@ -1,12 +0,0 @@
-import { AppDataSource } from '@orm/db';
-import { FeedFlagStatus } from '@orm/entities/feed/feedFlagStatus';
-
-export class FeedFlagStatusService {
-  private repository = AppDataSource.getRepository(FeedFlagStatus);
-
-  async get(id: number): Promise<FeedFlagStatus | null> {
-    return await this.repository.findOne({
-      where: { id },
-    });
-  }
-}

package/src/services/feed/feedLog.ts

@@ -1,24 +0,0 @@
-import { Feed } from '@orm/entities/feed/feed';
-import { FeedLog } from '@orm/entities/feed/feedLog';
-import { BaseOneService } from '@orm/services/base/baseOneService';
-
-type FeedLogDto = {
-  last_http_status?: number | null
-  last_good_http_status_time?: Date | null
-  last_finished_parse_time?: Date | null
-  parse_errors?: number
-}
-
-export class FeedLogService extends BaseOneService<FeedLog, 'feed'> {
-  constructor() {
-    super(FeedLog, 'feed');
-  }
-
-  async get(feed: Feed): Promise<FeedLog | null> {
-    return super._get(feed);
-  }
-
-  async update(feed: Feed, dto: FeedLogDto): Promise<FeedLog> {
-    return super._update(feed, dto);
-  }
-}

package/src/services/item/item.ts

@@ -1,118 +0,0 @@
-import { Channel } from '@orm/entities/channel/channel';
-import { Item } from '@orm/entities/item/item';
-import { applyProperties } from '@orm/lib/applyProperties';
-import { FindManyOptions, IsNull, Not, Repository } from 'typeorm';
-import { AppDataSource } from '@orm/db';
-
-type ItemDto = {
-  title: string | null
-  pubdate: Date | null
-  guid: string | null
-  guid_enclosure_url: string
-}
-
-type ItemGetByDto = {
-  guid: string | null
-  guid_enclosure_url: string
-}
-
-export class ItemService {
-  protected repository: Repository<Item>;
-
-  constructor() {
-    this.repository = AppDataSource.getRepository(Item);
-  }
-
-  async get(id: number): Promise<Item | null> {
-    return this.repository.findOne({ where: { id }, relations: ['item_chapters_feed'] });
-  }
-
-  async _getByIdText(id_text: string): Promise<Item | null> {
-    return this.repository.findOne({ where: { id_text } });
-  }
-
-  async getBy(channel: Channel, dto: ItemGetByDto): Promise<Item | null> {
-    let item = null;
-
-    if (dto.guid) {
-      item = await this.getByGuid(channel, dto.guid);
-    }
-    
-    if (!item && dto.guid_enclosure_url) {
-      item = await this.getByEnclosureUrl(channel, dto.guid_enclosure_url);
-    }
-
-    return item;
-  }
-
-  async getByGuid(channel: Channel, guid: string): Promise<Item | null> {
-    return this.repository.findOne({
-      where: {
-        channel,
-        guid
-      }
-    });
-  }
-
-  async getByEnclosureUrl(channel: Channel, guid_enclosure_url: string): Promise<Item | null> {
-    return this.repository.findOne({
-      where: {
-        channel,
-        guid_enclosure_url
-      }
-    });
-  }
-
-  async getAllItemsByChannel(channel: Channel, options?: FindManyOptions<Item>): Promise<Item[]> {
-    return this.repository.find({
-      where: {
-        channel,
-        live_item: {
-          id: IsNull()
-        }
-      },
-      ...options
-    });
-  }
-
-  async getAllItemsWithLiveItemByChannel(channel: Channel, options?: FindManyOptions<Item>): Promise<Item[]> {
-    return this.repository.find({
-      where: {
-        channel,
-        live_item: {
-          id: Not(IsNull())
-        }
-      },
-      ...options
-    });
-  }
-
-  async update(channel: Channel, dto: ItemDto): Promise<Item> {
-    let item = await this.getBy(channel, {
-      guid_enclosure_url: dto.guid_enclosure_url,
-      guid: dto.guid
-    });
-
-    if (!item) {
-      item = new Item();
-      item.guid = dto.guid;
-      item.guid_enclosure_url = dto.guid_enclosure_url;
-      item.channel = channel;
-      item = await this.repository.save(item);
-    }
-
-    item = applyProperties(item, dto);
-
-    return this.repository.save(item);
-  }
-
-  async delete(id: number): Promise<void> {
-    await this.repository.delete(id);
-  }
-
-  async deleteMany(ids: number[]): Promise<void> {
-    if (ids.length) {
-      await this.repository.delete(ids);
-    }
-  }
-}

package/src/services/item/itemAbout.ts

@@ -1,22 +0,0 @@
-import { EntityManager } from 'typeorm';
-import { Item } from '@orm/entities/item/item';
-import { ItemAbout } from '@orm/entities/item/itemAbout';
-import { ItemItunesEpisodeTypeEnum } from '@orm/entities/item/itemItunesEpisodeType';
-import { BaseOneService } from '@orm/services/base/baseOneService';
-
-type ItemAboutDto = {
-  duration: string | null
-  explicit: boolean | null
-  website_link_url: string | null
-  item_itunes_episode_type: ItemItunesEpisodeTypeEnum
-}
-
-export class ItemAboutService extends BaseOneService<ItemAbout, 'item'> {
-  constructor(transactionalEntityManager?: EntityManager) {
-    super(ItemAbout, 'item', transactionalEntityManager);
-  }
-
-  async update(item: Item, dto: ItemAboutDto): Promise<ItemAbout> {
-    return super._update(item, dto, { relations: ['item_itunes_episode_type'] });
-  }
-}

package/src/services/item/itemChapter.ts

@@ -1,38 +0,0 @@
-import { ItemChapter } from '@orm/entities/item/itemChapter';
-import { ItemChaptersFeed } from '@orm/entities/item/itemChaptersFeed';
-import { BaseManyService } from '@orm/services/base/baseManyService';
-import { FindManyOptions } from 'typeorm';
-
-export type ItemChapterDto = {
-  start_time: string
-  end_time: string | null
-  title: string | null
-  web_url: string | null
-  table_of_contents: boolean
-}
-
-export class ItemChapterService extends BaseManyService<ItemChapter, 'item_chapters_feed'> {
-  constructor() {
-    super(ItemChapter, 'item_chapters_feed');
-  }
-
-  async getAll(item_chapters_feed: ItemChaptersFeed, config?: FindManyOptions<ItemChapter>): Promise<ItemChapter[]> {
-    return super._getAll(item_chapters_feed, config);
-  }
-
-  async update(item_chapters_feed: ItemChaptersFeed, dto: ItemChapterDto): Promise<ItemChapter> {    
-    const whereKeys = ['start_time', 'end_time', 'table_of_contents'] as (keyof ItemChapter)[];
-    return super._update(item_chapters_feed, whereKeys, dto);
-  }
-
-  async updateMany(item_chapters_feed: ItemChaptersFeed, dtos: ItemChapterDto[]): Promise<ItemChapter[]> {
-    const whereKeys = ['start_time', 'end_time', 'table_of_contents'] as (keyof ItemChapter)[];
-    return super._updateMany(item_chapters_feed, whereKeys, dtos);
-  }
-
-  async deleteMany(ids: number[]): Promise<void> {
-    if (ids.length) {
-      await this.repository.delete(ids);
-    }
-  }
-}

package/src/services/item/itemChaptersFeed.ts

@@ -1,19 +0,0 @@
-import { EntityManager } from 'typeorm';
-import { Item } from '@orm/entities/item/item';
-import { ItemChaptersFeed } from '@orm/entities/item/itemChaptersFeed';
-import { BaseOneService } from '@orm/services/base/baseOneService';
-
-type ItemChaptersFeedDto = {
-  url: string
-  type: string
-}
-
-export class ItemChaptersFeedService extends BaseOneService<ItemChaptersFeed, 'item'> {
-  constructor(transactionalEntityManager?: EntityManager) {
-    super(ItemChaptersFeed, 'item', transactionalEntityManager);
-  }
-
-  async update(item: Item, dto: ItemChaptersFeedDto): Promise<ItemChaptersFeed> {
-    return super._update(item, dto);
-  }
-}

package/src/services/item/itemChaptersFeedLog.ts

@@ -1,24 +0,0 @@
-import { ItemChaptersFeed } from '@orm/entities/item/itemChaptersFeed';
-import { ItemChaptersFeedLog } from '@orm/entities/item/itemChaptersFeedLog';
-import { BaseOneService } from '@orm/services/base/baseOneService';
-
-type ItemChaptersFeedLogDto = {
-  last_http_status?: number | null
-  last_good_http_status_time?: Date | null
-  last_finished_parse_time?: Date | null
-  parse_errors?: number
-}
-
-export class ItemChaptersFeedLogService extends BaseOneService<ItemChaptersFeedLog, 'item_chapters_feed'> {
-  constructor() {
-    super(ItemChaptersFeedLog, 'item_chapters_feed');
-  }
-
-  async get(item_chapters_feed: ItemChaptersFeed): Promise<ItemChaptersFeedLog | null> {
-    return super._get(item_chapters_feed);
-  }
-
-  async update(item_chapters_feed: ItemChaptersFeed, dto: ItemChaptersFeedLogDto): Promise<ItemChaptersFeedLog> {
-    return super._update(item_chapters_feed, dto);
-  }
-}

package/src/services/item/itemChat.ts

@@ -1,21 +0,0 @@
-import { EntityManager } from 'typeorm';
-import { Item } from '@orm/entities/item/item';
-import { ItemChat } from '@orm/entities/item/itemChat';
-import { BaseOneService } from '@orm/services/base/baseOneService';
-
-type ItemChatDto = {
-  server: string
-  protocol: string | null
-  account_id: string | null
-  space: string | null
-}
-
-export class ItemChatService extends BaseOneService<ItemChat, 'item'> {
-  constructor(transactionalEntityManager?: EntityManager) {
-    super(ItemChat, 'item', transactionalEntityManager);
-  }
-
-  async update(item: Item, dto: ItemChatDto): Promise<ItemChat> {
-    return super._update(item, dto);
-  }
-}

package/src/services/item/itemContentLink.ts

@@ -1,24 +0,0 @@
-import { Item } from '@orm/entities/item/item';
-import { ItemContentLink } from '@orm/entities/item/itemContentLink';
-import { BaseManyService } from '@orm/services/base/baseManyService';
-
-type ItemContentLinkDto = {
-  url: string
-  title?: string | null
-}
-
-export class ItemContentLinkService extends BaseManyService<ItemContentLink, 'item'> {
-  constructor() {
-    super(ItemContentLink, 'item');
-  }
-
-  async update(item: Item, dto: ItemContentLinkDto): Promise<ItemContentLink> {
-    const whereKeys = ['href'] as (keyof ItemContentLink)[];
-    return super._update(item, whereKeys, dto);
-  }
-
-  async updateMany(item: Item, dtos: ItemContentLinkDto[]): Promise<ItemContentLink[]> {
-    const whereKeys = ['href'] as (keyof ItemContentLink)[];
-    return super._updateMany(item, whereKeys, dtos);
-  }
-}

package/src/services/item/itemDescription.ts

@@ -1,18 +0,0 @@
-import { EntityManager } from 'typeorm';
-import { Item } from '@orm/entities/item/item';
-import { ItemDescription } from '@orm/entities/item/itemDescription';
-import { BaseOneService } from '@orm/services/base/baseOneService';
-
-type ItemDescriptionDto = {
-  value: string
-}
-
-export class ItemDescriptionService extends BaseOneService<ItemDescription, 'item'> {
-  constructor(transactionalEntityManager?: EntityManager) {
-    super(ItemDescription, 'item', transactionalEntityManager);
-  }
-
-  async update(item: Item, dto: ItemDescriptionDto): Promise<ItemDescription> {
-    return super._update(item, dto);
-  }
-}

package/src/services/item/itemEnclosure.ts

@@ -1,36 +0,0 @@
-import { EntityManager } from 'typeorm';
-import { Item } from '@orm/entities/item/item';
-import { ItemEnclosure } from '@orm/entities/item/itemEnclosure';
-import { BaseManyService } from '@orm/services/base/baseManyService';
-
-type ItemEnclosureDto = {
-  type: string
-  length: number | null
-  bitrate: number | null
-  height: number | null
-  language: string | null
-  title: string | null
-  rel: string | null
-  codecs: string | null
-  item_enclosure_default: boolean
-}
-
-export class ItemEnclosureService extends BaseManyService<ItemEnclosure, 'item'> {
-  constructor(transactionalEntityManager?: EntityManager) {
-    super(ItemEnclosure, 'item', transactionalEntityManager);
-  }
-
-  async update(item: Item, dto: ItemEnclosureDto): Promise<ItemEnclosure> {
-    const whereKeys = ['type', 'bitrate'] as (keyof ItemEnclosure)[];
-    return super._update(item, whereKeys, dto);
-  }
-
-  async updateMany(item: Item, dtos: ItemEnclosureDto[]): Promise<ItemEnclosure[]> {
-    const whereKeys = ['type', 'bitrate'] as (keyof ItemEnclosure)[];
-    return super._updateMany(item, whereKeys, dtos);
-  }
-
-  async deleteAll(item: Item): Promise<void> {
-    return super._deleteAll(item);
-  }
-}

package/src/services/item/itemEnclosureIntegrity.ts

@@ -1,19 +0,0 @@
-import { ItemEnclosure } from '@orm/entities/item/itemEnclosure';
-import { ItemEnclosureIntegrity } from '@orm/entities/item/itemEnclosureIntegrity';
-import { BaseOneService } from '@orm/services/base/baseOneService';
-import { EntityManager } from 'typeorm';
-
-type ItemEnclosureIntegrityDto = {
-  type: "sri" | "pgp-signature"
-  value: string
-}
-
-export class ItemEnclosureIntegrityService extends BaseOneService<ItemEnclosureIntegrity, 'item_enclosure'> {
-  constructor(transactionalEntityManager?: EntityManager) {
-    super(ItemEnclosureIntegrity, 'item_enclosure', transactionalEntityManager);
-  }
-
-  async update(item_enclosure: ItemEnclosure, dto: ItemEnclosureIntegrityDto): Promise<ItemEnclosureIntegrity> {
-    return super._update(item_enclosure, dto);
-  }
-}

package/src/services/item/itemEnclosureSource.ts

@@ -1,25 +0,0 @@
-import { EntityManager } from 'typeorm';
-import { ItemEnclosure } from '@orm/entities/item/itemEnclosure';
-import { ItemEnclosureSource } from '@orm/entities/item/itemEnclosureSource';
-import { BaseManyService } from '@orm/services/base/baseManyService';
-
-type ItemEnclosureDto = {
-  uri: string
-  content_type: string | null
-}
-
-export class ItemEnclosureSourceService extends BaseManyService<ItemEnclosureSource, 'item_enclosure'> {
-  constructor(transactionalEntityManager?: EntityManager) {
-    super(ItemEnclosureSource, 'item_enclosure', transactionalEntityManager);
-  }
-
-  async update(item_enclosure: ItemEnclosure, dto: ItemEnclosureDto): Promise<ItemEnclosureSource> {
-    const whereKeys = ['uri'] as (keyof ItemEnclosureSource)[];
-    return super._update(item_enclosure, whereKeys, dto);
-  }
-
-  async updateMany(item_enclosure: ItemEnclosure, dtos: ItemEnclosureDto[]): Promise<ItemEnclosureSource[]> {
-    const whereKeys = ['uri'] as (keyof ItemEnclosureSource)[];
-    return super._updateMany(item_enclosure, whereKeys, dtos);
-  }
-}

package/src/services/item/itemFunding.ts

@@ -1,24 +0,0 @@
-import { Item } from '@orm/entities/item/item';
-import { ItemFunding } from '@orm/entities/item/itemFunding';
-import { BaseManyService } from '@orm/services/base/baseManyService';
-
-type ItemFundingDto = {
-  url: string
-  title: string | null
-}
-
-export class ItemFundingService extends BaseManyService<ItemFunding, 'item'> {
-  constructor() {
-    super(ItemFunding, 'item');
-  }
-
-  async update(item: Item, dto: ItemFundingDto): Promise<ItemFunding> {
-    const whereKeys = ['url'] as (keyof ItemFunding)[];
-    return super._update(item, whereKeys, dto);
-  }
-
-  async updateMany(item: Item, dtos: ItemFundingDto[]): Promise<ItemFunding[]> {
-    const whereKeys = ['url'] as (keyof ItemFunding)[];
-    return super._updateMany(item, whereKeys, dtos);
-  }
-}

package/src/services/item/itemImage.ts

@@ -1,33 +0,0 @@
-import { EntityManager } from 'typeorm';
-import { Item } from '@orm/entities/item/item';
-import { ItemImage } from '@orm/entities/item/itemImage';
-import { filterDtosByHighestWidth } from '@orm/lib/filterImageDtosByHighestWidth';
-import { BaseManyService } from '@orm/services/base/baseManyService';
-
-type ItemImageDto = {
-  url: string
-  image_width_size: number | null
-}
-
-export class ItemImageService extends BaseManyService<ItemImage, 'item'> {
-  constructor(transactionalEntityManager?: EntityManager) {
-    super(ItemImage, 'item', transactionalEntityManager);
-  }
-
-  async update(item: Item, dto: ItemImageDto): Promise<ItemImage> {
-    const whereKeys = ['url'] as (keyof ItemImage)[];
-    return super._update(item, whereKeys, dto);
-  }
-
-  async updateMany(item: Item, dtos: ItemImageDto[]): Promise<ItemImage[]> {
-    // TODO: adding image shrinking if an image < 500px is not found
-    
-    const filteredDtos = filterDtosByHighestWidth(dtos);
-    const whereKeys = ['url'] as (keyof ItemImage)[];
-    return super._updateMany(item, whereKeys, filteredDtos);
-  }
-
-  async deleteAll(item: Item): Promise<void> {
-    return super._deleteAll(item);
-  }
-}

package/src/services/item/itemLicense.ts

@@ -1,19 +0,0 @@
-import { EntityManager } from 'typeorm';
-import { Item } from '@orm/entities/item/item';
-import { ItemLicense } from '@orm/entities/item/itemLicense';
-import { BaseOneService } from '@orm/services/base/baseOneService';
-
-type ItemLicenseDto = {
-  identifier: string
-  url: string | null
-}
-
-export class ItemLicenseService extends BaseOneService<ItemLicense, 'item'> {
-  constructor(transactionalEntityManager?: EntityManager) {
-    super(ItemLicense, 'item', transactionalEntityManager);
-  }
-
-  async update(item: Item, dto: ItemLicenseDto): Promise<ItemLicense> {
-    return super._update(item, dto);
-  }
-}

package/src/services/item/itemLocation.ts

@@ -1,20 +0,0 @@
-import { EntityManager } from 'typeorm';
-import { Item } from '@orm/entities/item/item';
-import { ItemLocation } from '@orm/entities/item/itemLocation';
-import { BaseOneService } from '@orm/services/base/baseOneService';
-
-type ItemLocationDto = {
-  geo: string | null
-  osm: string | null
-  name: string | null
-}
-
-export class ItemLocationService extends BaseOneService<ItemLocation, 'item'> {
-  constructor(transactionalEntityManager?: EntityManager) {
-    super(ItemLocation, 'item', transactionalEntityManager);
-  }
-
-  async update(item: Item, dto: ItemLocationDto): Promise<ItemLocation> {
-    return super._update(item, dto);
-  }
-}

package/src/services/item/itemPerson.ts

@@ -1,32 +0,0 @@
-import { EntityManager } from 'typeorm';
-import { Item } from '@orm/entities/item/item';
-import { ItemPerson } from '@orm/entities/item/itemPerson';
-import { BaseManyService } from '@orm/services/base/baseManyService';
-
-type ItemPersonDto = {
-  name: string
-  role: string | null
-  person_group: string | 'cast'
-  img: string | null
-  href: string | null
-}
-
-export class ItemPersonService extends BaseManyService<ItemPerson, 'item'> {
-  constructor(transactionalEntityManager?: EntityManager) {
-    super(ItemPerson, 'item', transactionalEntityManager);
-  }
-
-  async update(item: Item, dto: ItemPersonDto): Promise<ItemPerson> {
-    const whereKeys = ['name'] as (keyof ItemPerson)[];
-    return super._update(item, whereKeys, dto);
-  }
-
-  async updateMany(item: Item, dtos: ItemPersonDto[]): Promise<ItemPerson[]> {
-    const whereKeys = ['name'] as (keyof ItemPerson)[];
-    return super._updateMany(item, whereKeys, dtos);
-  }
-
-  async deleteAll(item: Item): Promise<void> {
-    return super._deleteAll(item);
-  }
-}

package/src/services/item/itemSeason.ts

@@ -1,20 +0,0 @@
-import { EntityManager } from 'typeorm';
-import { Item } from '@orm/entities/item/item';
-import { ItemSeason } from '@orm/entities/item/itemSeason';
-import { BaseOneService } from '../base/baseOneService';
-import { ChannelSeason } from '@orm/entities/channel/channelSeason';
-
-export type ItemSeasonDto = {
-  title: string | null
-  channel_season: ChannelSeason
-}
-
-export class ItemSeasonService extends BaseOneService<ItemSeason, 'item'> {
-  constructor(transactionalEntityManager?: EntityManager) {
-    super(ItemSeason, 'item', transactionalEntityManager);
-  }
-
-  async update(item: Item, dto: ItemSeasonDto): Promise<ItemSeason> {
-    return super._update(item, dto, { relations: ['channel_season'] });
-  }
-}