Node/modules/blogs/middlewares/query.js

const User = require("../../users/models/user").User;
const { where, Op } = require("sequelize");
const { Follow } = require("../../follows/models");
const Blogs = require("../models/Blogs");
const Categories = require("../models/Categories");
const SavedBlogs = require("../models/SavedBlogs");
const { getFollowingsForIds } = require("../../follows/middlewares/query");
const { ReBlog } = require("../models/ReBlogs");
const { editedListPosts, editedPost, startAndEndDates } = require("./proccess");
const { Comments } = require("../../comments/models/Comments");

exports.getBlog = async function({blogId, myUserId}) {
    const blog = await Blogs.findOne({
        where: {
            id: blogId
        },
        include: [User, Categories, {
            model: SavedBlogs,
            where: [(myUserId) ? {
                userId: myUserId
            } : {}],
            required: false
        }, {
            model: Comments,
            include: User
        }]
    });

    (blog) && editedPost(blog);

    return blog;
};

exports.getBlogs = async function({myUserId}){
    return await Blogs.findAll({
        include: [User, Categories, {
            model: SavedBlogs,
            where: {
                userId: myUserId
            },
            required: false
        }],
        order: [["createdAt", "DESC"]]
    });
};

exports.getBlogsWithUserId = async function({userId, category, myUserId, endDate = false, blogIds = false}){
    endDate = (Boolean(endDate) !== false) && new Date(endDate);
    const blogs = await Blogs.findAll({
        where: {
            [Op.and]: [{
                userId: userId
            }, (blogIds !== false) && {
                [Op.not]: {
                    id: blogIds
                }
            },(endDate !== false) && {
                createdAt: {
                    [Op.lt]: endDate
                }
            }]
        },
        include:[(category) ? {
            model: Categories,
            where: {
                href: category
            }
        } : Categories, {
            model: SavedBlogs,
            where: {
                userId: myUserId
            },
            required: false
        }, {
            model: Comments,
            include: User
        }, User],
        limit: 20,
        order: [["createdAt", "DESC"]]
    });

    const date = startAndEndDates(blogs, endDate);

    const reblogs = await ReBlog.findAll({
        where:[{
            userId: userId
        }, (date.status === true && blogIds) ? {
            createdAt: {
                [Op.between]: [date.endDate, date.startDate]
            }
        } : {}],
        include: [{
            model: Blogs,
            where: {
                [Op.not]: {
                    id: blogIds
                }
            },
            include: [(category) ? {
                model: Categories,
                where: {
                    href: category
                }
            } : Categories, User, {
                model: SavedBlogs,
                where: {
                    userId: myUserId
                },
                required: false
            }, {
                model: Comments,
                include: User
            }]
        }, User],
        limit: 20,
        order: [["createdAt", "DESC"]]
    });

    const result = await editedListPosts(blogs, reblogs);

    return result.slice(0, 20);
};

exports.getBlogsWithUsername = async function({username, category, myUserId}){
    const blogs = await Blogs.findAll({
        include:[(category) ? {
            model: Categories,
            where: {
                href: category
            }
        } : Categories, {
            model: User,
            where: {
                username: username
            }
        },{
            model: SavedBlogs,
            where: {
                userId: myUserId
            },
            required: false
        }],
        order: [["createdAt", "DESC"]]
    });

    const reblogs = await ReBlog.findAll({
        include: [{
            model: Blogs,
            include: [Categories, {
                model: User,
                include: {
                    model: Follow,
                    where: {
                        user: myUserId
                    }
                },
                required: true
            }, {
                model: SavedBlogs,
                where: {
                    userId: myUserId
                }
            }]
        }, User]
    });

    const result = new Array(...blogs);
    
    reblogs.map(res => {
        res.blog.dataValues.reblog = true;
        res.blog.dataValues.reUser = res.user;
        result.push(res.blog);
    });

    return result;
};

exports.getBlogsWithCategory = async function({categoryId, categoryTitle, categoryHref, myUserId}){
    return await Blogs.findAll({
        include: [User, Categories, {
            model: Categories,
            where: [(categoryId) && {
                id: categoryId
            }, (categoryTitle) && {
                title: categoryTitle
            }, (categoryHref) && {
                href: categoryHref
            }]
        },{
            model: SavedBlogs,
            where: {
                userId: myUserId
            },
            required: false
        }],
        order: [["createdAt", "DESC"]]
    });
};

exports.getBlogsWithFollows = async function({userId, endDate, blogIds = false}){
    endDate = (endDate) && new Date(endDate);
    console.log(blogIds)
    const blogs = await Blogs.findAll({
        where: {
            [Op.and]: [(blogIds !== false) && {
                [Op.not]: {
                    id: blogIds
                }
            }, (endDate) && {
                createdAt: {
                    [Op.lt]: endDate
                }
            }]
        },
        include: [{
            model: User,
            include: {
                model: Follow,
                where: {
                    user: userId
                },
            },
            required: true
        }, Categories, {
            model: SavedBlogs,
            where: {
                userId: userId
            },
            required: false
        }, {
            model: Comments,
            include: User
        }],
        limit: 20
    });

    const date = startAndEndDates(blogs, endDate);
    
    const reblogs = await ReBlog.findAll({
        where:[(date.status === true && blogIds) ? {
            createdAt: {
                [Op.between]: [date.endDate, date.startDate]
            }
        } : {}],
        include: [{
            model: User,
            include: {
                model: Follow,
                where: {
                    user: userId
                },
            },
            required: true
        }, {
            model: Blogs,
            include: [Categories, {
                model: SavedBlogs,
                where: {
                    userId: userId
                },
                required: false
            }, {
                model: Comments,
                include: User
            }, User]
        }],
        limit: 20
    });
    
    const result = await editedListPosts(blogs, reblogs);
    
    return result.slice(0, 20);
};

