lexica-dialog-repository/dist/MessageRepository.js

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const mongoose_1 = require("mongoose");
const Message_1 = require("lexica-dialog-model/dist/Message");
const CRUDRepository_1 = require("./CRUDRepository");
const request = new mongoose_1.Schema({
    contentType: {
        type: String,
        required() {
            const type = this.type;
            const { IMAGE, VIDEO, FILE } = Message_1.RequestType;
            return type === IMAGE || type === VIDEO || type === FILE;
        },
    },
    message: {
        type: String,
        required() {
            return this.type === Message_1.RequestType.TEXT;
        },
    },
    path: {
        type: String,
        required() {
            const type = this.type;
            const { IMAGE, VIDEO, FILE } = Message_1.RequestType;
            return type === IMAGE || type === VIDEO || type === FILE;
        },
    },
    type: {
        enum: [
            Message_1.RequestType.AUDIO,
            Message_1.RequestType.FILE,
            Message_1.RequestType.IMAGE,
            Message_1.RequestType.TEXT,
            Message_1.RequestType.VIDEO,
        ],
        index: true,
        required: true,
        type: String,
    },
});
const responseOption = new mongoose_1.Schema({
    command: {
        required: true,
        type: String,
    },
    features: {
        required: true,
        type: mongoose_1.Schema.Types.Mixed,
    },
    message: {
        required: true,
        type: String,
    },
    textOnlyIndicator: {
        required: true,
        type: String,
    },
});
const responseItem = new mongoose_1.Schema({
    message: {
        required: true,
        type: String,
    },
    type: {
        enum: [Message_1.ItemType.AUDIO, Message_1.ItemType.FILE, Message_1.ItemType.IMAGE, Message_1.ItemType.VIDEO],
        required: true,
        type: String,
    },
    url: {
        required: true,
        type: String,
    },
});
const response = new mongoose_1.Schema({
    items: {
        default: undefined,
        required() {
            return this.type === Message_1.ResponseType.ITEMS;
        },
        type: [responseItem],
    },
    message: {
        required: true,
        type: String,
    },
    options: {
        default: undefined,
        required() {
            return this.type === Message_1.ResponseType.OPTIONS;
        },
        type: [responseOption],
    },
    type: {
        enum: [Message_1.ResponseType.TEXT, Message_1.ResponseType.OPTIONS, Message_1.ResponseType.ITEMS],
        index: true,
        required: true,
        type: String,
    },
});
const commentSchema = new mongoose_1.Schema({
    newType: {
        required: false,
        type: Boolean,
    },
    rating: {
        required: false,
        type: Number,
    },
    text: {
        required: false,
        type: String,
    },
});
const messageSchema = new mongoose_1.Schema({
    commands: {
        required: false,
        type: [String],
    },
    comment: {
        required: false,
        type: commentSchema,
    },
    date: {
        index: true,
        required: true,
        type: Date,
    },
    issueId: {
        index: true,
        required: false,
        type: String,
    },
    messenger: {
        index: true,
        required: true,
        type: String,
    },
    rawRequest: {
        required() {
            return this.type === Message_1.MessageType.REQUEST;
        },
        type: mongoose_1.Schema.Types.Mixed,
    },
    rawResponse: {
        required() {
            return this.type === Message_1.MessageType.RESPONSE;
        },
        type: mongoose_1.Schema.Types.Mixed,
    },
    request: {
        required() {
            return this.type === Message_1.MessageType.REQUEST;
        },
        type: request,
    },
    response: {
        required() {
            return this.type === Message_1.MessageType.RESPONSE;
        },
        type: response,
    },
    senderId: {
        index: true,
        required: true,
        type: String,
    },
    sessionId: {
        index: true,
        required: false,
        type: String,
    },
    type: {
        enum: [Message_1.MessageType.REQUEST, Message_1.MessageType.RESPONSE],
        index: true,
        required: true,
        type: String,
    },
    uni: {
        index: true,
        required: true,
        type: String,
    },
});
class MessageRepository extends CRUDRepository_1.default {
    constructor(mongoConnection) {
        super(mongoConnection.model('Message', messageSchema, 'Messages'));
    }
    async findByUni(uni) {
        return this.model.find({ uni }).sort({ date: -1 });
    }
    async findByUniAndSenderId(uni, senderId) {
        return this.model.find({ uni, senderId }).sort({ date: -1 });
    }
    async findPageByUniAndSenderId(pageable, uni, senderId) {
        return this.findPage(pageable, { uni, senderId });
    }
    async findByUniAndSenderIdAndIssueId(uni, senderId, issueId) {
        return this.model.find({ uni, senderId, issueId }).sort({ date: -1 });
    }
    async findByUniAndIssueId(uni, issueId) {
        return this.model.find({ uni, issueId }).sort({ date: -1 });
    }
    async findLatestByUniAndIssueId(uni, issueId) {
        return this.model.find({ uni, issueId }).sort({ date: -1 }).limit(1);
    }
}
exports.MessageRepository = MessageRepository;
const messageRepository = new MessageRepository(mongoose_1.connection);
exports.messageRepository = messageRepository;
//# sourceMappingURL=MessageRepository.js.map