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

package/dist/src/services/channel/channelSeason.d.ts

@@ -0,0 +1,15 @@
+import { Channel } from '@/entities/channel/channel';
+import { ChannelSeason } from '@/entities/channel/channelSeason';
+import { BaseManyService } from '@/services/base/baseManyService';
+type ChannelSeasonDto = {
+    number: number;
+    name: string | null;
+};
+export type ChannelSeasonIndex = Record<number, ChannelSeason>;
+export declare class ChannelSeasonService extends BaseManyService<ChannelSeason, 'channel'> {
+    constructor();
+    getChannelSeasonIndex(channel: Channel): Promise<ChannelSeasonIndex>;
+    update(channel: Channel, dto: ChannelSeasonDto): Promise<ChannelSeason>;
+    updateMany(channel: Channel, dtos: ChannelSeasonDto[]): Promise<ChannelSeason[]>;
+}
+export {};

package/dist/src/services/channel/channelSeason.js

@@ -0,0 +1,48 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChannelSeasonService = void 0;
+const channelSeason_1 = require("@/entities/channel/channelSeason");
+const baseManyService_1 = require("@/services/base/baseManyService");
+class ChannelSeasonService extends baseManyService_1.BaseManyService {
+    constructor() {
+        super(channelSeason_1.ChannelSeason, 'channel');
+    }
+    getChannelSeasonIndex(channel) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const channelSeasonIndex = {};
+            const channel_seasons = yield this.repository.find({ where: { channel } });
+            for (const channel_season of channel_seasons) {
+                channelSeasonIndex[channel_season.number] = channel_season;
+            }
+            return channelSeasonIndex;
+        });
+    }
+    update(channel, dto) {
+        const _super = Object.create(null, {
+            _update: { get: () => super._update }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            const whereKeys = ['number'];
+            return _super._update.call(this, channel, whereKeys, dto);
+        });
+    }
+    updateMany(channel, dtos) {
+        const _super = Object.create(null, {
+            _updateMany: { get: () => super._updateMany }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            const whereKeys = ['number'];
+            return _super._updateMany.call(this, channel, whereKeys, dtos);
+        });
+    }
+}
+exports.ChannelSeasonService = ChannelSeasonService;

package/dist/src/services/channel/channelSocialInteract.d.ts

@@ -0,0 +1,17 @@
+import { EntityManager } from 'typeorm';
+import { Channel } from '@/entities/channel/channel';
+import { ChannelSocialInteract } from '@/entities/channel/channelSocialInteract';
+import { BaseManyService } from '@/services/base/baseManyService';
+type ChannelSocialInteractDto = {
+    protocol: string;
+    uri: string;
+    account_id: string | null;
+    account_url: string | null;
+    priority: number | null;
+};
+export declare class ChannelSocialInteractService extends BaseManyService<ChannelSocialInteract, 'channel'> {
+    constructor(transactionalEntityManager?: EntityManager);
+    update(channel: Channel, dto: ChannelSocialInteractDto): Promise<ChannelSocialInteract>;
+    updateMany(channel: Channel, dtos: ChannelSocialInteractDto[]): Promise<ChannelSocialInteract[]>;
+}
+export {};

package/dist/src/services/channel/channelSocialInteract.js

@@ -0,0 +1,38 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChannelSocialInteractService = void 0;
+const channelSocialInteract_1 = require("@/entities/channel/channelSocialInteract");
+const baseManyService_1 = require("@/services/base/baseManyService");
+class ChannelSocialInteractService extends baseManyService_1.BaseManyService {
+    constructor(transactionalEntityManager) {
+        super(channelSocialInteract_1.ChannelSocialInteract, 'channel', transactionalEntityManager);
+    }
+    update(channel, dto) {
+        const _super = Object.create(null, {
+            _update: { get: () => super._update }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            const whereKeys = ['uri'];
+            return _super._update.call(this, channel, whereKeys, dto);
+        });
+    }
+    updateMany(channel, dtos) {
+        const _super = Object.create(null, {
+            _updateMany: { get: () => super._updateMany }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            const whereKeys = ['uri'];
+            return _super._updateMany.call(this, channel, whereKeys, dtos);
+        });
+    }
+}
+exports.ChannelSocialInteractService = ChannelSocialInteractService;

package/dist/src/services/channel/channelTrailer.d.ts

