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

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

@@ -0,0 +1,19 @@
+import { EntityManager } from 'typeorm';
+import { Channel } from '@/entities/channel/channel';
+import { ChannelAbout } from '@/entities/channel/channelAbout';
+import { ChannelItunesTypeItunesTypeEnum } from '@/entities/channel/channelItunesType';
+import { BaseOneService } from '@/services/base/baseOneService';
+type ChannelAboutDto = {
+    author: string | null;
+    explicit: boolean | null;
+    language: string | null;
+    last_pub_date: Date | null;
+    website_link_url: string | null;
+    itunes_type: ChannelItunesTypeItunesTypeEnum;
+    episode_count: number;
+};
+export declare class ChannelAboutService extends BaseOneService<ChannelAbout, 'channel'> {
+    constructor(transactionalEntityManager?: EntityManager);
+    update(channel: Channel, dto: ChannelAboutDto): Promise<ChannelAbout>;
+}
+export {};

package/dist/src/services/channel/channelAbout.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.ChannelAboutService = void 0;
+const channelAbout_1 = require("@/entities/channel/channelAbout");
+const baseOneService_1 = require("@/services/base/baseOneService");
+class ChannelAboutService extends baseOneService_1.BaseOneService {
+    constructor(transactionalEntityManager) {
+        super(channelAbout_1.ChannelAbout, 'channel', transactionalEntityManager);
+    }
+    update(channel, dto) {
+        const _super = Object.create(null, {
+            _update: { get: () => super._update }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            return _super._update.call(this, channel, dto, { relations: ['itunes_type'] });
+        });
+    }
+}
+exports.ChannelAboutService = ChannelAboutService;

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

@@ -0,0 +1,15 @@
+import { EntityManager } from 'typeorm';
+import { Channel } from '@/entities/channel/channel';
+import { ChannelChat } from '@/entities/channel/channelChat';
+import { BaseOneService } from '@/services/base/baseOneService';
+type ChannelChatDto = {
+    server: string;
+    protocol: string;
+    account_id: string | null;
+    space: string | null;
+};
+export declare class ChannelChatService extends BaseOneService<ChannelChat, 'channel'> {
+    constructor(transactionalEntityManager?: EntityManager);
+    update(channel: Channel, dto: ChannelChatDto): Promise<ChannelChat>;
+}
+export {};

package/dist/src/services/channel/channelChat.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.ChannelChatService = void 0;
+const channelChat_1 = require("@/entities/channel/channelChat");
+const baseOneService_1 = require("@/services/base/baseOneService");
+class ChannelChatService extends baseOneService_1.BaseOneService {
+    constructor(transactionalEntityManager) {
+        super(channelChat_1.ChannelChat, 'channel', transactionalEntityManager);
+    }
+    update(channel, dto) {
+        const _super = Object.create(null, {
+            _update: { get: () => super._update }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            return _super._update.call(this, channel, dto);
+        });
+    }
+}
+exports.ChannelChatService = ChannelChatService;

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

@@ -0,0 +1,12 @@
+import { EntityManager } from 'typeorm';
+import { Channel } from '@/entities/channel/channel';
+import { ChannelDescription } from '@/entities/channel/channelDescription';
+import { BaseOneService } from '@/services/base/baseOneService';
+type ChannelDescriptionDto = {
+    value: string;
+};
+export declare class ChannelDescriptionService extends BaseOneService<ChannelDescription, 'channel'> {
+    constructor(transactionalEntityManager?: EntityManager);
+    update(channel: Channel, dto: ChannelDescriptionDto): Promise<ChannelDescription>;
+}
+export {};

package/dist/src/services/channel/channelDescription.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.ChannelDescriptionService = void 0;
+const channelDescription_1 = require("@/entities/channel/channelDescription");
+const baseOneService_1 = require("@/services/base/baseOneService");
+class ChannelDescriptionService extends baseOneService_1.BaseOneService {
+    constructor(transactionalEntityManager) {
+        super(channelDescription_1.ChannelDescription, 'channel', transactionalEntityManager);
+    }
+    update(channel, dto) {
+        const _super = Object.create(null, {
+            _update: { get: () => super._update }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            return _super._update.call(this, channel, dto);
+        });
+    }
+}
+exports.ChannelDescriptionService = ChannelDescriptionService;

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

@@ -0,0 +1,14 @@
+import { EntityManager } from 'typeorm';
+import { Channel } from '@/entities/channel/channel';
+import { ChannelFunding } from '@/entities/channel/channelFunding';
+import { BaseManyService } from '@/services/base/baseManyService';
+type ChannelFundingDto = {
+    url: string;
+    title: string | null;
+};
+export declare class ChannelFundingService extends BaseManyService<ChannelFunding, 'channel'> {
+    constructor(transactionalEntityManager?: EntityManager);
+    update(channel: Channel, dto: ChannelFundingDto): Promise<ChannelFunding>;
+    updateMany(channel: Channel, dtos: ChannelFundingDto[]): Promise<ChannelFunding[]>;
+}
+export {};

package/dist/src/services/channel/channelFunding.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.ChannelFundingService = void 0;
+const channelFunding_1 = require("@/entities/channel/channelFunding");
+const baseManyService_1 = require("@/services/base/baseManyService");
+class ChannelFundingService extends baseManyService_1.BaseManyService {
+    constructor(transactionalEntityManager) {
+        super(channelFunding_1.ChannelFunding, '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);
+        });
+    }
+}
+exports.ChannelFundingService = ChannelFundingService;

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

@@ -0,0 +1,14 @@
+import { EntityManager } from 'typeorm';
+import { Channel } from '@/entities/channel/channel';
+import { ChannelImage } from '@/entities/channel/channelImage';
+import { BaseManyService } from '@/services/base/baseManyService';
+type ChannelImageDto = {
+    url: string;
+    image_width_size: number | null;
+};
+export declare class ChannelImageService extends BaseManyService<ChannelImage, 'channel'> {
+    constructor(transactionalEntityManager?: EntityManager);
+    update(channel: Channel, dto: ChannelImageDto): Promise<ChannelImage>;
+    updateMany(channel: Channel, dtos: ChannelImageDto[]): Promise<ChannelImage[]>;
+}
+export {};

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

@@ -0,0 +1,41 @@
+"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.ChannelImageService = void 0;
+const channelImage_1 = require("@/entities/channel/channelImage");
+const filterImageDtosByHighestWidth_1 = require("@/lib/filterImageDtosByHighestWidth");
+const baseManyService_1 = require("@/services/base/baseManyService");
+class ChannelImageService extends baseManyService_1.BaseManyService {
+    constructor(transactionalEntityManager) {
+        super(channelImage_1.ChannelImage, '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* () {
+            // TODO: adding image shrinking if an image < 500px is not found
+            const filteredDtos = (0, filterImageDtosByHighestWidth_1.filterDtosByHighestWidth)(dtos);
+            const whereKeys = ['url'];
+            return _super._updateMany.call(this, channel, whereKeys, filteredDtos);
+        });
+    }
+}
+exports.ChannelImageService = ChannelImageService;

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

@@ -0,0 +1,13 @@
+import { EntityManager } from 'typeorm';
+import { Channel } from '@/entities/channel/channel';
+import { ChannelLicense } from '@/entities/channel/channelLicense';
+import { BaseOneService } from '@/services/base/baseOneService';
+type ChannelLicenseDto = {
+    identifier: string;
+    url: string | null;
+};
+export declare class ChannelLicenseService extends BaseOneService<ChannelLicense, 'channel'> {
+    constructor(transactionalEntityManager?: EntityManager);
+    update(channel: Channel, dto: ChannelLicenseDto): Promise<ChannelLicense>;
+}
+export {};

