Question

我正在为博客管理仪表板构建Express REST API。前端将是Vue JS，用户可以在其中登录，创建网站并将博客文章添加到他们添加的特定网站。所有这些都将存储在Mongo DB Atlas中。

我遵循了有关创建一个宁静的api的基本指南，其中包括CRUD操作并将其链接到Mongo DB。

它向我展示了如何创建模型，使用中间件导入路线以及如何执行GET和POST请求以与数据库交互。

它提供了一种添加博客帖子的方法，每个博客帖子都作为对象添加到Mongo DB中的数组。现在，我需要对此进行扩展，以从本质上对一组对象（博客文章）进行分组并将它们放入特定的对象中，并且仍然为每个对象保留CRUD操作。

当前，我有app.js，它实际上加载在网站和帖子中，如下所示：

const express = require('express');
const app = express();
const mongoose = require('mongoose');
const slug = require('mongoose-slug-generator');
const bodyParser = require('body-parser');
const cors = require('cors');
require('dotenv/config');

mongoose.plugin(slug);

// middleware
app.use(cors());
app.use(bodyParser.json());

// routes
const postRoute = require('./routes/posts');
const siteRoute = require('./routes/sites');

app.use('/posts', postRoute);
app.use('/sites', siteRoute);

每条路线中，加载CRUD操作以添加单个博客文章和单个站点。

这非常简单，但是，我正在努力了解如何以及需要添加什么内容才能将特定博客帖子添加到数据库中的特定收集对象。

我的JS文件（包含添加博客文章的路线）是：

const express = require('express');
const router = express.Router();
const Post = require('../models/Post');

// get all posts
router.get('/', async (req, res) => {
  try {
    const posts = await Post.find();
    res.json(posts);
  } catch(err) {
    res.json({message: err})
  }
});


// create blog post
router.post('/add', async (req, res) => {
  const post = new Post({
    title: req.body.title,
    slug: req.body.slug,
    author: req.body.author,
    creation: req.body.creation,
    body: req.body.body,
    css: req.body.css,
    enabled: req.body.enabled
  })

  try {
    const savedPost = await post.save()
    res.json(savedPost);
  } catch(err) {
    res.json({message: err})
  }
});


// get specific post
router.get('/:post', async (req, res) => {
  try {
    const post = await Post.findById(req.params.postId)
    res.json(post)
  } catch(err) {
    res.json({message: err})
  }
});


// delete specific post
router.delete('/:post', async (req, res) => {
  try {
    const removePost = await Post.deleteOne({ _id: req.params.postId })
    res.json(removePost)
  } catch(err) {
    res.json({message: err})
  }
});


// delete specific post
router.patch('/:post', async (req, res) => {
  try {
    const updatedPost = await Post.updateOne({ _id: req.params.postId }, { $set: {
      title: req.params.title
    }})
    res.json(updatedPost)
  } catch(err) {
    res.json({message: err})
  }
});

module.exports = router;

这很好用，但是，我需要能够 POST 将特定博客帖子发布到由我的网站模型创建的特定对象。

最后，我想得到这样的结果：

[
  {
    "ID": "some unique ID",
    "name": "Example Blog Site 01",
    "enabled": true,
    "blogs": [
      {
        "title": "My blog title",
        "slug": "slug",
        "description": "some blog content"
      },
      {
        "title": "My blog title",
        "slug": "slug",
        "description": "some blog content"
      }
    ]
  },
  {
    "ID": "some unique ID",
    "name": "Example Blog Site 02",
    "enabled": true,
    "blogs": [
      {
        "title": "My blog title",
        "slug": "slug",
        "description": "some blog content"
      },
      {
        "title": "My blog title",
        "slug": "slug",
        "description": "some blog content"
      }
    ]
  }
]

我想要成为我的sites.js对象的每个对象中的博客数组，而我想要成为sites.js路由的父对象中的对象。

本质上使用户能够为端点快速创建一组博客文章，例如：

https://example.com/api/sites/my_site/posts-全部获取
https://example.com/api/sites/my_site_02/posts-全部获取
https://example.com/api/sites/my_site/posts/blog-post-01-特定于GET
https://example.com/api/sites/my_site_02/posts/blog-post-01-特定于

Answer 1

让我们将其分解为较小的问题。

我们有博客和网站，其中包含多个博客。

所以，我的假设是：
一个站点可以具有多个博客，但是一个博客可以属于一个站点。这意味着将存在一对多关系。

在继续阅读之前，建议您先看看here。

一种解决此问题的方法如下：

每个site都应该有一个名为blogIds的字段，您只在其中存储属于它的博客的ID。

{
 name: '...',
 blogIds: [blogId1, blogId2...]
}

创建博客后，请确保您获得了新创建的博客的id并使用blogIds插入并添加到网站的site_id

从视觉上看，您将具有以下内容：

// Sites
 [
  { id, name, blogIds: [1, 2], ... },
  { id, name, blogIds: [3], ... },
]

// Blogs
[
 { id: 1, name: 'blog 1', ... },
 { id: 2, name: 'blog 2', ... },
 { id: 3, name: 'blog 3', ... },
]

对于获取每个站点的博客，这些资源可能很有用：

Select items from array of ids

Performing an inner join

将博客帖子按ID插入收藏集

1 个答案: