Untitled

import {model, Schema} from 'mongoose';
import {convertDateToUnix} from "../utils/dates.js";

const PartnershipsSchema = new Schema(
    {
        title: {
            type: String,
            required: true,
        },
        content: {
            type: String,
            required: true,
        },
        metaTitle: {
            type: String,
            required: true,
        },
        metaDesc: {
            type: String,
            required: true,
        },
        pic: {
            type: String,
            required: true,
            default:
                'https://www.hindustantimes.com/ht-img/img/2023/04/10/550x309/Why-do-doctors-oppose-such-Acts--Why-would-they-no_1681127776786.jpg',
        },
        author: {
            type: String,
            required: true
        },
        authorPic: {
            type: String,
            required: true,
            default: 'https://i.stack.imgur.com/l60Hf.png'
        },
        tags: {
            type: Array,
            required: true,
        },
        readMinutes: {
            type: Number,
            required: true,
            default: 0
        },
        scheduled: {
            type: Boolean,
            default: false
        },
        scheduledTime: {
            type: Number,
            default: function () {
                return convertDateToUnix(this.createdAt)
            }
        }
    },

    {
        timestamps: true,
    }
);

const Partnerships = model('Partnerships', PartnershipsSchema);
export default Partnerships;


import asyncHandler from "express-async-handler";
import {convertDateToUnix} from "../utils/dates.js";
import EditorialContact from "../models/EditorialContact.js";
import Partnerships from "../models/Partnerships.js";
import PartnershipSubscribers from "../models/PartnershipSubscriber.js";

export const getPartnerships = asyncHandler(async (req, res) => {
    try {
        const currentTime = convertDateToUnix(new Date())
        const partnerships = await Partnerships.find({})
        const filteredPartnerships = partnerships.filter((partnership) => {
            return partnership.scheduledTime <= currentTime
        })
        return res.json({partnerships: filteredPartnerships})
    } catch (e) {
        return res.json({error: e})
    }
})

export const getScheduledPartnerships = asyncHandler(async (req, res) => {
    try {
        const currentTime = convertDateToUnix(new Date())
        const partnerships = await Partnerships.find({})
        const filteredPartnerships = partnerships.filter((partnership) => {
            return partnership.scheduledTime > currentTime
        })
        return res.json({partnerships: filteredPartnerships})
    } catch (e) {
        return res.json({error: e})
    }
})

export const addPartnership = asyncHandler(async (req, res) => {
    try {
        const {
            title,
            content,
            metaTitle,
            metaDesc,
            pic,
            author,
            authorPic,
            tags,
            readMinutes,
            scheduled,
            scheduledTime
        } = req.body

        let partnership = new Partnerships({
            title,
            content,
            metaTitle,
            metaDesc,
            pic,
            author,
            authorPic,
            tags,
            readMinutes,
            scheduled,
            scheduledTime
        })
        await partnership.save()
        return res.json({partnership})
    } catch (e) {
        return res.json({error: e})
    }
})

export const updatePartnership = asyncHandler(async (req, res) => {
    try {
        const {
            id,
            title,
            content,
            metaTitle,
            metaDesc,
            pic,
            author,
            authorPic,
            tags,
            readMinutes,
            scheduled,
            scheduledTime
        } = req.body
        const partnership = await Partnerships.findById(id)

        if (!partnership) {
            return res.json({error: "Partnership not found!"})
        }

        if (title) partnership.title = title
        if (content) partnership.content = content
        if (metaTitle) partnership.metaTitle = metaTitle
        if (metaDesc) partnership.metaDesc = metaDesc
        if (pic) partnership.pic = pic
        if (author) partnership.author = author
        if (authorPic) partnership.authorPic = authorPic
        if (tags) partnership.tags = tags
        if (readMinutes) partnership.readMinutes = readMinutes
        if (scheduled) partnership.scheduled = scheduled
        if (scheduledTime) partnership.scheduledTime = scheduledTime

        await partnership.save()
        return res.json({partnership})
    } catch (e) {
        return res.json({error: e})
    }
})

export const deletePartnership = asyncHandler(async (req, res) => {
    try {
        const {id} = req.params;
        const partnership = await Partnerships.findById(id);

        if (!partnership) {
            return res.json({error: "Partnership not found!"});
        }

        await partnership.remove();
        return res.json({message: "Partnership deleted successfully"});
    } catch (e) {
        return res.json({error: e});
    }
});

export const deleteAllPartnerships = asyncHandler(async (req, res) => {
    try {
        const {username, password} = req.body;
        if (username !== 'editor' || password !== 'editor12345') {
            return res.json({error: "Invalid username or password"});
        }

        const deleteResult = await Partnerships.deleteMany({});
        if (deleteResult.deletedCount === 0) {
            return res.json({message: "No partnerships found"});
        }

        return res.json({message: "All partnerships deleted successfully"});
    } catch (e) {
        return res.json({error: e});
    }
});

export const getPartnershipById = asyncHandler(async (req, res) => {
    try {
        const {id} = req.params;
        const partnership = await Partnerships.findById(id);

        if (!partnership) {
            return res.json({error: "Partnership not found!"});
        }

        return res.json({partnership});
    } catch (e) {
        return res.json({error: e});
    }
});

export const addPartnershipSubscriber = asyncHandler(async (req, res) => {
    try {
        const {email} = req.body
        let subscriber = new PartnershipSubscribers({email})
        await subscriber.save()
        return res.json({subscriber})
    } catch (e) {
        return res.json({error: e})
    }
})

export const addEditorialContact = asyncHandler(async (req, res) => {
    try {
        const {name, email, subject, message} = req.body
        let contact = new EditorialContact({name, email, subject, message})
        await contact.save()
        return res.json({contact})
    } catch (e) {
        return res.json({error: e})
    }
})


import {model, Schema} from 'mongoose';

const PartnershipSubscriberSchema = new Schema(
    {
        email: {
            type: String,
            required: true,
        },
    },
    {
        timestamps: true,
    }
);

const PartnershipSubscribers = model('PartnershipSubscribers', PartnershipSubscriberSchema);
export default PartnershipSubscribers;


//partnerships
router.get('/partnerships/getPartnerships', getPartnerships)
router.get('/partnerships/getScheduledPartnerships', getScheduledPartnerships)
router.post('/partnerships/addPartnership', addPartnership)
router.put('/partnerships/updatePartnership', updatePartnership)
router.delete('/partnerships/deletePartnership/:id', deletePartnership)
router.get('/partnerships/getPartnership/:id', getPartnershipById)
router.post('/partnerships/addPartnershipSubscriber', addPartnershipSubscriber)
router.post('/partnerships/deleteAllPartnerships', deleteAllPartnerships)