package/dist/src/services/channel/channelLicense.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.ChannelLicenseService = void 0;
+const channelLicense_1 = require("@/entities/channel/channelLicense");
+const baseOneService_1 = require("@/services/base/baseOneService");
+class ChannelLicenseService extends baseOneService_1.BaseOneService {
+    constructor(transactionalEntityManager) {
+        super(channelLicense_1.ChannelLicense, 'channel', transactionalEntityManager);
+    }
+    update(channel, dto) {
+        const _super = Object.create(null, {
+            _update: { get: () => super._update }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            return _super._update.call(this, channel, dto);
+        });
+    }
+}
+exports.ChannelLicenseService = ChannelLicenseService;

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

@@ -0,0 +1,14 @@
+import { EntityManager } from 'typeorm';
+import { Channel } from '@/entities/channel/channel';
+import { ChannelLocation } from '@/entities/channel/channelLocation';
+import { BaseOneService } from '@/services/base/baseOneService';
+type ChannelLocationDto = {
+    geo: string | null;
+    osm: string | null;
+    name: string | null;
+};
+export declare class ChannelLocationService extends BaseOneService<ChannelLocation, 'channel'> {
+    constructor(transactionalEntityManager?: EntityManager);
+    update(channel: Channel, dto: ChannelLocationDto): Promise<ChannelLocation>;
+}
+export {};

package/dist/src/services/channel/channelLocation.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.ChannelLocationService = void 0;
+const channelLocation_1 = require("@/entities/channel/channelLocation");
+const baseOneService_1 = require("@/services/base/baseOneService");
+class ChannelLocationService extends baseOneService_1.BaseOneService {
+    constructor(transactionalEntityManager) {
+        super(channelLocation_1.ChannelLocation, 'channel', transactionalEntityManager);
+    }
+    update(channel, dto) {
+        const _super = Object.create(null, {
+            _update: { get: () => super._update }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            return _super._update.call(this, channel, dto);
+        });
+    }
+}
+exports.ChannelLocationService = ChannelLocationService;

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

@@ -0,0 +1,17 @@
+import { EntityManager } from 'typeorm';
+import { Channel } from '@/entities/channel/channel';
+import { ChannelPerson } from '@/entities/channel/channelPerson';
+import { BaseManyService } from '@/services/base/baseManyService';
+type ChannelPersonDto = {
+    name: string;
+    role: string | null;
+    person_group: string | 'cast';
+    img: string | null;
+    href: string | null;
+};
+export declare class ChannelPersonService extends BaseManyService<ChannelPerson, 'channel'> {
+    constructor(transactionalEntityManager?: EntityManager);
+    update(channel: Channel, dto: ChannelPersonDto): Promise<ChannelPerson>;
+    updateMany(channel: Channel, dtos: ChannelPersonDto[]): Promise<ChannelPerson[]>;
+}
+export {};

package/dist/src/services/channel/channelPerson.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.ChannelPersonService = void 0;
+const channelPerson_1 = require("@/entities/channel/channelPerson");
+const baseManyService_1 = require("@/services/base/baseManyService");
+class ChannelPersonService extends baseManyService_1.BaseManyService {
+    constructor(transactionalEntityManager) {
+        super(channelPerson_1.ChannelPerson, 'channel', transactionalEntityManager);
+    }
+    update(channel, dto) {
+        const _super = Object.create(null, {
+            _update: { get: () => super._update }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            const whereKeys = ['name'];
+            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 = ['name'];
+            return _super._updateMany.call(this, channel, whereKeys, dtos);
+        });
+    }
+}
+exports.ChannelPersonService = ChannelPersonService;

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

@@ -0,0 +1,10 @@
+import { EntityManager } from 'typeorm';
+import { Channel } from '@/entities/channel/channel';
+import { ChannelPodroll } from '@/entities/channel/channelPodroll';
+import { BaseOneService } from '@/services/base/baseOneService';
+type ChannelPodrollDto = object;
+export declare class ChannelPodrollService extends BaseOneService<ChannelPodroll, 'channel'> {
+    constructor(transactionalEntityManager?: EntityManager);
+    update(channel: Channel, dto: ChannelPodrollDto): Promise<ChannelPodroll>;
+}
+export {};

package/dist/src/services/channel/channelPodroll.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.ChannelPodrollService = void 0;
+const channelPodroll_1 = require("@/entities/channel/channelPodroll");
+const baseOneService_1 = require("@/services/base/baseOneService");
+class ChannelPodrollService extends baseOneService_1.BaseOneService {
+    constructor(transactionalEntityManager) {
+        super(channelPodroll_1.ChannelPodroll, 'channel', transactionalEntityManager);
+    }
+    update(channel, dto) {
+        const _super = Object.create(null, {
+            _update: { get: () => super._update }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            return _super._update.call(this, channel, dto);
+        });
+    }
+}
+exports.ChannelPodrollService = ChannelPodrollService;

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

@@ -0,0 +1,15 @@
+import { EntityManager } from 'typeorm';
+import { ChannelPodroll } from '@/entities/channel/channelPodroll';
+import { ChannelPodrollRemoteItem } from '@/entities/channel/channelPodrollRemoteItem';
+import { BaseRemoteItemsService } from '@/services/base/baseRemoteItemsService';
+type ChannelPodrollRemoteItemDto = {
+    feed_guid: string;
+    feed_url: string | null;
+    item_guid: string | null;
+};
+export declare class ChannelPodrollRemoteItemService extends BaseRemoteItemsService<ChannelPodrollRemoteItem, 'channel_podroll'> {
+    constructor(transactionalEntityManager?: EntityManager);
+    update(channel_podroll: ChannelPodroll, dto: ChannelPodrollRemoteItemDto): Promise<ChannelPodrollRemoteItem>;
+    updateMany(channel_podroll: ChannelPodroll, dtos: ChannelPodrollRemoteItemDto[]): Promise<ChannelPodrollRemoteItem[]>;
+}
+export {};

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

@@ -0,0 +1,36 @@
+"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.ChannelPodrollRemoteItemService = void 0;
+const channelPodrollRemoteItem_1 = require("@/entities/channel/channelPodrollRemoteItem");
+const baseRemoteItemsService_1 = require("@/services/base/baseRemoteItemsService");
+class ChannelPodrollRemoteItemService extends baseRemoteItemsService_1.BaseRemoteItemsService {
+    constructor(transactionalEntityManager) {
+        super(channelPodrollRemoteItem_1.ChannelPodrollRemoteItem, 'channel_podroll', transactionalEntityManager);
+    }
+    update(channel_podroll, dto) {
+        const _super = Object.create(null, {
+            update: { get: () => super.update }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            return _super.update.call(this, channel_podroll, dto);
+        });
+    }
+    updateMany(channel_podroll, dtos) {
+        const _super = Object.create(null, {
+            updateMany: { get: () => super.updateMany }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            return _super.updateMany.call(this, channel_podroll, dtos);
+        });
+    }
+}
+exports.ChannelPodrollRemoteItemService = ChannelPodrollRemoteItemService;

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

@@ -0,0 +1,9 @@
+import { Channel } from '@/entities/channel/channel';
+import { ChannelPublisher } from '@/entities/channel/channelPublisher';
+import { BaseOneService } from '@/services/base/baseOneService';
+type ChannelPublisherDto = object;
+export declare class ChannelPublisherService extends BaseOneService<ChannelPublisher, 'channel'> {
+    constructor();
+    update(channel: Channel, dto: ChannelPublisherDto): Promise<ChannelPublisher>;
+}
+export {};

package/dist/src/services/channel/channelPublisher.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.ChannelPublisherService = void 0;
+const channelPublisher_1 = require("@/entities/channel/channelPublisher");
+const baseOneService_1 = require("@/services/base/baseOneService");
+class ChannelPublisherService extends baseOneService_1.BaseOneService {
+    constructor() {
+        super(channelPublisher_1.ChannelPublisher, 'channel');
+    }
+    update(channel, dto) {
+        const _super = Object.create(null, {
+            _update: { get: () => super._update }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            return _super._update.call(this, channel, dto);
+        });
+    }
+}
+exports.ChannelPublisherService = ChannelPublisherService;

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