@@ -0,0 +1,18 @@
+import { EntityManager } from 'typeorm';
+import { Channel } from '@/entities/channel/channel';
+import { ChannelSeason } from '@/entities/channel/channelSeason';
+import { ChannelTrailer } from '@/entities/channel/channelTrailer';
+import { BaseManyService } from '@/services/base/baseManyService';
+export type ChannelTrailerDto = {
+    url: string;
+    pubdate: Date;
+    title: string | null;
+    length: number | null;
+    type: string | null;
+    channel_season: ChannelSeason | null;
+};
+export declare class ChannelTrailerService extends BaseManyService<ChannelTrailer, 'channel'> {
+    constructor(transactionalEntityManager?: EntityManager);
+    update(channel: Channel, dto: ChannelTrailerDto): Promise<ChannelTrailer>;
+    updateMany(channel: Channel, dtos: ChannelTrailerDto[]): Promise<ChannelTrailer[]>;
+}

package/dist/src/services/channel/channelTrailer.js

@@ -0,0 +1,38 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChannelTrailerService = void 0;
+const channelTrailer_1 = require("@/entities/channel/channelTrailer");
+const baseManyService_1 = require("@/services/base/baseManyService");
+class ChannelTrailerService extends baseManyService_1.BaseManyService {
+    constructor(transactionalEntityManager) {
+        super(channelTrailer_1.ChannelTrailer, 'channel', transactionalEntityManager);
+    }
+    update(channel, dto) {
+        const _super = Object.create(null, {
+            _update: { get: () => super._update }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            const whereKeys = ['url'];
+            return _super._update.call(this, channel, whereKeys, dto);
+        });
+    }
+    updateMany(channel, dtos) {
+        const _super = Object.create(null, {
+            _updateMany: { get: () => super._updateMany }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            const whereKeys = ['url'];
+            return _super._updateMany.call(this, channel, whereKeys, dtos, { relations: ['channel_season'] });
+        });
+    }
+}
+exports.ChannelTrailerService = ChannelTrailerService;

package/dist/src/services/channel/channelTxt.d.ts

@@ -0,0 +1,14 @@
+import { EntityManager } from 'typeorm';
+import { Channel } from '@/entities/channel/channel';
+import { ChannelTxt } from '@/entities/channel/channelTxt';
+import { BaseManyService } from '@/services/base/baseManyService';
+type ChannelTxtDto = {
+    purpose: string | null;
+    value: string;
+};
+export declare class ChannelTxtService extends BaseManyService<ChannelTxt, 'channel'> {
+    constructor(transactionalEntityManager?: EntityManager);
+    update(channel: Channel, dto: ChannelTxtDto): Promise<ChannelTxt>;
+    updateMany(channel: Channel, dtos: ChannelTxtDto[]): Promise<ChannelTxt[]>;
+}
+export {};

package/dist/src/services/channel/channelTxt.js

@@ -0,0 +1,38 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChannelTxtService = void 0;
+const channelTxt_1 = require("@/entities/channel/channelTxt");
+const baseManyService_1 = require("@/services/base/baseManyService");
+class ChannelTxtService extends baseManyService_1.BaseManyService {
+    constructor(transactionalEntityManager) {
+        super(channelTxt_1.ChannelTxt, 'channel', transactionalEntityManager);
+    }
+    update(channel, dto) {
+        const _super = Object.create(null, {
+            _update: { get: () => super._update }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            const whereKeys = ['value'];
+            return _super._update.call(this, channel, whereKeys, dto);
+        });
+    }
+    updateMany(channel, dtos) {
+        const _super = Object.create(null, {
+            _updateMany: { get: () => super._updateMany }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            const whereKeys = ['value'];
+            return _super._updateMany.call(this, channel, whereKeys, dtos);
+        });
+    }
+}
+exports.ChannelTxtService = ChannelTxtService;

package/dist/src/services/channel/channelValue.d.ts

@@ -0,0 +1,15 @@
+import { EntityManager } from 'typeorm';
+import { Channel } from '@/entities/channel/channel';
+import { ChannelValue } from '@/entities/channel/channelValue';
+import { BaseManyService } from '@/services/base/baseManyService';
+type ChannelValueDto = {
+    type: string;
+    method: string;
+    suggested: number | null;
+};
+export declare class ChannelValueService extends BaseManyService<ChannelValue, 'channel'> {
+    constructor(transactionalEntityManager?: EntityManager);
+    update(channel: Channel, dto: ChannelValueDto): Promise<ChannelValue>;
+    updateMany(channel: Channel, dtos: ChannelValueDto[]): Promise<ChannelValue[]>;
+}
+export {};

package/dist/src/services/channel/channelValue.js

