/ var / www / html / greenpreneurs / api / controllers / [ HOME SHELL ]

Name	Size	Permission
admin.dashboard.controller.js	12.23 KB	-rw-r--r--
auth.controller.js	5.83 KB	-rw-r--r--
blog.controller.js	5.49 KB	-rw-r--r--
event.controller.js	1.43 KB	-rw-r--r--
homePage.controller.js	1.33 KB	-rw-r--r--
individualBlog.controller.js	4.96 KB	-rw-r--r--
user.controller.js	4.33 KB	-rw-r--r--
user.dashboard.controller.js	6.88 KB	-rw-r--r--

Code Editor : admin.dashboard.controller.js

import pool from "../config/db.js";
import { errorHandler } from "../utils/error.js";

export const test = (req, res) => {
    res.json({ message: 'dashboard controller is working!' });
};

// const query = util.promisify(pool.query).bind(pool);

export const getAllTimeBlogEventCommentVerifiedEnt = async (req, res) => {
    try {
        const query = `
            SELECT COUNT(*) AS TotalBlogs FROM BlogData
            UNION ALL
            SELECT COUNT(*) AS TotalEvents FROM Event
            UNION ALL
            SELECT COUNT(*) AS TotalComments FROM Comment
            UNION ALL
            SELECT COUNT(*) AS TotalVerifiedEnt FROM verifiedEnt WHERE IsVerified = true;
        `;

const [results] = await pool.query(query);
        console.log("Result getAllTimeBlogEventCommentVerifiedEnt", results)
        const stats = {
            TotalBlogs: results[0]['TotalBlogs'],
            TotalEvents: results[1]['TotalBlogs'],
            TotalComments: results[2]['TotalBlogs'],
            TotalVerifiedEnt: results[3]['TotalBlogs']
        };

res.status(200).json(stats);
    } catch (err) {
        return errorHandler(err.statusCode, err.message, res);
    }
};

export const getLast30DaysViewLikeShareComment = async (req, res) => {
     //TODO Not used - have to create a api in frontend for Admin dashboard
    try {
        const query = `
            SELECT COUNT(*) AS TotalLikes FROM LikeData 
            WHERE Date >= CURDATE() - INTERVAL 30 DAY
            UNION ALL
            SELECT COUNT(*) AS TotalShares FROM ShareData 
            WHERE Date >= CURDATE() - INTERVAL 30 DAY
            UNION ALL
            SELECT COUNT(*) AS TotalComments FROM Comment 
            WHERE Date >= CURDATE() - INTERVAL 30 DAY
            UNION ALL
            SELECT SUM(TotalViews) AS TotalViews FROM ViewData 
            WHERE Date >= CURDATE() - INTERVAL 30 DAY;
        `;

const [results] = await pool.query(query);
        console.log("Result getLast30DaysViewLikeShareComment", results)

const stats = {
            TotalLikes: results[0]['TotalLikes'],
            TotalShares: results[1]['TotalShares'],
            TotalComments: results[2]['TotalComments'],
            TotalViews: results[3]['TotalViews']
        };

res.status(200).json(stats);
    } catch (err) {
        return errorHandler(err.statusCode, err.message, res);
    }
};

export const addEditorial = async (req, res) => {
    try {
        const text = req.body.content;
        const currentDate = new Date();
        const date = currentDate.toISOString().slice(0, 10);
        const time = currentDate.toTimeString().split(' ')[0];

const query = 'INSERT INTO Editorial (Text, Date, Time) VALUES (?, ?, ?)';
        const values = [text, date, time];

await pool.query(query, values);
        res.status(200).json("Editorial inserted successfully");
    } catch (err) {
        return errorHandler(err.statusCode, err.message, res);
    }
};

export const getEnt = async (req, res) => {
    try {
        const { IsVerified, limit, offset } = req.body.data;

if (isNaN(limit) || isNaN(offset)) {
            return res.status(400).json({ error: "Invalid limit or offset value" });
        }

const query = "SELECT * FROM verifiedEnt WHERE IsVerified = ? LIMIT ? OFFSET ?";
        const [results] = await pool.query(query, [IsVerified, parseInt(limit), parseInt(offset)]);

console.log("Result getEnt", results);

res.status(200).json(results);
    } catch (error) {
        return res.status(500).json({ error: "Internal Server Error" });
    }
};