exports.getBlogsForFollowsWithCategory = async function({userId, category, endDate = false, blogIds = false}){
    endDate = (endDate !== false) && new Date(endDate);
    const blogs = await Blogs.findAll({
        where: {
            [Op.and]: [(blogIds !== false) && {
                [Op.not]: {
                    id: blogIds
                }
            }, (endDate !== false) && {
                createdAt: {
                    [Op.lt]: endDate
                }
            }]
        },
        include: [{
            model: User,
            include: {
                model: Follow,
                where: {
                    user: userId
                }
            },
            required: true
        }, {
            model: Categories,
            where: {
                href: category
            }
        }, {
            model: SavedBlogs,
            where: {
                userId: userId
            },
            required: false
        }, {
            model: Comments,
            include: User
        }],
        limit: 20
    });

    const date = startAndEndDates(blogs, endDate);

    const reblogs = await ReBlog.findAll({
        where:[(date.status === true && blogIds) ? {
            createdAt: {
                [Op.between]: [date.endDate, date.startDate]
            }
        } : {}],
        include: [{
            model: User,
            include: {
                model: Follow,
                where: {
                    user: userId
                }
            },
            required: true
        }, {
            model: Blogs,
            include: [{
                model: Categories,
                where: {
                    href: category
                }
            }, {
                model: SavedBlogs,
                where: {
                    userId: userId
                },
                required: false
            }, {
                model: Comments,
                include: User
            }, User],
            required: true
        }],
        limit: 20
    });

    const result = await editedListPosts(blogs, reblogs);

    return result.slice(0, 20);
};

exports.getBlogsForDiscover = async function({userId, endDate, blogIds = false}){
    endDate = (endDate) && new Date(endDate);

    const followsIds = await getFollowingsForIds({
        userId: userId
    });

    const blogs = await Blogs.findAll({
        where:[{
            [Op.not]: {
                userId: [followsIds, userId]
            }
        }, (endDate) ? {
            createdAt: {
                [Op.lt]: endDate
            }
        } : {}, (blogIds) ? {
            [Op.not]: {
                id: [blogIds, userId]
            }
        } : {}],
        include: [Categories, {
            model: SavedBlogs,
            where: {
                userId: userId
            },
            required: false
        }, {
            model: Comments,
            include: User
        }, User],
        limit: 20,
        order: [["createdAt", "DESC"]]
    });

    
    const date = startAndEndDates(blogs, endDate);
    
    const reblogs = await ReBlog.findAll({
        where: [{
            [Op.not]: {
                userId: [followsIds, userId]
            }
        }, (date.status === true && blogIds) ? {
            createdAt: {
                [Op.between]: [date.endDate, date.startDate]
            }
        } : {}],
        include:[{
            model: Blogs,
            where: {
                [Op.not]: {
                    userId: [followsIds, userId]
                }
            },
            include: [Categories, User, {
                model: SavedBlogs,
                where: {
                    userId: userId
                },
                required: false
            }, {
                model: Comments,
                include: User
            }]
        }, User],
        limit: 20,
        order: [["createdAt", "DESC"]]
    });

    const result = await editedListPosts(blogs, reblogs);

    return result.splice(0, 20);
};

exports.getBlogsForDiscoverWithCategory = async function({userId, category, endDate, blogIds = false}){
    endDate = (endDate) && new Date(endDate);

    const followsIds = await getFollowingsForIds({
        userId: userId
    });

    console.log(endDate, blogIds);

    const blogs = await Blogs.findAll({
        where:[{
            [Op.not]: {
                userId: [followsIds, userId]
            }
        }, (endDate) && {
            createdAt: {
                [Op.lt]: endDate
            }
        }],
        include: [{
            model: Categories,
            where: {
                href: category
            },
            required: true
        }, {
            model: SavedBlogs,
            where: {
                userId: userId
            },
            required: false
        }, {
            model: Comments,
            include: User
        }, User],
        limit: 20,
        order: [["createdAt", "DESC"]]
    });

    const date = startAndEndDates(blogs, endDate);

    const reblogs = await ReBlog.findAll({
        where: [{
            [Op.not]: {
                userId: [followsIds, userId]
            }
        }, (date.status === true && blogIds) ? {
            createdAt: {
                [Op.between]: [date.endDate, date.startDate]
            }
        } : {}],
        include:[{
            model: Blogs,
            where:[{
                [Op.not]: {
                    userId: [followsIds, userId]
                }
            }],
            include: [{
                model: Categories,
                where: {
                    href: category
                },
                required: true
            }, {
                model: SavedBlogs,
                where: {
                    userId: userId
                },
                required: false
            }, {
                model: Comments,
                include: User
            }, User]
        }, User],
        limit: 20,
        order: [["createdAt", "DESC"]]
    });

    const result = await editedListPosts(blogs, reblogs);

    return result;
};


// CATE
exports.getCategoryWithParams = async function({categoryId, categoryTitle}){
    return await Categories.findOne({
        where:[
            (categoryId) ? {id: categoryId} : {},
            (categoryTitle) ? {title: categoryTitle} : {}
        ]
    });
};


// SAVED
exports.getSaved = async function({userId, blogId}){
    return await SavedBlogs.findOne({
        where:{
            userId: userId,
            blogId: blogId
        }
    });
};