news-cms-module 0.1.2 → 1.1.0

package/routes/index.js

@@ -1,7 +1,14 @@
 const express = require('express');
+const multer  = require('multer');
+const path = require('path');
+const upload = require('../middlewares/multerMiddleware');
+const {CreateNewsValidationRules, UpdateNewsValidationRules} = require('../validations/newsValidations');
+const {validate} = require('../validations/mainValidation');
+const {parseContentBlocks} = require('../middlewares/parseForm');
+const { isAdmin } = require('../middlewares/authAdminMiddleware');
+
 const NewsController = require('../controllers/NewsController');
 const StatController = require('../controllers/StatController');
-const path = require('path');
 
 /**
  * Setup semua route untuk package.
@@ -12,7 +19,11 @@ const path = require('path');
 module.exports = (router, services, config) => {
     // Inisialisasi Controllers dengan services dan config yang dibutuhkan
     const newsController = new NewsController(services.news, services.stat, config);
-    const statController = new StatController(services.stat);
+    const statController = new StatController(services.news, services.stat);
+    const beritaUpload = upload.fields([
+        { name: 'thumbnailImage', maxCount: 1 },
+        { name: 'contentImages', maxCount: 10 }
+    ]);
 
     // 1. Ekspos Aset Statis (CSS)
     // Misalnya, package diakses di /berita-kami, maka aset diakses di /berita-kami/nc-assets
@@ -22,43 +33,45 @@ module.exports = (router, services, config) => {
     // Route ini menggunakan prefix yang ditentukan oleh pengguna (default: '/')
     // router.get(config.publicRoutePrefix, newsController.listPublic.bind(newsController));
 
-    // 2. Route Publik (READ-ONLY API)
-    // Gunakan endpoint yang jelas: /list, /trending, /:slug
     router.get(config.publicRoutePrefix + 'list', newsController.listPublic.bind(newsController));
     
-    // Route detail berita, termasuk tracking middleware
     router.get(`${config.publicRoutePrefix}post/:slug`, 
             statController.trackVisitMiddleware.bind(statController), 
             newsController.getDetail.bind(newsController));
     
-    // Route detail berita (termasuk tracking middleware)
-    // PERHATIAN: Di controller, Anda harus memastikan baseUrl dikirim ke view
-    // router.get(`${config.publicRoutePrefix}:slug`, statController.trackVisitMiddleware.bind(statController), newsController.getDetail.bind(newsController));
-
-    // 3. Route Admin (CRUD)
-    // Route ini menggunakan prefix admin yang ditentukan oleh pengguna (default: '/admin')
     const adminRouter = express.Router();
-    // Middleware otentikasi admin bisa ditambahkan di sini (user harus menyediakannya!)
-
-    // GET /admin/list (Membaca semua post, termasuk DRAFT)
-    adminRouter.get('/list', newsController.adminList.bind(newsController)); 
+    adminRouter.use(isAdmin);
     
-    // GET /admin/:id (Membaca detail post untuk editing)
-    adminRouter.get('/:id', newsController.getDetail.bind(newsController)); 
-    
-    // POST /admin/create (Membuat berita baru)
-    adminRouter.post('/create', newsController.createPost.bind(newsController)); 
+    // adminRouter.get('/create', (req, res) => {
+    //     res.render(path.join(__dirname, '../views/admin/create_news.ejs'));
+    // });
+
+    router.get('/cms-admin/create', (req, res) => {
+        const appBaseUrl = config.baseUrl; 
+        const newsPrefix = config.newsPrefix;
+        const adminPrefix = config.adminRoutePrefix;
+
+        const fullApiUrl = `${appBaseUrl}${adminPrefix}/create`;
+        const nextUrl = `${newsPrefix}${adminPrefix}/list`
+
+        res.render(path.join(__dirname, "../views/admin/create_news.ejs"), {
+            title: 'Buat Berita Baru',
+
+            apiBaseUrl: fullApiUrl,
+            nextUrl
+        });
+    });
+    adminRouter.post('/create', beritaUpload, parseContentBlocks, CreateNewsValidationRules, validate, newsController.createPost.bind(newsController));
+
+    adminRouter.get('/update/:slug', newsController.getEditForAdmin.bind(newsController));
+    adminRouter.patch('/update/:id', newsController.updateStatusNews.bind(newsController)); 
+    adminRouter.put('/update/:id', beritaUpload, parseContentBlocks, UpdateNewsValidationRules, validate, newsController.updatePost.bind(newsController)); 
     
-    // PUT/PATCH /admin/update/:id (Memperbarui berita)
-    adminRouter.put('/update/:id', newsController.updatePost.bind(newsController)); 
+    adminRouter.get('/dashboard', newsController.dashboardAdmin.bind(newsController)); 
+    adminRouter.get('/list', newsController.adminList.bind(newsController)); 
+    adminRouter.get('/:slug', newsController.getDetailForAdmin.bind(newsController)); 
 
-    // DELETE /admin/delete/:id (Menghapus berita)
     adminRouter.delete('/delete/:id', newsController.deletePost.bind(newsController)); 
-
-    // Pasang router admin ke prefix yang ditentukan pengguna (default: '/admin')
     router.use(config.adminRoutePrefix, adminRouter);
-
-    // 4. Route API (Untuk data trending)
     router.get('/api/trending', statController.getTrendingApi.bind(statController));
-
 };

package/services/NewsService.js

@@ -1,79 +1,244 @@
+const { Op, fn, col, where } = require("sequelize");
+
 class NewsService {
-    constructor(NewsModel, ContentNewsModel) {
+    constructor(NewsModel, ContentNewsModel, VisitorLogModel) {
         this.News = NewsModel;
         this.ContentNews = ContentNewsModel;
+        this.VisitorLog = VisitorLogModel
+    }
+
+    async getTrendingNews() {
+        try {
+            const last24Hours = new Date(new Date() - 24 * 60 * 60 * 1000);
+
+            const trending = await this.News.findAll({
+                attributes: [
+                    'id',
+                    'title',
+                    'slug',
+                    'category',
+                    'imagePath',
+                    'authorName',
+                    'createdAt',
+                    [fn('COUNT', col('visits.id')), 'totalViews']
+                ],
+                include: [{
+                    model: this.VisitorLog,
+                    as: 'visits',
+                    attributes: [],
+                    where: {
+                        visitedAt: {
+                            [Op.gt]: last24Hours
+                        }
+                    },
+                    required: true 
+                }],
+                group: ['News.id'],
+                order: [[fn('COUNT', col('visits.id')), 'DESC']],
+                limit: 10, 
+                subQuery: false 
+            });
+
+            return trending;
+        } catch (error) {
+            console.error("Error fetching trending news:", error);
+            throw error;
+        }
     }
 
-    // --- Operasi READ (Membaca) ---
-    async getAllPosts(page = 1, limit = 10, status = 'PUBLISHED') {
-        const offset = (page - 1) * limit;
-        return this.News.findAndCountAll({
-            where: { status },
+    async getUniqueCategories() {
+        const categories = await this.News.findAll({
+            attributes: [
+                [fn('DISTINCT', col('category')), 'category']
+            ],
+            raw: true
+        });
+        return categories.map(item => item.category).filter(Boolean);
+    }
+
+    async getRecommendationNews(category) {
+        return this.News.findAll({
+            where: {
+                category
+            },
+            limit: 5,
+            order: [['createdAt', 'DESC']]
+        })
+    }
+
+    //for all
+    async getAllPosts({ offset = 0, limit = 10, title = '', category = '', status = '' }) {
+        const validStatuses = ['PUBLISHED', 'ARCHIVED', 'DRAFT'];
+        const where = {};
+
+        if (status && validStatuses.includes(status)) {
+            where.status = status;
+        }
+        if (title) {
+            where.title = { [Op.like]: `%${title}%` };
+        }
+        if (category) {
+            where.category = category;
+        }
+
+        return await this.News.findAndCountAll({
+            where: where,
             limit: limit,
             offset: offset,
-            order: [['publishedAt', 'DESC']],
+            order: [['createdAt', 'DESC']]
         });
     }
 
+    //forUser
     async getPostBySlug(slug) {
         return this.News.findOne({
             where: { slug, status: 'PUBLISHED' },
             include: [{
                 model: this.ContentNews,
-                as: 'blocks',
+                as: 'contentBlocks',
                 order: [['order', 'ASC']]
             }]
         });
     }
 
-    // --- Operasi CREATE & UPDATE ---
-    async createPost(newsData, contentBlocks) {
+    //forAdmin
+
+    async getPostBySlugForAdmin(slug) {
+        return this.News.findOne({
+            where: { slug },
+            include: [{
+                model: this.ContentNews,
+                as: 'contentBlocks',
+                order: [['order', 'ASC']]
+            }]
+        });
+    }
+
+    async createPost(newsData, contentBlocks, files) {
         return this.News.sequelize.transaction(async (t) => {
+            const rawPath = files['thumbnailImage']?.[0]?.path;
+            newsData.imagePath = rawPath 
+                ? rawPath.replace(/\\/g, '/').replace(/^public/, '') 
+                : null;
             const newsItem = await this.News.create(newsData, { transaction: t });
 
-            const blocks = contentBlocks.map((block, index) => ({
-                ...block,
-                newsId: newsItem.id,
-                order: index + 1
-            }));
+            let blocks = [];
+            let count = 0;
+            contentBlocks.forEach((element, index) => {
+                console.log(element);
+                if (element.blockType == "IMAGE") {
+                    const rawPathE = files['contentImages']?.[count]?.path;
+                    element.contentValue = rawPathE.replace(/\\/g, '/').replace(/^public/, '');
+                    count++;
+                }
+                element.newsId = newsItem.id;
+                element.order = index + 1;
+                blocks.push(element);
+            });
+
 
             await this.ContentNews.bulkCreate(blocks, { transaction: t });
             return newsItem;
         });
     }
 
-    async updatePost(id, newsData, contentBlocks) {
-        const existingNews = await this.News.findByPk(id);
-        if (!existingNews) {
-            return null;
-        }
-
+    async updatePost(id, newsData, contentBlocks, files) {
         return this.News.sequelize.transaction(async (t) => {
-            await existingNews.update(newsData, { transaction: t });
+            const oldNews = await this.News.findByPk(id, {
+                include: [{ model: this.ContentNews, as: 'contentBlocks' }],
+                transaction: t
+            });
+
+            if (!oldNews) throw new Error("Berita tidak ditemukan");
+
+            let filesToDelete = [];
 
-            await this.ContentNews.destroy({ 
+            if (files['thumbnailImage']?.[0]) {
+                if (oldNews.imagePath) filesToDelete.push(oldNews.imagePath);
+                const rawPath = files['thumbnailImage'][0].path;
+                // newsData.imagePath = rawPath.replace(/\\/g, '/');
+                newsData.imagePath = rawPath.replace(/\\/g, '/').replace(/^public/, '');
+            } else {
+                newsData.imagePath = oldNews.imagePath;
+            }
+
+            await oldNews.update(newsData, { transaction: t });
+
+            const oldBlocks = oldNews.contentBlocks || [];
+
+            await this.ContentNews.destroy({
                 where: { newsId: id },
-                transaction: t 
+                transaction: t
             });
 
-            const blocks = contentBlocks.map((block, index) => ({
-                ...block,
-                newsId: id,
-                order: index + 1
-            }));
+            let blocks = [];
+            let imageCount = 0;
 
-            await this.ContentNews.bulkCreate(blocks, { transaction: t });
-            
-            return this.News.findByPk(id, {
-                include: [{ model: this.ContentNews, as: 'blocks', order: [['order', 'ASC']] }],
-                transaction: t
+            contentBlocks.forEach((element, index) => {
+                if (element.blockType === "IMAGE") {
+                    const newFile = files['contentImages']?.[imageCount];
+
+                    if (newFile) {
+                        const rawPathE = newFile.path;
+                        // element.contentValue = rawPathE.replace(/\\/g, '/');
+                        element.contentValue = rawPathE.replace(/\\/g, '/').replace(/^public/, '');
+                        imageCount++;
+                    } else {
+                        element.contentValue = element.contentValue;
+                    }
+                }
+
+                element.newsId = id;
+                element.order = index + 1;
+                blocks.push(element);
             });
+
+            await this.ContentNews.bulkCreate(blocks, { transaction: t });
+
+            return { newsItem: oldNews, filesToDelete };
         });
     }
 
+    async updateStatusNews(id, status) {
+        const news = await this.News.findByPk(id);
+        if (!news) throw new Error("Berita tidak ditemukan");
+
+        await news.update({
+            status: status
+        });
+
+        return news;
+    }
+
+    //belum selesai
     async deletePost(id) {
         return this.News.destroy({ where: { id } });
     }
+
+    async dashboardAdmin(currentYear) {
+        const newsCount = await this.News.count();
+
+        const monthlyVisitors = await this.VisitorLog.findAll({
+            attributes: [
+                [fn('MONTH', col('visitedAt')), 'month'],
+                [fn('COUNT', col('id')), 'total']
+            ],
+            where: where(fn('YEAR', col('visitedAt')), currentYear),
+            group: [fn('MONTH', col('visitedAt'))],
+            raw: true
+        });
+
+        const totalYearlyVisitors = await this.VisitorLog.count({
+            where: where(fn('YEAR', col('visitedAt')), currentYear)
+        });
+
+        const categoryCount = await this.News.count({
+            distinct: true,
+            col: 'category'
+        });
+
+        return { newsCount, categoryCount, monthlyVisitors, totalYearlyVisitors };
+    }
 }
 
 module.exports = NewsService;

package/services/StatService.js

@@ -7,15 +7,24 @@ class StatService {
     }
 
     async trackVisit(newsId, sessionId) {
-        try {
-            await this.VisitorLog.create({
+        const TWENTY_FOUR_HOURS_AGO = new Date(new Date() - 24 * 60 * 60 * 1000);
+
+        const existingVisit = await this.VisitorLog.findOne({
+            where: {
                 newsId: newsId,
                 sessionId: sessionId,
+                visitedAt: {
+                    [Op.gt]: TWENTY_FOUR_HOURS_AGO
+                }
+            }
+        });
+
+        if (!existingVisit) {
+            return await this.VisitorLog.create({
+                newsId,
+                sessionId,
                 visitedAt: new Date()
             });
-            return true;
-        } catch (error) {
-            return false;
         }
     }
 

package/services/index.js

@@ -8,8 +8,8 @@ const StatService = require('./StatService');
  */
 module.exports = (db) => {
     return {
-        news: new NewsService(db.News, db.ContentNews), // NewsService butuh News dan ContentNews
-        stat: new StatService(db.VisitorLog, db.News), // StatService butuh VisitorLog dan News
-        db: db // Mungkin perlu mengakses Sequelize instance (opsional)
+        news: new NewsService(db.News, db.ContentNews, db.VisitorLog),
+        stat: new StatService(db.VisitorLog, db.News),
+        db: db 
     };
 };

