artsite/routes/v2/detail.js

var express = require('express');
var router = express.Router();
const redis = require('../../libs/redis');
const models = require('../../models');
const utils = require('../../libs/utils');
const common = require('./common');
const { getListBuilder } = require('../../libs/pager');
const categories = require('../../config/category');
const { tags } = require('../../config/tag');
const { coloringList } = require('./config');

const CACHE_PREFIX = "art_v2";
// const CACHE_EXPIRES = 60; // 60s刷新一次
const CACHE_EXPIRES = 600;

const artSelect = 'name title desc seoTitle seoDescription width height date publishTime tags lastMod mystery hasSpecial useSpecialThumb publishVersion totalStartCount totalDoneCount completionRate';

// 详情页路由
router.get('/:id', function (req, res, next) {
  (async function () {
    let id = req.params.id;
    utils.validators.validateId(id);

    let cacheKey = `${CACHE_PREFIX}_detail_${id}`;
    let htmlData = await redis.getAsync(cacheKey);
    // htmlData = null;
    if (!htmlData) {
      // 详情
      let doc = await models.Art
        .findById(id)
        .select(artSelect)
        .populate('user', 'username name')
        .lean()
        .exec();
      if (!doc) throw createError(404, 'Art Not Found!');

      common.organizeDetail(doc);

      // 关联推荐
      let mytags = [...doc.tags];
      let cates = categories.map(e => e.id);
      let alltags = tags.map(e => e.tag);
      mytags = mytags.filter(e => !cates.includes(e) && alltags.includes(e));
      if (mytags.length == 0) mytags = [...doc.tags];

      let query = {
        page: req.query.page,
        length: req.query.length,
        search: req.query.search,
        orderBy: 'publishTime',
        order: 'desc',
        base: { open: true, status: 9000 },
        filters: { tags: mytags },
      }

      let result = await getListBuilder(query, models.Art);
      common.organizeData(result.data);

      // 填色页合集推荐
      const recmCollections = recommendColoringPages(doc, coloringList);

      // 评论
      const comments = await models.Comment.find({ approved: true, page: doc._id }).sort({ createdAt: -1 });

      let data = {
        title: `${doc.seoTitle}`,
        description: `${doc.seoDescription}`,
        detail: doc,
        data: result.data,
        page: result.page,
        pageId: doc._id,
        length: result.length,
        recordsFiltered: result.recordsFiltered,
        recordsTotal: result.recordsTotal,
        relates: result.data,
        uri: `/coloring-page/${doc._id}`,
        imageUrl: doc.thumb,
        pageUri: common.replaceUriParams,
        comments,
        dateFormat: common.dateFormat,
        collections: recmCollections,
      };

      // 渲染EJS模板到内存中
      res.render('v2/detail', data, async (err, html) => {
        if (err) {
          // 如果渲染出错，调用next()传递错误
          return next(err);
        }

        // 渲染成功，存redis, 发送数据到客户端
        htmlData = html;
        try {
          await redis.set(cacheKey, htmlData, 'EX', CACHE_EXPIRES);
        } catch (e) {
          console.error(e);
        }

        res.send(htmlData);
      });

    } else {
      // 缓存命中， 直接发送缓存数据
      res.set({ 'X-From-Cache': 'true' });
      res.send(htmlData);
    }

  })().catch(next);

});



/**
 * 填色页推荐系统 - 根据标签相似度推荐相关填色页合集
 * @param {Object} currentPage - 当前填色页对象，包含tags属性
 * @param {Array} collections - 所有填色页合集列表
 * @returns {Array} - 推荐的3个填色页合集
 */
function recommendColoringPages(currentPage, collections) {
  // 计算每个候选页与当前页的标签匹配度
  const scoredPages = collections.map(page => {
    const matchedTags = page.tags.filter(tag =>
      currentPage.tags.some(currentTag =>
        currentTag.toLowerCase() === tag.toLowerCase()
      )
    );
    return {
      ...page,
      score: matchedTags.length,
      matchedTags
    };
  });

  // 按匹配度降序排序
  scoredPages.sort((a, b) => b.score - a.score);

  // 收集匹配度大于0的推荐
  const tagMatchedRecommendations = scoredPages.filter(page => page.score > 0);

  // 如果标签匹配的推荐不足3个，从剩余的合集中随机选取补足
  if (tagMatchedRecommendations.length < 3) {
    const remainingPages = scoredPages.filter(page => page.score === 0);
    // 打乱剩余页面顺序
    const shuffledRemaining = remainingPages.sort(() => 0.5 - Math.random());
    // 补足到3个推荐
    return [...tagMatchedRecommendations, ...shuffledRemaining].slice(0, 3);
  }

  // 如果标签匹配的推荐超过3个，取前3个
  return tagMatchedRecommendations.slice(0, 3);
}

module.exports = router;