@@ -0,0 +1,14 @@
+import { ChannelPublisher } from '@/entities/channel/channelPublisher';
+import { ChannelPublisherRemoteItem } from '@/entities/channel/channelPublisherRemoteItem';
+import { BaseRemoteItemsService } from '@/services/base/baseRemoteItemsService';
+type ChannelPublisherRemoteItemDto = {
+    feed_guid: string;
+    feed_url: string | null;
+    item_guid: string | null;
+};
+export declare class ChannelPublisherRemoteItemService extends BaseRemoteItemsService<ChannelPublisherRemoteItem, 'channel_publisher'> {
+    constructor();
+    update(channel_publisher: ChannelPublisher, dto: ChannelPublisherRemoteItemDto): Promise<ChannelPublisherRemoteItem>;
+    updateMany(channel_publisher: ChannelPublisher, dtos: ChannelPublisherRemoteItemDto[]): Promise<ChannelPublisherRemoteItem[]>;
+}
+export {};

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

@@ -0,0 +1,36 @@
+"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.ChannelPublisherRemoteItemService = void 0;
+const channelPublisherRemoteItem_1 = require("@/entities/channel/channelPublisherRemoteItem");
+const baseRemoteItemsService_1 = require("@/services/base/baseRemoteItemsService");
+class ChannelPublisherRemoteItemService extends baseRemoteItemsService_1.BaseRemoteItemsService {
+    constructor() {
+        super(channelPublisherRemoteItem_1.ChannelPublisherRemoteItem, 'channel_publisher');
+    }
+    update(channel_publisher, dto) {
+        const _super = Object.create(null, {
+            update: { get: () => super.update }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            return _super.update.call(this, channel_publisher, dto);
+        });
+    }
+    updateMany(channel_publisher, dtos) {
+        const _super = Object.create(null, {
+            updateMany: { get: () => super.updateMany }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            return _super.updateMany.call(this, channel_publisher, dtos);
+        });
+    }
+}
+exports.ChannelPublisherRemoteItemService = ChannelPublisherRemoteItemService;

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

@@ -0,0 +1,15 @@
+import { EntityManager } from 'typeorm';
+import { Channel } from '@/entities/channel/channel';
+import { ChannelRemoteItem } from '@/entities/channel/channelRemoteItem';
+import { BaseRemoteItemsService } from '@/services/base/baseRemoteItemsService';
+type ChannelRemoteItemDto = {
+    feed_guid: string;
+    feed_url: string | null;
+    item_guid: string | null;
+};
+export declare class ChannelRemoteItemService extends BaseRemoteItemsService<ChannelRemoteItem, 'channel'> {
+    constructor(transactionalEntityManager?: EntityManager);
+    update(channel: Channel, dto: ChannelRemoteItemDto): Promise<ChannelRemoteItem>;
+    updateMany(channel: Channel, dtos: ChannelRemoteItemDto[]): Promise<ChannelRemoteItem[]>;
+}
+export {};

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

@@ -0,0 +1,36 @@
+"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.ChannelRemoteItemService = void 0;
+const channelRemoteItem_1 = require("@/entities/channel/channelRemoteItem");
+const baseRemoteItemsService_1 = require("@/services/base/baseRemoteItemsService");
+class ChannelRemoteItemService extends baseRemoteItemsService_1.BaseRemoteItemsService {
+    constructor(transactionalEntityManager) {
+        super(channelRemoteItem_1.ChannelRemoteItem, 'channel', transactionalEntityManager);
+    }
+    update(channel, dto) {
+        const _super = Object.create(null, {
+            update: { get: () => super.update }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            return _super.update.call(this, channel, dto);
+        });
+    }
+    updateMany(channel, dtos) {
+        const _super = Object.create(null, {
+            updateMany: { get: () => super.updateMany }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            return _super.updateMany.call(this, channel, dtos);
+        });
+    }
+}
+exports.ChannelRemoteItemService = ChannelRemoteItemService;