@@ -0,0 +1,38 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChannelValueService = void 0;
+const channelValue_1 = require("@/entities/channel/channelValue");
+const baseManyService_1 = require("@/services/base/baseManyService");
+class ChannelValueService extends baseManyService_1.BaseManyService {
+    constructor(transactionalEntityManager) {
+        super(channelValue_1.ChannelValue, 'channel', transactionalEntityManager);
+    }
+    update(channel, dto) {
+        const _super = Object.create(null, {
+            _update: { get: () => super._update }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            const whereKeys = ['type', 'method'];
+            return _super._update.call(this, channel, whereKeys, dto);
+        });
+    }
+    updateMany(channel, dtos) {
+        const _super = Object.create(null, {
+            _updateMany: { get: () => super._updateMany }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            const whereKeys = ['type', 'method'];
+            return _super._updateMany.call(this, channel, whereKeys, dtos);
+        });
+    }
+}
+exports.ChannelValueService = ChannelValueService;

package/dist/src/services/channel/channelValueRecipient.d.ts

@@ -0,0 +1,19 @@
+import { EntityManager } from 'typeorm';
+import { ChannelValue } from '@/entities/channel/channelValue';
+import { ChannelValueRecipient } from '@/entities/channel/channelValueRecipient';
+import { BaseManyService } from '@/services/base/baseManyService';
+type ChannelValueRecipientDto = {
+    type: string;
+    address: string;
+    split: number;
+    name: string | null;
+    custom_key: string | null;
+    custom_value: string | null;
+    fee: boolean;
+};
+export declare class ChannelValueRecipientService extends BaseManyService<ChannelValueRecipient, 'channel_value'> {
+    constructor(transactionalEntityManager?: EntityManager);
+    update(channel_value: ChannelValue, dto: ChannelValueRecipientDto): Promise<ChannelValueRecipient>;
+    updateMany(channel_value: ChannelValue, dtos: ChannelValueRecipientDto[]): Promise<ChannelValueRecipient[]>;
+}
+export {};

package/dist/src/services/channel/channelValueRecipient.js

@@ -0,0 +1,38 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChannelValueRecipientService = void 0;
+const channelValueRecipient_1 = require("@/entities/channel/channelValueRecipient");
+const baseManyService_1 = require("@/services/base/baseManyService");
+class ChannelValueRecipientService extends baseManyService_1.BaseManyService {
+    constructor(transactionalEntityManager) {
+        super(channelValueRecipient_1.ChannelValueRecipient, 'channel_value', transactionalEntityManager);
+    }
+    update(channel_value, dto) {
+        const _super = Object.create(null, {
+            _update: { get: () => super._update }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            const whereKeys = ['type', 'address', 'custom_key', 'custom_value'];
+            return _super._update.call(this, channel_value, whereKeys, dto);
+        });
+    }
+    updateMany(channel_value, dtos) {
+        const _super = Object.create(null, {
+            _updateMany: { get: () => super._updateMany }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            const whereKeys = ['type', 'address', 'custom_key', 'custom_value'];
+            return _super._updateMany.call(this, channel_value, whereKeys, dtos);
+        });
+    }
+}
+exports.ChannelValueRecipientService = ChannelValueRecipientService;

package/dist/src/services/feed/feed.d.ts

@@ -0,0 +1,23 @@
+import { Feed } from '@/entities/feed/feed';
+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 declare class FeedService {
+    private repository;
+    get(id: number): Promise<Feed | null>;
+    getAll(): Promise<Feed[]>;
+    getBy({ url, podcast_index_id }: FeedCreateDto): Promise<Feed | null>;
+    getOrCreate({ url, podcast_index_id }: FeedCreateDto): Promise<Feed>;
+    create({ url, podcast_index_id }: FeedCreateDto): Promise<Feed>;
+    update(id: number, dto: FeedUpdateDto): Promise<Feed>;
+}
+export {};

package/dist/src/services/feed/feed.js

