@comasoft/nestjs 0.0.97 → 0.1.2

package/dist/notifications/services/email.service.js

@@ -0,0 +1,69 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+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.EmailService = void 0;
+const common_1 = require("@nestjs/common");
+const config_1 = require("@nestjs/config");
+let EmailService = class EmailService {
+    constructor(configService) {
+        this.configService = configService;
+    }
+    send(recipients) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const provider = this.configService.get('EMAIL_PROVIDER');
+            if (!provider || !this.configService.get('EMAIL_FROM')) {
+                throw new Error('EMAIL_PROVIDER or EMAIL_FROM is not set');
+            }
+            if (provider === 'aws') {
+                return this.sendAws(recipients);
+            }
+            return [];
+        });
+    }
+    sendAws(recipients) {
+        return __awaiter(this, void 0, void 0, function* () {
+            console.log('📧 [EMAIL] AWS SES 배열 발송:', {
+                count: recipients.length,
+                from: this.configService.get('EMAIL_FROM'),
+                provider: this.configService.get('EMAIL_PROVIDER'),
+                recipients: recipients.map(r => ({
+                    user_id: r.user_id,
+                    recipient: r.recipient,
+                    subject: r.subject,
+                    text: r.text.substring(0, 50) + (r.text.length > 50 ? '...' : ''),
+                    variables: r.variables
+                })),
+                timestamp: new Date().toISOString()
+            });
+            return recipients.map(r => ({
+                user_id: r.user_id,
+                recipient: r.recipient,
+                success: true,
+                messageId: `aws-${Date.now()}-${r.user_id}`,
+                status: 'sent'
+            }));
+        });
+    }
+};
+exports.EmailService = EmailService;
+exports.EmailService = EmailService = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [config_1.ConfigService])
+], EmailService);

package/dist/notifications/services/index.d.ts

@@ -0,0 +1,7 @@
+export * from './notification.service';
+export * from './notification-send.service';
+export * from './message-template.service';
+export * from './email.service';
+export * from './kakao.service';
+export * from './sms.service';
+export * from './slack.service';

package/dist/notifications/services/index.js

@@ -0,0 +1,23 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./notification.service"), exports);
+__exportStar(require("./notification-send.service"), exports);
+__exportStar(require("./message-template.service"), exports);
+__exportStar(require("./email.service"), exports);
+__exportStar(require("./kakao.service"), exports);
+__exportStar(require("./sms.service"), exports);
+__exportStar(require("./slack.service"), exports);

package/dist/notifications/services/kakao.service.d.ts

@@ -0,0 +1,41 @@
+import { ConfigService } from '@nestjs/config';
+export declare class KakaoService {
+    private readonly configService;
+    constructor(configService: ConfigService);
+    send(recipients: Array<{
+        recipient: string;
+        user_id: number;
+        template_code: string;
+        variables?: Record<string, any>;
+    }>): Promise<{
+        user_id: number;
+        recipient: string;
+        success: boolean;
+        messageId: string;
+        status: string;
+    }[]>;
+    sendAligo(recipients: Array<{
+        recipient: string;
+        user_id: number;
+        template_code: string;
+        variables?: Record<string, any>;
+    }>): Promise<{
+        user_id: number;
+        recipient: string;
+        success: boolean;
+        messageId: string;
+        status: string;
+    }[]>;
+    sendPpurio(recipients: Array<{
+        recipient: string;
+        user_id: number;
+        template_code: string;
+        variables?: Record<string, any>;
+    }>): Promise<{
+        user_id: number;
+        recipient: string;
+        success: boolean;
+        messageId: string;
+        status: string;
+    }[]>;
+}

package/dist/notifications/services/kakao.service.js

@@ -0,0 +1,94 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+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.KakaoService = void 0;
+const common_1 = require("@nestjs/common");
+const config_1 = require("@nestjs/config");
+let KakaoService = class KakaoService {
+    constructor(configService) {
+        this.configService = configService;
+    }
+    send(recipients) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const provider = this.configService.get('KAKAO_PROVIDER');
+            if (!provider || !this.configService.get('KAKAO_FROM')) {
+                throw new Error('KAKAO_PROVIDER or KAKAO_FROM is not set');
+            }
+            if (provider === 'aligo') {
+                return this.sendAligo(recipients);
+            }
+            else if (provider === 'ppurio') {
+                return this.sendPpurio(recipients);
+            }
+            return [];
+        });
+    }
+    sendAligo(recipients) {
+        return __awaiter(this, void 0, void 0, function* () {
+            console.log('📱 [KAKAO] Aligo 배열 발송:', {
+                count: recipients.length,
+                from: this.configService.get('KAKAO_FROM'),
+                provider: 'aligo',
+                recipients: recipients.map(r => ({
+                    user_id: r.user_id,
+                    recipient: r.recipient,
+                    template_code: r.template_code,
+                    variables: r.variables
+                })),
+                timestamp: new Date().toISOString()
+            });
+            return recipients.map(r => ({
+                user_id: r.user_id,
+                recipient: r.recipient,
+                success: true,
+                messageId: `aligo-${Date.now()}-${r.user_id}`,
+                status: 'sent'
+            }));
+        });
+    }
+    sendPpurio(recipients) {
+        return __awaiter(this, void 0, void 0, function* () {
+            console.log('📱 [KAKAO] Ppurio 배열 발송:', {
+                count: recipients.length,
+                from: this.configService.get('KAKAO_FROM'),
+                provider: 'ppurio',
+                recipients: recipients.map(r => ({
+                    user_id: r.user_id,
+                    recipient: r.recipient,
+                    template_code: r.template_code,
+                    variables: r.variables
+                })),
+                timestamp: new Date().toISOString()
+            });
+            return recipients.map(r => ({
+                user_id: r.user_id,
+                recipient: r.recipient,
+                success: true,
+                messageId: `ppurio-${Date.now()}-${r.user_id}`,
+                status: 'sent'
+            }));
+        });
+    }
+};
+exports.KakaoService = KakaoService;
+exports.KakaoService = KakaoService = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [config_1.ConfigService])
+], KakaoService);

package/dist/notifications/services/message-template.service.d.ts

@@ -0,0 +1,15 @@
+import { Repository } from 'typeorm';
+import { Config } from '../../database/entities';
+export declare class MessageTemplateService {
+    private configRepository;
+    constructor(configRepository: Repository<Config>);
+    getTemplate(type: 'email' | 'sms' | 'slack' | 'kakao', templateKey: string): Promise<any>;
+    getTemplates(): Promise<Record<string, any>>;
+    updateTemplates(templates: any): Promise<void>;
+    renderTemplate(template: {
+        content: string;
+        variables: string[];
+        required_vars: string[];
+        default_vars: Record<string, any>;
+    }, variables: Record<string, any>): string;
+}

package/dist/notifications/services/message-template.service.js

@@ -0,0 +1,74 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+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.MessageTemplateService = void 0;
+const common_1 = require("@nestjs/common");
+const typeorm_1 = require("@nestjs/typeorm");
+const typeorm_2 = require("typeorm");
+const entities_1 = require("../../database/entities");
+let MessageTemplateService = class MessageTemplateService {
+    constructor(configRepository) {
+        this.configRepository = configRepository;
+    }
+    getTemplate(type, templateKey) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const templates = yield this.getTemplates();
+            return (_a = templates[type]) === null || _a === void 0 ? void 0 : _a[templateKey];
+        });
+    }
+    getTemplates() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const config = yield this.configRepository.findOne({
+                where: { key: 'message_templates', is_active: true },
+            });
+            return (config === null || config === void 0 ? void 0 : config.value) || {};
+            return {};
+        });
+    }
+    updateTemplates(templates) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.configRepository.update({ key: 'message_templates' }, { value: templates, updated_at: new Date() });
+        });
+    }
+    renderTemplate(template, variables) {
+        const missing = template.required_vars.filter((v) => { var _a; return variables[v] === undefined && ((_a = template.default_vars) === null || _a === void 0 ? void 0 : _a[v]) === undefined; });
+        if (missing.length > 0) {
+            throw new Error(`Missing required variables: ${missing.join(', ')}`);
+        }
+        return template.content.replace(/\{\{(\w+)\}\}/g, (match, key) => {
+            var _a;
+            if (variables[key] !== undefined)
+                return variables[key];
+            if (((_a = template.default_vars) === null || _a === void 0 ? void 0 : _a[key]) !== undefined)
+                return template.default_vars[key];
+            return '';
+        });
+    }
+};
+exports.MessageTemplateService = MessageTemplateService;
+exports.MessageTemplateService = MessageTemplateService = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, typeorm_1.InjectRepository)(entities_1.Config)),
+    __metadata("design:paramtypes", [typeorm_2.Repository])
+], MessageTemplateService);

package/dist/notifications/services/notification-send.service.d.ts

@@ -0,0 +1,30 @@
+import { NotificationPayload } from '..';
+import { EmailService } from './email.service';
+import { KakaoService } from './kakao.service';
+import { MessageTemplateService } from './message-template.service';
+import { SlackService } from './slack.service';
+import { SmsService } from './sms.service';
+export declare class NotificationSendService {
+    private readonly emailService;
+    private readonly smsService;
+    private readonly kakaoService;
+    private readonly slackService;
+    private readonly messageTemplateService;
+    constructor(emailService: EmailService, smsService: SmsService, kakaoService: KakaoService, slackService: SlackService, messageTemplateService: MessageTemplateService);
+    send(payload: NotificationPayload): Promise<{
+        user_id: number;
+        recipient: string;
+        success: boolean;
+        messageId: string;
+        status: string;
+    }[] | {
+        channel: string;
+        success: boolean;
+        messageId: string;
+        status: string;
+    }[]>;
+    private sendEmail;
+    private sendSms;
+    private sendKakao;
+    private sendSlack;
+}

