mirror of
https://github.com/TryGhost/Ghost.git
synced 2024-12-21 01:41:46 +03:00
326 lines
10 KiB
JavaScript
326 lines
10 KiB
JavaScript
// # Posts API
|
|
// RESTful API for the Post resource
|
|
const Promise = require('bluebird'),
|
|
{omit, defaults} = require('lodash'),
|
|
pipeline = require('../../lib/promise/pipeline'),
|
|
localUtils = require('./utils'),
|
|
models = require('../../models'),
|
|
common = require('../../lib/common'),
|
|
{urlsForPost} = require('./decorators/urls'),
|
|
docName = 'posts',
|
|
/**
|
|
* @deprecated: `author`, will be removed in Ghost 3.0
|
|
*/
|
|
allowedIncludes = [
|
|
'created_by', 'updated_by', 'published_by', 'author', 'tags', 'fields', 'authors', 'authors.roles'
|
|
],
|
|
unsafeAttrs = ['author_id', 'status', 'authors'];
|
|
|
|
const mongo = require('../v2/utils/serializers/input/utils/mongo.js');
|
|
|
|
/*
|
|
* Replaces references of "page" in filters
|
|
* with the correct column "type"
|
|
*/
|
|
function replacePageWithType(mongoJSON) {
|
|
return mongo.mapKeysAndValues(mongoJSON, {
|
|
key: {
|
|
from: 'page',
|
|
to: 'type'
|
|
},
|
|
values: [{
|
|
from: false,
|
|
to: 'post'
|
|
}, {
|
|
from: true,
|
|
to: 'page'
|
|
}]
|
|
});
|
|
}
|
|
|
|
function convertTypeToPage(model) {
|
|
// Respect include param
|
|
if (!Object.hasOwnProperty.call(model, 'type')) {
|
|
return model;
|
|
}
|
|
model.page = model.type === 'page';
|
|
delete model.type;
|
|
return model;
|
|
}
|
|
|
|
function convertPageToType(model) {
|
|
if (!Object.hasOwnProperty.call(model, 'page')) {
|
|
return model;
|
|
}
|
|
|
|
if (model.page === true) {
|
|
model.type = 'page';
|
|
} else if (model.page === false) {
|
|
model.type = 'post';
|
|
} else {
|
|
// This is to ensure that invalid page props generate a ValidationError
|
|
model.type = 'UNKNOWN_PAGE_OPTION';
|
|
}
|
|
delete model.page;
|
|
return model;
|
|
}
|
|
|
|
let posts;
|
|
|
|
/**
|
|
* ### Posts API Methods
|
|
*
|
|
* **See:** [API Methods](constants.js.html#api%20methods)
|
|
*/
|
|
|
|
posts = {
|
|
/**
|
|
* ## Browse
|
|
* Find a paginated set of posts
|
|
*
|
|
* Will only return published posts unless we have an authenticated user and an alternative status
|
|
* parameter.
|
|
*
|
|
* Will return without static pages unless told otherwise
|
|
*
|
|
*
|
|
* @public
|
|
* @param {{context, page, limit, status, staticPages, tag, featured}} options (optional)
|
|
* @returns {Promise<Posts>} Posts Collection with Meta
|
|
*/
|
|
browse(options) {
|
|
const extraOptions = ['status', 'formats', 'absolute_urls'];
|
|
let permittedOptions,
|
|
tasks;
|
|
|
|
// Workaround to remove static pages from results
|
|
// TODO: rework after https://github.com/TryGhost/Ghost/issues/5151
|
|
if (options && options.context && (options.context.user || options.context.internal)) {
|
|
extraOptions.push('staticPages');
|
|
}
|
|
permittedOptions = localUtils.browseDefaultOptions.concat(extraOptions);
|
|
|
|
/**
|
|
* ### Model Query
|
|
* Make the call to the Model layer
|
|
* @param {Object} options
|
|
* @returns {Object} options
|
|
*/
|
|
function modelQuery(options) {
|
|
options.mongoTransformer = replacePageWithType;
|
|
|
|
return models.Post.findPage(options)
|
|
.then(({data, meta}) => {
|
|
return {
|
|
posts: data.map(model => urlsForPost(model.id, model.toJSON(options), options)).map(convertTypeToPage),
|
|
meta: meta
|
|
};
|
|
});
|
|
}
|
|
|
|
// Push all of our tasks into a `tasks` array in the correct order
|
|
tasks = [
|
|
localUtils.validate(docName, {opts: permittedOptions}),
|
|
localUtils.convertOptions(allowedIncludes, models.Post.allowedFormats),
|
|
localUtils.handlePublicPermissions(docName, 'browse', unsafeAttrs),
|
|
modelQuery
|
|
];
|
|
|
|
// Pipeline calls each task passing the result of one to be the arguments for the next
|
|
return pipeline(tasks, options);
|
|
},
|
|
|
|
/**
|
|
* ## Read
|
|
* Find a post, by ID, UUID, or Slug
|
|
*
|
|
* @public
|
|
* @param {Object} options
|
|
* @return {Promise<Post>} Post
|
|
*/
|
|
read(options) {
|
|
const attrs = ['id', 'slug', 'status', 'uuid'],
|
|
// NOTE: the scheduler API uses the post API and forwards custom options
|
|
extraAllowedOptions = options.opts || ['formats', 'absolute_urls'];
|
|
|
|
let tasks;
|
|
|
|
/**
|
|
* ### Model Query
|
|
* Make the call to the Model layer
|
|
* @param {Object} options
|
|
* @returns {Object} options
|
|
*/
|
|
function modelQuery(options) {
|
|
options.mongoTransformer = replacePageWithType;
|
|
|
|
return models.Post.findOne(options.data, omit(options, ['data']))
|
|
.then((model) => {
|
|
if (!model) {
|
|
return Promise.reject(new common.errors.NotFoundError({
|
|
message: common.i18n.t('errors.api.posts.postNotFound')
|
|
}));
|
|
}
|
|
|
|
return {
|
|
posts: [urlsForPost(model.id, model.toJSON(options), options)].map(convertTypeToPage)
|
|
};
|
|
});
|
|
}
|
|
|
|
// Push all of our tasks into a `tasks` array in the correct order
|
|
tasks = [
|
|
localUtils.validate(docName, {attrs: attrs, opts: extraAllowedOptions}),
|
|
localUtils.convertOptions(allowedIncludes, models.Post.allowedFormats),
|
|
localUtils.handlePublicPermissions(docName, 'read', unsafeAttrs),
|
|
modelQuery
|
|
];
|
|
|
|
// Pipeline calls each task passing the result of one to be the arguments for the next
|
|
return pipeline(tasks, options);
|
|
},
|
|
|
|
/**
|
|
* ## Edit
|
|
* Update properties of a post
|
|
*
|
|
* @public
|
|
* @param {Post} object Post or specific properties to update
|
|
* @param {{id (required), context, include,...}} options
|
|
* @return {Promise(Post)} Edited Post
|
|
*/
|
|
edit(object, options) {
|
|
let tasks;
|
|
// NOTE: the scheduler API uses the post API and forwards custom options
|
|
const extraAllowedOptions = options.opts || [];
|
|
|
|
/**
|
|
* ### Model Query
|
|
* Make the call to the Model layer
|
|
* @param {Object} options
|
|
* @returns {Object} options
|
|
*/
|
|
function modelQuery(options) {
|
|
return models.Post.edit(options.data.posts.map(convertPageToType)[0], omit(options, ['data']))
|
|
.then((model) => {
|
|
if (!model) {
|
|
return Promise.reject(new common.errors.NotFoundError({
|
|
message: common.i18n.t('errors.api.posts.postNotFound')
|
|
}));
|
|
}
|
|
|
|
const post = urlsForPost(model.id, model.toJSON(options), options);
|
|
|
|
// If previously was not published and now is (or vice versa), signal the change
|
|
// @TODO: `statusChanged` get's added for the API headers only. Reconsider this.
|
|
post.statusChanged = false;
|
|
if (model.previous('status') !== model.get('status')) {
|
|
post.statusChanged = true;
|
|
}
|
|
|
|
return {
|
|
posts: [post].map(convertTypeToPage)
|
|
};
|
|
});
|
|
}
|
|
|
|
// Push all of our tasks into a `tasks` array in the correct order
|
|
tasks = [
|
|
localUtils.validate(docName, {opts: localUtils.idDefaultOptions.concat(extraAllowedOptions)}),
|
|
localUtils.convertOptions(allowedIncludes),
|
|
localUtils.handlePermissions(docName, 'edit', unsafeAttrs),
|
|
modelQuery
|
|
];
|
|
|
|
// Pipeline calls each task passing the result of one to be the arguments for the next
|
|
return pipeline(tasks, object, options);
|
|
},
|
|
|
|
/**
|
|
* ## Add
|
|
* Create a new post along with any tags
|
|
*
|
|
* @public
|
|
* @param {Post} object
|
|
* @param {{context, include,...}} options
|
|
* @return {Promise(Post)} Created Post
|
|
*/
|
|
add(object, options) {
|
|
let tasks;
|
|
|
|
/**
|
|
* ### Model Query
|
|
* Make the call to the Model layer
|
|
* @param {Object} options
|
|
* @returns {Object} options
|
|
*/
|
|
function modelQuery(options) {
|
|
return models.Post.add(options.data.posts.map(convertPageToType)[0], omit(options, ['data']))
|
|
.then((model) => {
|
|
const post = urlsForPost(model.id, model.toJSON(options), options);
|
|
|
|
if (post.status === 'published') {
|
|
// When creating a new post that is published right now, signal the change
|
|
post.statusChanged = true;
|
|
}
|
|
|
|
return {
|
|
posts: [post].map(convertTypeToPage)
|
|
};
|
|
});
|
|
}
|
|
|
|
// Push all of our tasks into a `tasks` array in the correct order
|
|
tasks = [
|
|
localUtils.validate(docName),
|
|
localUtils.convertOptions(allowedIncludes),
|
|
localUtils.handlePermissions(docName, 'add', unsafeAttrs),
|
|
modelQuery
|
|
];
|
|
|
|
// Pipeline calls each task passing the result of one to be the arguments for the next
|
|
return pipeline(tasks, object, options);
|
|
},
|
|
|
|
/**
|
|
* ## Destroy
|
|
* Delete a post, cleans up tag relations, but not unused tags.
|
|
* You can only delete a post by `id`.
|
|
*
|
|
* @public
|
|
* @param {{id (required), context,...}} options
|
|
* @return {Promise}
|
|
*/
|
|
destroy(options) {
|
|
let tasks;
|
|
|
|
/**
|
|
* @function deletePost
|
|
* @param {Object} options
|
|
*/
|
|
function deletePost(options) {
|
|
const opts = defaults({require: true}, options);
|
|
|
|
return models.Post.destroy(opts).return(null)
|
|
.catch(models.Post.NotFoundError, () => {
|
|
throw new common.errors.NotFoundError({
|
|
message: common.i18n.t('errors.api.posts.postNotFound')
|
|
});
|
|
});
|
|
}
|
|
|
|
// Push all of our tasks into a `tasks` array in the correct order
|
|
tasks = [
|
|
localUtils.validate(docName, {opts: localUtils.idDefaultOptions}),
|
|
localUtils.convertOptions(allowedIncludes),
|
|
localUtils.handlePermissions(docName, 'destroy', unsafeAttrs),
|
|
deletePost
|
|
];
|
|
|
|
// Pipeline calls each task passing the result of one to be the arguments for the next
|
|
return pipeline(tasks, options);
|
|
}
|
|
};
|
|
|
|
module.exports = posts;
|