@@ -0,0 +1,92 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FeedService = void 0;
+const db_1 = require("@/db");
+const feed_1 = require("@/entities/feed/feed");
+const feedFlagStatus_1 = require("@/entities/feed/feedFlagStatus");
+const channel_1 = require("@/services/channel/channel");
+const feedFlagStatus_2 = require("./feedFlagStatus");
+const applyProperties_1 = require("@/lib/applyProperties");
+const channelService = new channel_1.ChannelService();
+class FeedService {
+    constructor() {
+        this.repository = db_1.AppDataSource.getRepository(feed_1.Feed);
+    }
+    get(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.repository.findOne({ where: { id } });
+        });
+    }
+    getAll() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.repository.find({
+                relations: ['channel']
+            });
+        });
+    }
+    getBy(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ url, podcast_index_id }) {
+            return this.repository.findOne({
+                where: {
+                    url,
+                    channel: {
+                        podcast_index_id
+                    }
+                }
+            });
+        });
+    }
+    getOrCreate(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ url, podcast_index_id }) {
+            const feed = yield this.repository.findOne({
+                where: { url },
+                relations: ['feed_flag_status', 'feed_log'],
+            });
+            if (feed) {
+                return feed;
+            }
+            return this.create({ url, podcast_index_id });
+        });
+    }
+    create(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ url, podcast_index_id }) {
+            const feed = new feed_1.Feed();
+            feed.url = url;
+            const feedFlagStatusService = new feedFlagStatus_2.FeedFlagStatusService();
+            const feed_flag_status = yield feedFlagStatusService.get(feedFlagStatus_1.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 = yield this.repository.save(feed);
+            const channel = yield channelService.getOrCreateByPodcastIndexId({
+                feed: newFeed,
+                podcast_index_id
+            });
+            newFeed.channel = channel;
+            return this.repository.save(newFeed);
+        });
+    }
+    update(id, dto) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let feed = yield this.get(id);
+            if (!feed) {
+                throw new Error(`FeedService.update: feed ${id} not found`);
+            }
+            feed = (0, applyProperties_1.applyProperties)(feed, dto);
+            return this.repository.save(feed);
+        });
+    }
+}
+exports.FeedService = FeedService;

package/dist/src/services/feed/feedFlagStatus.d.ts

@@ -0,0 +1,5 @@
+import { FeedFlagStatus } from '@/entities/feed/feedFlagStatus';
+export declare class FeedFlagStatusService {
+    private repository;
+    get(id: number): Promise<FeedFlagStatus | null>;
+}

package/dist/src/services/feed/feedFlagStatus.js

@@ -0,0 +1,27 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FeedFlagStatusService = void 0;
+const db_1 = require("@/db");
+const feedFlagStatus_1 = require("@/entities/feed/feedFlagStatus");
+class FeedFlagStatusService {
+    constructor() {
+        this.repository = db_1.AppDataSource.getRepository(feedFlagStatus_1.FeedFlagStatus);
+    }
+    get(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.repository.findOne({
+                where: { id },
+            });
+        });
+    }
+}
+exports.FeedFlagStatusService = FeedFlagStatusService;

package/dist/src/services/feed/feedLog.d.ts

@@ -0,0 +1,14 @@
+import { Feed } from '@/entities/feed/feed';
+import { FeedLog } from '@/entities/feed/feedLog';
+import { BaseOneService } from '@/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 declare class FeedLogService extends BaseOneService<FeedLog, 'feed'> {
+    constructor();
+    update(feed: Feed, dto: FeedLogDto): Promise<FeedLog>;
+}
+export {};

package/dist/src/services/feed/feedLog.js

@@ -0,0 +1,28 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FeedLogService = void 0;
+const feedLog_1 = require("@/entities/feed/feedLog");
+const baseOneService_1 = require("@/services/base/baseOneService");
+class FeedLogService extends baseOneService_1.BaseOneService {
+    constructor() {
+        super(feedLog_1.FeedLog, 'feed');
+    }
+    update(feed, dto) {
+        const _super = Object.create(null, {
+            _update: { get: () => super._update }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            return _super._update.call(this, feed, dto);
+        });
+    }
+}
+exports.FeedLogService = FeedLogService;

package/dist/src/services/item/item.d.ts

@@ -0,0 +1,28 @@
+import { Channel } from '@/entities/channel/channel';
+import { Item } from '@/entities/item/item';
+import { FindManyOptions, Repository } from 'typeorm';
+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 declare class ItemService {
+    protected repository: Repository<Item>;
+    constructor();
+    get(id: number): Promise<Item | null>;
+    _getByIdText(id_text: string): Promise<Item | null>;
+    getBy(channel: Channel, dto: ItemGetByDto): Promise<Item | null>;
+    getByGuid(channel: Channel, guid: string): Promise<Item | null>;
+    getByEnclosureUrl(channel: Channel, guid_enclosure_url: string): Promise<Item | null>;
+    getAllItemsByChannel(channel: Channel, options?: FindManyOptions<Item>): Promise<Item[]>;
+    getAllItemsWithLiveItemByChannel(channel: Channel, options?: FindManyOptions<Item>): Promise<Item[]>;
+    update(channel: Channel, dto: ItemDto): Promise<Item>;
+    delete(id: number): Promise<void>;
+    deleteMany(ids: number[]): Promise<void>;
+}
+export {};