export const updateEnt = async (req, res) => {
    try {
        const { id, isVerified } = req.body;
        const query = "UPDATE verifiedEnt SET IsVerified = ? WHERE id = ?";
        await pool.query(query, [isVerified, id]);
        res.status(200).json({ message: "Entity updated successfully" });
    } catch (error) {
        return res.status(500).json({ error: "Internal Server Error" });
    }
};

export const deleteEnt = async (req, res) => {
    try {
        const { id } = req.body;
        const query = "DELETE FROM verifiedEnt WHERE id = ?";
        const [results] = await pool.query(query, [id]);

if (results.affectedRows === 0) {
            return res.status(404).json({ error: "Record not found" });
        }
        res.status(200).json({ message: "Record deleted successfully" });
    } catch (error) {
        return res.status(500).json({ error: "Internal Server Error" });
    }
};

export const getAdmins = async (req, res) => {
    try {
        const admins = await pool.query("SELECT * FROM ADMIN");
        console.log("Admin", admins[0]);
        return res.status(200).json(admins[0]);
    } catch (error) {
        console.error("Error fetching admins:", error);
        return res.status(500).json({ error: "Internal Server Error" });
    }
};

// Delete an admin
export const deleteAdmin = async (req, res) => {
    try {
        const { id } = req.body;
        const result = await pool.query("DELETE FROM ADMIN WHERE AID = ?", [id]);

if (result.affectedRows === 0) {
            return res.status(404).json({ error: "Admin not found" });
        }

return res.status(200).json({ message: "Admin deleted successfully" });
    } catch (error) {
        console.error("Error deleting admin:", error);
        return res.status(500).json({ error: "Internal Server Error" });
    }
};

// Get blogs with pagination and verification filter
export const getBlogs = async (req, res) => {
    try {
        const { IsVerified, offset, limit } = req.body.data;
        // console.log(req.body.data)
        const blogs = await pool.query(
            `SELECT 
                BlogData.BID,
                BlogData.ImageURL AS BlogImage,
                BlogData.Content,
                BlogData.AdminConfirmed,
                BlogData.Date,
                BlogData.Time,
                UserData.Name AS UserName,
                UserData.ImageURL AS UserImage
            FROM BlogData
            JOIN UserData ON BlogData.CID = UserData.CID
            WHERE BlogData.AdminConfirmed = ?
            LIMIT ? OFFSET ?`,
            [IsVerified, limit, offset]
        );

console.log("Admin verify getBlogs", blogs[0]);

return res.status(200).json(blogs[0]);
    } catch (error) {
        console.error("Error fetching blogs:", error);
        return res.status(500).json({ error: "Internal Server Error" });
    }
};

// Delete a blog
export const deleteBlog = async (req, res) => {
    try {
        const { BID } = req.body.data;
        const result = await pool.query("DELETE FROM BlogData WHERE BID = ?", [BID]);

if (result.affectedRows === 0) {
            return res.status(404).json({ error: "Blog not found" });
        }

return res.status(200).json({ message: "Blog deleted successfully" });
    } catch (error) {
        console.error("Error deleting blog:", error);
        return res.status(500).json({ error: "Internal Server Error" });
    }
};

// Update blog's admin confirmation status
export const updateAdminConfirmed = async (req, res) => {
    try {
        const { BID, IsVerified } = req.body.data;
        const result = await pool.query("UPDATE BlogData SET AdminConfirmed = ? WHERE BID = ?", [IsVerified, BID]);

if (result.affectedRows === 0) {
            return res.status(404).json({ error: "Blog not found" });
        }

return res.status(200).json({ message: "Blog updated successfully" });
    } catch (error) {
        console.error("Error updating blog confirmation:", error);
        return res.status(500).json({ error: "Internal Server Error" });
    }
};

