按 ID 将博文插入集合

Question

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

我已经按照基本指南创建了一个 restful 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 的每个对象中的 blogs 数组，以及成为我的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 - 获取特定

• https://example.com/api/sites/my_site_02/posts/blog-post-01 - 获取特定的

Answer 1

让我们把它分解成更小的问题。

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

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

在进一步阅读之前，我建议你先看看here。

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

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

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

• 创建博客后，确保您获得新创建博客的id 并将其添加到带有site_id 的站点的blogIds

在视觉上，你会有这样的东西：

// 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