package/dist/notifications/services/notification-send.service.js

@@ -0,0 +1,146 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+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.NotificationSendService = void 0;
+const common_1 = require("@nestjs/common");
+const email_service_1 = require("./email.service");
+const kakao_service_1 = require("./kakao.service");
+const message_template_service_1 = require("./message-template.service");
+const slack_service_1 = require("./slack.service");
+const sms_service_1 = require("./sms.service");
+let NotificationSendService = class NotificationSendService {
+    constructor(emailService, smsService, kakaoService, slackService, messageTemplateService) {
+        this.emailService = emailService;
+        this.smsService = smsService;
+        this.kakaoService = kakaoService;
+        this.slackService = slackService;
+        this.messageTemplateService = messageTemplateService;
+    }
+    send(payload) {
+        return __awaiter(this, void 0, void 0, function* () {
+            switch (payload.type) {
+                case 'email':
+                    return this.sendEmail(payload);
+                case 'sms':
+                    return this.sendSms(payload);
+                case 'kakao':
+                    return this.sendKakao(payload);
+                case 'slack':
+                    return this.sendSlack(payload);
+            }
+        });
+    }
+    sendEmail(payload) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const emailRecipients = [];
+            for (const recipient of payload.recipients) {
+                let content;
+                let subject;
+                if (payload.template_key) {
+                    const template = yield this.messageTemplateService.getTemplate('email', payload.template_key);
+                    if (!template)
+                        throw new Error('Template not found');
+                    const mergedVariables = Object.assign(Object.assign({}, payload.variables), recipient.variables);
+                    content = this.messageTemplateService.renderTemplate(template, mergedVariables);
+                    subject = template.subject;
+                }
+                else {
+                    if (!payload.subject || !payload.body)
+                        throw new Error('subject, body is required');
+                    content = payload.body;
+                    subject = payload.subject;
+                }
+                emailRecipients.push({
+                    recipient: recipient.recipient,
+                    user_id: recipient.user_id,
+                    subject,
+                    text: content,
+                    variables: recipient.variables
+                });
+            }
+            return yield this.emailService.send(emailRecipients);
+        });
+    }
+    sendSms(payload) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const smsRecipients = [];
+            for (const recipient of payload.recipients) {
+                let content;
+                if (payload.template_key) {
+                    const template = yield this.messageTemplateService.getTemplate('sms', payload.template_key);
+                    if (!template)
+                        throw new Error('Template not found');
+                    const mergedVariables = Object.assign(Object.assign({}, payload.variables), recipient.variables);
+                    content = this.messageTemplateService.renderTemplate(template, mergedVariables);
+                }
+                else {
+                    if (!payload.message)
+                        throw new Error('message is required');
+                    content = payload.message;
+                }
+                smsRecipients.push({
+                    recipient: recipient.recipient,
+                    user_id: recipient.user_id,
+                    message: content,
+                    variables: recipient.variables
+                });
+            }
+            return yield this.smsService.send(smsRecipients);
+        });
+    }
+    sendKakao(payload) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const kakaoRecipients = payload.recipients.map(recipient => ({
+                recipient: recipient.recipient,
+                user_id: recipient.user_id,
+                template_code: payload.template_key,
+                variables: Object.assign(Object.assign({}, payload.variables), recipient.variables)
+            }));
+            return yield this.kakaoService.send(kakaoRecipients);
+        });
+    }
+    sendSlack(payload) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let content;
+            if (payload.template_key) {
+                const template = yield this.messageTemplateService.getTemplate('slack', payload.template_key);
+                if (!template)
+                    throw new Error('Template not found');
+                content = this.messageTemplateService.renderTemplate(template, payload.variables || {});
+            }
+            else {
+                if (!payload.message)
+                    throw new Error('message is required');
+                content = payload.message;
+            }
+            const result = yield this.slackService.send(payload.channel, content);
+            return [result];
+        });
+    }
+};
+exports.NotificationSendService = NotificationSendService;
+exports.NotificationSendService = NotificationSendService = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [email_service_1.EmailService,
+        sms_service_1.SmsService,
+        kakao_service_1.KakaoService,
+        slack_service_1.SlackService,
+        message_template_service_1.MessageTemplateService])
+], NotificationSendService);

package/dist/notifications/services/notification.service.d.ts