package/validations/mainValidation.js

@@ -0,0 +1,25 @@
+const { body, validationResult } = require('express-validator');
+
+const validate = (req, res, next) => {
+    console.log("di validate");
+    const errors = validationResult(req);
+    if (errors.isEmpty()) {
+        console.log("validate berhasil");
+        return next();
+    }
+
+    console.log("=== DETAIL ERROR VALIDASI ===");
+    console.log(JSON.stringify(errors.array(), null, 2));
+
+    return res.status(400).json({
+        status: 'error',
+        errors: errors.array().map(err => ({
+        field: err.path,
+        message: err.msg
+        }))
+    });
+};
+
+module.exports = {
+    validate
+};

package/validations/newsValidations.js

@@ -0,0 +1,84 @@
+const { body, validationResult } = require('express-validator');
+
+const CreateNewsValidationRules = [
+    body('title')
+    .notEmpty().withMessage('title wajib diisi')
+    .isLength({ min: 3 }).withMessage('title minimal 3 karakter')
+    .trim(),
+    body('authorName')
+    .notEmpty().withMessage('authorName wajib diisi')
+    .isLength({ min: 3 }).withMessage('authorName minimal 3 karakter')
+    .trim(),
+    body('category')
+    .notEmpty().withMessage('category wajib diisi')
+    .isLength({ min: 3 }).withMessage('category minimal 3 karakter')
+    .trim(),
+    body('status')
+    .notEmpty().withMessage('status wajib dipilih antara DRAFT, PUBLISHED')
+    .isLength({ min: 3 }).withMessage('status minimal 3 karakter')
+    .isIn(['DRAFT', 'PUBLISHED']).withMessage('status tidak sesuai')
+    .trim(),
+    
+    body('contentBlocks')
+        .isArray({ min: 1 }).withMessage('contentBlocks harus berupa array dan minimal berisi 1 block'),
+    body('contentBlocks.*.blockType')
+        .notEmpty().withMessage('blockType wajib diisi')
+        .isIn(['PARAGRAPH', 'IMAGE', 'VIDEO', 'SUBHEADING']).withMessage('Tipe block tidak valid'),
+    body('contentBlocks.*.contentValue')
+        .custom((value, { req, path }) => {
+            const index = path.match(/\d+/)[0];
+            const blockType = req.body.contentBlocks[index].blockType;
+
+            if (blockType !== 'IMAGE') {
+                if (!value || value.trim() === '') {
+                    throw new Error(`contentValue untuk ${blockType} wajib diisi`);
+                }
+            }
+
+            if (( blockType === 'VIDEO') && !value.startsWith('http')) {
+                throw new Error(`contentValue untuk ${blockType} harus berupa URL yang valid`);
+            }
+            return true;
+        }),
+    body('contentBlocks.*.caption')
+        .optional({ nullable: true })
+        .isString().withMessage('caption harus berupa string')
+        .isLength({ max: 255 }).withMessage('caption maksimal 255 karakter')
+]
+
+const UpdateNewsValidationRules = [
+    body('title').optional().isLength({ min: 3 }).trim(),
+    body('authorName').optional().isLength({ min: 3 }).trim(),
+    body('category').optional().trim(),
+    body('status').optional().isIn(['DRAFT', 'PUBLISHED']),
+    
+    // body('contentBlocks')
+    //     .isArray().withMessage('contentBlocks harus berupa array'),
+    body('contentBlocks')
+        .isArray({ min: 1 }).withMessage('contentBlocks harus berupa array dan minimal berisi 1 block'),
+
+    body('contentBlocks.*.blockType')
+        .notEmpty().withMessage('blockType wajib diisi'),
+
+    body('contentBlocks.*.contentValue')
+        .custom((value, { req, path }) => {
+            const index = path.match(/\d+/)[0];
+            const block = req.body.contentBlocks[index];
+            
+            // Jika IMAGE, cek apakah ada file baru ATAU path lama
+            if (block.blockType === 'IMAGE') {
+                const hasNewFile = req.files && req.files['contentImages'] && req.files['contentImages'].length > 0;
+                if (!hasNewFile && (!value || value.trim() === '')) {
+                    throw new Error(`Blok gambar index ${index} wajib memiliki file baru atau path lama`);
+                }
+            } else {
+                if (!value || value.trim() === '') throw new Error('Konten wajib diisi');
+            }
+            return true;
+        })
+];
+
+module.exports = {
+    CreateNewsValidationRules,
+    UpdateNewsValidationRules
+};