// Get all listed products with user details
export const getListProduct = async (req, res) => {
    try {
        const products = await pool.query(
            `SELECT 
                product_list.PID, 
                product_list.name AS ProductName, 
                product_list.description AS ProductDescription, 
                product_list.cost AS ProductCost, 
                product_list.link AS ProductLink, 
                product_list.imageURL AS ProductImageURL, 
                UserData.CID AS UserID, 
                UserData.Name AS UserName, 
                UserData.Email AS UserEmail, 
                UserData.ImageURL AS UserImageURL 
            FROM product_list 
            JOIN UserData ON product_list.CID = UserData.CID`
        );
        console.log('Admin Listed Product',products[0])
        return res.status(200).json(products[0]);
    } catch (error) {
        console.error("Error fetching products:", error);
        return res.status(500).json({ error: "Internal Server Error" });
    }
};

// Delete a product
export const deleteProduct = async (req, res) => {
    try {
        const { id } = req.body;
        const result = await pool.query("DELETE FROM product_list WHERE PID = ?", [id]);

if (result.affectedRows === 0) {
            return res.status(404).json({ error: "Product not found" });
        }

return res.status(200).json({ message: "Product deleted successfully" });
    } catch (error) {
        console.error("Error deleting product:", error);
        return res.status(500).json({ error: "Internal Server Error" });
    }
};

// Add a new resource
export const addResource = async (req, res) => {
    try {
        const { title, description, imageURL, websiteURL } = req.body;

if (!title) {
            return res.status(400).json({ success: false, message: "Title is required" });
        }

const result = await pool.query(
            "INSERT INTO Resources (title, description, imageURL, websiteURL) VALUES (?, ?, ?, ?)",
            [title, description, imageURL, websiteURL]
        );

return res.status(201).json({
            success: true,
            message: "Resource added successfully",
            data: { id: result.insertId, title, description, imageURL, websiteURL },
        });
    } catch (error) {
        console.error("Error adding resource:", error);
        return res.status(500).json({ success: false, message: "Internal Server Error" });
    }
};

// Add a new story
export const addStory = async (req, res) => {
    try {
        const { title, description, imageURL, websiteURL } = req.body;

if (!title) {
            return res.status(400).json({ success: false, message: "Title is required" });
        }

const result = await pool.query(
            "INSERT INTO Stories (title, description, imageURL, websiteURL) VALUES (?, ?, ?, ?)",
            [title, description, imageURL, websiteURL]
        );

return res.status(201).json({
            success: true,
            message: "Story added successfully",
            data: { id: result.insertId, title, description, imageURL, websiteURL },
        });
    } catch (error) {
        console.error("Error adding story:", error);
        return res.status(500).json({ success: false, message: "Internal Server Error" });
    }
};

export const addEvent = async (req, res) => {
    try {
        const { title, content, imageURL, URL, eventDate, eventTime } = req.body.eventData;

// Input validation
        if (!eventDate || !eventTime || !title || !content || !imageURL) {
            return res.status(400).json({ message: "Time, Date, Title, Content, and Image URL are required fields." });
        }

// Insert query
        const sql = `
            INSERT INTO Event (Time, Date, URL, PhotoURL, Title, Description)
            VALUES (?, ?, ?, ?, ?, ?)
        `;
        const values = [eventTime, eventDate, URL, imageURL, title, content];

// Execute the query
        const result = await pool.query(sql, values);

console.log("Event inserted successfully with ID:", result.insertId);
        return res.status(201).json({ message: "Event inserted successfully", eventId: result.insertId });
    } catch (error) {
        console.error("Error inserting event:", error);
        return res.status(500).json({ error: "Internal Server Error" });
    }
};

Urban Research Lab

The Urban Research Lab (URL) at IIIT-Delhi was established in 2020, during a time when the pandemic brought the complexities of urban life more visible than ever. What started as an initiative by faculty and students has grown into a collaborative space for critically exploring and reimagining the urban questions through research, dialogue, and interdisciplinary engagement.

${this.title}

Code Editor : admin.dashboard.controller.js

Urban Research Lab