@@ -0,0 +1,37 @@
+import { ConfigService } from '@nestjs/config';
+import { Repository } from 'typeorm';
+import { Notification, NotificationRecipient } from '../../database/entities';
+import { NOTIFICATION_STATUS } from '../../enums.common';
+export declare class NotificationService {
+    private readonly notificationRepository;
+    private readonly notificationRecipientRepository;
+    private readonly configService;
+    constructor(notificationRepository: Repository<Notification>, notificationRecipientRepository: Repository<NotificationRecipient>, configService: ConfigService);
+    create({ type, template_key, title, content, recipients, variables, }: {
+        type: string;
+        template_key: string;
+        title?: string;
+        content?: string;
+        recipients: Array<{
+            user_id: number;
+            recipient: string;
+            variables?: Record<string, any>;
+        }>;
+        variables?: Record<string, any>;
+    }): Promise<{
+        notification: {
+            type: string;
+            template_key: string;
+            title: string;
+            content: string;
+            sender: string;
+            status: NOTIFICATION_STATUS.PENDING;
+        } & Notification;
+        recipients: NotificationRecipient[];
+    }>;
+    private getSenderByType;
+    findAll(): Promise<Notification[]>;
+    find(id: number): Promise<Notification>;
+    resend(notification_id: number, user_id?: number): Promise<NotificationRecipient[]>;
+    markAsRead(notification_id: number, user_id: number): Promise<NotificationRecipient>;
+}

package/dist/notifications/services/notification.service.js

@@ -0,0 +1,125 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+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.NotificationService = void 0;
+const common_1 = require("@nestjs/common");
+const typeorm_1 = require("@nestjs/typeorm");
+const config_1 = require("@nestjs/config");
+const typeorm_2 = require("typeorm");
+const entities_1 = require("../../database/entities");
+const enums_common_1 = require("../../enums.common");
+let NotificationService = class NotificationService {
+    constructor(notificationRepository, notificationRecipientRepository, configService) {
+        this.notificationRepository = notificationRepository;
+        this.notificationRecipientRepository = notificationRecipientRepository;
+        this.configService = configService;
+    }
+    create(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ type, template_key, title, content, recipients, variables, }) {
+            const sender = this.getSenderByType(type);
+            const notification = yield this.notificationRepository.save({
+                type,
+                template_key,
+                title,
+                content,
+                sender,
+                status: enums_common_1.NOTIFICATION_STATUS.PENDING,
+            });
+            const notificationRecipients = recipients.map((recipient) => this.notificationRecipientRepository.create({
+                notification_id: notification.id,
+                user_id: recipient.user_id,
+                recipient: recipient.recipient,
+                variables: recipient.variables,
+                status: enums_common_1.NOTIFICATION_STATUS.PENDING,
+            }));
+            yield this.notificationRecipientRepository.save(notificationRecipients);
+            return { notification, recipients: notificationRecipients };
+        });
+    }
+    getSenderByType(type) {
+        switch (type) {
+            case 'email':
+                return this.configService.get('EMAIL_FROM') || 'noreply@example.com';
+            case 'sms':
+                return this.configService.get('SMS_FROM') || '';
+            case 'kakao':
+                return this.configService.get('KAKAO_FROM') || '';
+            case 'slack':
+                return this.configService.get('SLACK_CHANNEL') || '';
+            default:
+                return '';
+        }
+    }
+    findAll() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.notificationRepository.find({
+                relations: ['recipients'],
+                order: { created_at: 'DESC' },
+            });
+        });
+    }
+    find(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.notificationRepository.findOne({
+                where: { id },
+                relations: ['recipients'],
+            });
+        });
+    }
+    resend(notification_id, user_id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const recipients = yield this.notificationRecipientRepository.find({
+                where: user_id ? { notification_id, user_id } : { notification_id },
+            });
+            for (const recipient of recipients) {
+                recipient.status = enums_common_1.NOTIFICATION_STATUS.PENDING;
+                recipient.failed_at = null;
+                recipient.reason_failed = null;
+                yield this.notificationRecipientRepository.save(recipient);
+            }
+            return recipients;
+        });
+    }
+    markAsRead(notification_id, user_id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const recipient = yield this.notificationRecipientRepository.findOne({
+                where: { notification_id, user_id },
+            });
+            if (recipient) {
+                recipient.status = enums_common_1.NOTIFICATION_STATUS.READ;
+                recipient.read_at = new Date();
+                yield this.notificationRecipientRepository.save(recipient);
+            }
+            return recipient;
+        });
+    }
+};
+exports.NotificationService = NotificationService;
+exports.NotificationService = NotificationService = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, typeorm_1.InjectRepository)(entities_1.Notification)),
+    __param(1, (0, typeorm_1.InjectRepository)(entities_1.NotificationRecipient)),
+    __metadata("design:paramtypes", [typeorm_2.Repository,
+        typeorm_2.Repository,
+        config_1.ConfigService])
+], NotificationService);