2013-06-25 15:43:15 +04:00
|
|
|
var Post,
|
|
|
|
Posts,
|
|
|
|
_ = require('underscore'),
|
|
|
|
uuid = require('node-uuid'),
|
|
|
|
when = require('when'),
|
|
|
|
errors = require('../errorHandling'),
|
|
|
|
Showdown = require('showdown'),
|
2013-08-20 01:52:50 +04:00
|
|
|
github = require('../../shared/vendor/showdown/extensions/github'),
|
|
|
|
converter = new Showdown.converter({extensions: [github]}),
|
2013-06-25 15:43:15 +04:00
|
|
|
User = require('./user').User,
|
2013-08-16 18:11:36 +04:00
|
|
|
config = require('../../../config'),
|
2013-08-21 16:55:58 +04:00
|
|
|
Tag = require('./tag').Tag,
|
2013-09-14 00:38:53 +04:00
|
|
|
Tags = require('./tag').Tags,
|
2013-09-23 02:20:08 +04:00
|
|
|
ghostBookshelf = require('./base');
|
2013-06-25 15:43:15 +04:00
|
|
|
|
2013-09-23 02:20:08 +04:00
|
|
|
Post = ghostBookshelf.Model.extend({
|
2013-06-25 15:43:15 +04:00
|
|
|
|
|
|
|
tableName: 'posts',
|
|
|
|
|
2013-08-25 14:49:31 +04:00
|
|
|
permittedAttributes: [
|
2013-09-14 23:01:46 +04:00
|
|
|
'id', 'uuid', 'title', 'slug', 'markdown', 'html', 'meta_title', 'meta_description',
|
2013-08-25 14:49:31 +04:00
|
|
|
'featured', 'image', 'status', 'language', 'author_id', 'created_at', 'created_by', 'updated_at', 'updated_by',
|
|
|
|
'published_at', 'published_by'
|
|
|
|
],
|
|
|
|
|
2013-06-25 15:43:15 +04:00
|
|
|
defaults: function () {
|
|
|
|
return {
|
|
|
|
uuid: uuid.v4(),
|
2013-09-14 23:01:46 +04:00
|
|
|
status: 'draft'
|
2013-06-25 15:43:15 +04:00
|
|
|
};
|
|
|
|
},
|
|
|
|
|
|
|
|
initialize: function () {
|
|
|
|
this.on('creating', this.creating, this);
|
2013-08-21 16:55:58 +04:00
|
|
|
this.on('saving', this.updateTags, this);
|
2013-06-25 15:43:15 +04:00
|
|
|
this.on('saving', this.saving, this);
|
2013-08-25 14:49:31 +04:00
|
|
|
this.on('saving', this.validate, this);
|
2013-06-25 15:43:15 +04:00
|
|
|
},
|
|
|
|
|
2013-08-20 22:52:44 +04:00
|
|
|
validate: function () {
|
2013-09-23 02:20:08 +04:00
|
|
|
ghostBookshelf.validator.check(this.get('title'), "Post title cannot be blank").notEmpty();
|
2013-08-20 22:52:44 +04:00
|
|
|
|
|
|
|
return true;
|
|
|
|
},
|
|
|
|
|
2013-06-25 15:43:15 +04:00
|
|
|
saving: function () {
|
2013-09-13 21:29:08 +04:00
|
|
|
var self = this;
|
2013-08-25 14:49:31 +04:00
|
|
|
|
|
|
|
// Remove any properties which don't belong on the post model
|
|
|
|
this.attributes = this.pick(this.permittedAttributes);
|
|
|
|
|
2013-09-14 23:01:46 +04:00
|
|
|
this.set('html', converter.makeHtml(this.get('markdown')));
|
2013-06-01 18:47:41 +04:00
|
|
|
|
2013-10-09 22:11:29 +04:00
|
|
|
this.set('title', this.sanitize('title').trim());
|
2013-08-30 08:18:55 +04:00
|
|
|
|
2013-06-25 15:43:15 +04:00
|
|
|
if (this.hasChanged('status') && this.get('status') === 'published') {
|
2013-09-17 14:39:27 +04:00
|
|
|
if (!this.get('published_at')) {
|
|
|
|
this.set('published_at', new Date());
|
|
|
|
}
|
2013-06-25 15:43:15 +04:00
|
|
|
// This will need to go elsewhere in the API layer.
|
|
|
|
this.set('published_by', 1);
|
|
|
|
}
|
2013-06-15 20:11:15 +04:00
|
|
|
|
2013-09-23 02:20:08 +04:00
|
|
|
ghostBookshelf.Model.prototype.saving.call(this);
|
2013-08-21 16:55:58 +04:00
|
|
|
|
2013-09-14 23:01:46 +04:00
|
|
|
if (this.hasChanged('slug')) {
|
|
|
|
// Pass the new slug through the generator to strip illegal characters, detect duplicates
|
2013-10-18 21:18:49 +04:00
|
|
|
return this.generateSlug(Post, this.get('slug'), { status: 'all' })
|
2013-09-14 23:01:46 +04:00
|
|
|
.then(function (slug) {
|
|
|
|
self.set({slug: slug});
|
|
|
|
});
|
|
|
|
}
|
2013-06-25 15:43:15 +04:00
|
|
|
},
|
2013-06-01 18:47:41 +04:00
|
|
|
|
2013-06-25 15:43:15 +04:00
|
|
|
creating: function () {
|
2013-08-20 22:52:44 +04:00
|
|
|
// set any dynamic default properties
|
2013-06-26 05:42:51 +04:00
|
|
|
var self = this;
|
2013-06-18 02:59:08 +04:00
|
|
|
|
2013-06-25 15:43:15 +04:00
|
|
|
if (!this.get('author_id')) {
|
|
|
|
this.set('author_id', 1);
|
|
|
|
}
|
2013-06-26 05:42:51 +04:00
|
|
|
|
2013-09-23 02:20:08 +04:00
|
|
|
ghostBookshelf.Model.prototype.creating.call(this);
|
2013-09-14 23:01:46 +04:00
|
|
|
|
2013-06-26 05:42:51 +04:00
|
|
|
if (!this.get('slug')) {
|
|
|
|
// Generating a slug requires a db call to look for conflicting slugs
|
2013-10-18 21:18:49 +04:00
|
|
|
return this.generateSlug(Post, this.get('title'), { status: 'all' })
|
2013-06-26 05:42:51 +04:00
|
|
|
.then(function (slug) {
|
|
|
|
self.set({slug: slug});
|
|
|
|
});
|
|
|
|
}
|
2013-06-25 15:43:15 +04:00
|
|
|
},
|
2013-06-01 18:47:41 +04:00
|
|
|
|
2013-09-13 17:29:59 +04:00
|
|
|
updateTags: function (newTags) {
|
2013-09-14 00:38:53 +04:00
|
|
|
var self = this;
|
|
|
|
|
2013-08-21 16:55:58 +04:00
|
|
|
|
2013-09-13 17:29:59 +04:00
|
|
|
if (newTags === this) {
|
|
|
|
newTags = this.get('tags');
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!newTags || !this.id) {
|
2013-08-21 16:55:58 +04:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2013-09-14 00:38:53 +04:00
|
|
|
return Post.forge({id: this.id}).fetch({withRelated: ['tags']}).then(function (thisPostWithTags) {
|
|
|
|
var existingTags = thisPostWithTags.related('tags').toJSON(),
|
|
|
|
tagOperations = [],
|
|
|
|
tagsToDetach = [],
|
|
|
|
tagsToAttach = [];
|
|
|
|
|
|
|
|
// First find any tags which have been removed
|
|
|
|
_.each(existingTags, function (existingTag) {
|
|
|
|
if (!_.some(newTags, function (newTag) { return newTag.name === existingTag.name; })) {
|
|
|
|
tagsToDetach.push(existingTag.id);
|
|
|
|
}
|
2013-08-21 16:55:58 +04:00
|
|
|
});
|
2013-09-14 00:38:53 +04:00
|
|
|
|
2013-08-21 16:55:58 +04:00
|
|
|
if (tagsToDetach.length > 0) {
|
|
|
|
tagOperations.push(self.tags().detach(tagsToDetach));
|
|
|
|
}
|
|
|
|
|
2013-09-14 00:38:53 +04:00
|
|
|
// Next check if new tags are all exactly the same as what is set on the model
|
|
|
|
_.each(newTags, function (newTag) {
|
|
|
|
if (!_.some(existingTags, function (existingTag) { return newTag.name === existingTag.name; })) {
|
|
|
|
// newTag isn't on this post yet
|
|
|
|
tagsToAttach.push(newTag);
|
|
|
|
}
|
2013-08-21 16:55:58 +04:00
|
|
|
});
|
|
|
|
|
2013-09-27 14:55:02 +04:00
|
|
|
if (!_.isEmpty(tagsToAttach)) {
|
2013-09-14 00:38:53 +04:00
|
|
|
return Tags.forge().query('whereIn', 'name', _.pluck(tagsToAttach, 'name')).fetch().then(function (matchingTags) {
|
|
|
|
_.each(matchingTags.toJSON(), function (matchingTag) {
|
|
|
|
tagOperations.push(self.tags().attach(matchingTag.id));
|
|
|
|
tagsToAttach = _.reject(tagsToAttach, function (tagToAttach) {
|
|
|
|
return tagToAttach.name === matchingTag.name;
|
|
|
|
});
|
|
|
|
});
|
2013-08-21 16:55:58 +04:00
|
|
|
|
2013-09-14 00:38:53 +04:00
|
|
|
_.each(tagsToAttach, function (tagToCreateAndAttach) {
|
|
|
|
var createAndAttachOperation = Tag.add({name: tagToCreateAndAttach.name}).then(function (createdTag) {
|
|
|
|
return self.tags().attach(createdTag.id, createdTag.name);
|
|
|
|
});
|
2013-08-21 16:55:58 +04:00
|
|
|
|
|
|
|
|
2013-09-14 00:38:53 +04:00
|
|
|
tagOperations.push(createAndAttachOperation);
|
|
|
|
});
|
|
|
|
|
|
|
|
return when.all(tagOperations);
|
|
|
|
});
|
|
|
|
}
|
2013-08-21 16:55:58 +04:00
|
|
|
|
|
|
|
return when.all(tagOperations);
|
|
|
|
});
|
|
|
|
},
|
|
|
|
|
|
|
|
// Relations
|
2013-06-25 15:43:15 +04:00
|
|
|
user: function () {
|
|
|
|
return this.belongsTo(User, 'created_by');
|
|
|
|
},
|
2013-06-07 00:36:17 +04:00
|
|
|
|
2013-06-25 15:43:15 +04:00
|
|
|
author: function () {
|
|
|
|
return this.belongsTo(User, 'author_id');
|
2013-08-21 16:55:58 +04:00
|
|
|
},
|
|
|
|
|
|
|
|
tags: function () {
|
|
|
|
return this.belongsToMany(Tag);
|
2013-06-25 15:43:15 +04:00
|
|
|
}
|
2013-06-01 18:47:41 +04:00
|
|
|
|
2013-06-25 15:43:15 +04:00
|
|
|
}, {
|
2013-06-01 18:47:41 +04:00
|
|
|
|
2013-08-23 13:13:32 +04:00
|
|
|
// #### findAll
|
|
|
|
// Extends base model findAll to eager-fetch author and user relationships.
|
|
|
|
findAll: function (options) {
|
|
|
|
options = options || {};
|
2013-09-24 14:46:30 +04:00
|
|
|
options.withRelated = [ 'author', 'user', 'tags' ];
|
2013-09-23 02:20:08 +04:00
|
|
|
return ghostBookshelf.Model.findAll.call(this, options);
|
2013-08-23 13:13:32 +04:00
|
|
|
},
|
|
|
|
|
|
|
|
// #### findOne
|
|
|
|
// Extends base model findOne to eager-fetch author and user relationships.
|
|
|
|
findOne: function (args, options) {
|
|
|
|
options = options || {};
|
2013-10-18 21:18:49 +04:00
|
|
|
|
|
|
|
args = _.extend({
|
|
|
|
status: 'published'
|
|
|
|
}, args || {});
|
|
|
|
|
|
|
|
if (args.status === 'all') {
|
|
|
|
delete args.status;
|
|
|
|
}
|
|
|
|
|
2013-09-24 14:46:30 +04:00
|
|
|
options.withRelated = [ 'author', 'user', 'tags' ];
|
2013-09-23 02:20:08 +04:00
|
|
|
return ghostBookshelf.Model.findOne.call(this, args, options);
|
2013-08-23 13:13:32 +04:00
|
|
|
},
|
|
|
|
|
2013-06-25 22:07:19 +04:00
|
|
|
// #### findPage
|
|
|
|
// Find results by page - returns an object containing the
|
|
|
|
// information about the request (page, limit), along with the
|
|
|
|
// info needed for pagination (pages, total).
|
|
|
|
|
|
|
|
// **response:**
|
|
|
|
|
|
|
|
// {
|
|
|
|
// posts: [
|
|
|
|
// {...}, {...}, {...}
|
|
|
|
// ],
|
|
|
|
// page: __,
|
|
|
|
// limit: __,
|
|
|
|
// pages: __,
|
|
|
|
// total: __
|
|
|
|
// }
|
|
|
|
|
|
|
|
/*
|
2013-06-25 15:43:15 +04:00
|
|
|
* @params opts
|
|
|
|
*/
|
|
|
|
findPage: function (opts) {
|
|
|
|
var postCollection;
|
|
|
|
|
|
|
|
// Allow findPage(n)
|
|
|
|
if (_.isString(opts) || _.isNumber(opts)) {
|
|
|
|
opts = {page: opts};
|
|
|
|
}
|
2013-06-01 18:47:41 +04:00
|
|
|
|
2013-06-25 15:43:15 +04:00
|
|
|
opts = _.extend({
|
|
|
|
page: 1,
|
|
|
|
limit: 15,
|
|
|
|
where: {},
|
|
|
|
status: 'published',
|
|
|
|
orderBy: ['published_at', 'DESC']
|
|
|
|
}, opts);
|
2013-06-01 23:30:42 +04:00
|
|
|
|
2013-06-25 15:43:15 +04:00
|
|
|
postCollection = Posts.forge();
|
2013-06-01 18:47:41 +04:00
|
|
|
|
2013-06-25 15:43:15 +04:00
|
|
|
// Unless `all` is passed as an option, filter on
|
|
|
|
// the status provided.
|
|
|
|
if (opts.status !== 'all') {
|
|
|
|
opts.where.status = opts.status;
|
|
|
|
}
|
2013-06-09 03:39:24 +04:00
|
|
|
|
2013-06-25 15:43:15 +04:00
|
|
|
// If there are where conditionals specified, add those
|
|
|
|
// to the query.
|
|
|
|
if (opts.where) {
|
|
|
|
postCollection.query('where', opts.where);
|
|
|
|
}
|
2013-06-09 03:39:24 +04:00
|
|
|
|
2013-09-24 14:46:30 +04:00
|
|
|
opts.withRelated = [ 'author', 'user', 'tags' ];
|
2013-08-23 13:13:32 +04:00
|
|
|
|
2013-06-25 15:43:15 +04:00
|
|
|
// Set the limit & offset for the query, fetching
|
|
|
|
// with the opts (to specify any eager relations, etc.)
|
|
|
|
// Omitting the `page`, `limit`, `where` just to be sure
|
|
|
|
// aren't used for other purposes.
|
|
|
|
return postCollection
|
|
|
|
.query('limit', opts.limit)
|
|
|
|
.query('offset', opts.limit * (opts.page - 1))
|
|
|
|
.query('orderBy', opts.orderBy[0], opts.orderBy[1])
|
|
|
|
.fetch(_.omit(opts, 'page', 'limit', 'where', 'status', 'orderBy'))
|
|
|
|
.then(function (collection) {
|
|
|
|
var qb;
|
|
|
|
|
|
|
|
// After we're done, we need to figure out what
|
|
|
|
// the limits are for the pagination values.
|
2013-09-23 02:20:08 +04:00
|
|
|
qb = ghostBookshelf.knex(_.result(collection, 'tableName'));
|
2013-06-25 15:43:15 +04:00
|
|
|
|
|
|
|
if (opts.where) {
|
|
|
|
qb.where(opts.where);
|
2013-06-09 03:39:24 +04:00
|
|
|
}
|
|
|
|
|
2013-06-25 15:43:15 +04:00
|
|
|
return qb.count(_.result(collection, 'idAttribute')).then(function (resp) {
|
2013-10-15 20:09:08 +04:00
|
|
|
var totalPosts = parseInt(resp[0].aggregate, 10),
|
2013-06-25 19:13:19 +04:00
|
|
|
data = {
|
|
|
|
posts: collection.toJSON(),
|
2013-09-16 03:34:23 +04:00
|
|
|
page: parseInt(opts.page, 10),
|
2013-06-25 19:13:19 +04:00
|
|
|
limit: opts.limit,
|
|
|
|
pages: Math.ceil(totalPosts / opts.limit),
|
|
|
|
total: totalPosts
|
|
|
|
};
|
|
|
|
|
|
|
|
if (data.pages > 1) {
|
|
|
|
if (data.page === 1) {
|
|
|
|
data.next = data.page + 1;
|
|
|
|
} else if (data.page === data.pages) {
|
|
|
|
data.prev = data.page - 1;
|
|
|
|
} else {
|
|
|
|
data.next = data.page + 1;
|
|
|
|
data.prev = data.page - 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return data;
|
2013-06-25 15:43:15 +04:00
|
|
|
}, errors.logAndThrowError);
|
|
|
|
}, errors.logAndThrowError);
|
|
|
|
},
|
|
|
|
|
|
|
|
permissable: function (postModelOrId, userId, action_type, userPermissions) {
|
|
|
|
var self = this,
|
|
|
|
hasPermission,
|
|
|
|
postModel = postModelOrId;
|
|
|
|
|
|
|
|
// If we passed in an id instead of a model, get the model
|
|
|
|
// then check the permissions
|
|
|
|
if (_.isNumber(postModelOrId) || _.isString(postModelOrId)) {
|
|
|
|
return this.read({id: postModelOrId}).then(function (foundPostModel) {
|
|
|
|
return self.permissable(foundPostModel, userId, action_type, userPermissions);
|
|
|
|
}, errors.logAndThrowError);
|
|
|
|
}
|
2013-06-09 03:39:24 +04:00
|
|
|
|
2013-08-16 03:22:08 +04:00
|
|
|
// Check if any permissions apply for this user and post.
|
2013-06-25 15:43:15 +04:00
|
|
|
hasPermission = _.any(userPermissions, function (perm) {
|
2013-08-16 03:22:08 +04:00
|
|
|
// Check for matching action type and object type
|
|
|
|
if (perm.get('action_type') !== action_type ||
|
|
|
|
perm.get('object_type') !== 'post') {
|
2013-06-25 15:43:15 +04:00
|
|
|
return false;
|
2013-06-09 03:39:24 +04:00
|
|
|
}
|
|
|
|
|
2013-08-16 03:22:08 +04:00
|
|
|
// If asking whether we can create posts,
|
|
|
|
// and we have a create posts permission then go ahead and say yes
|
|
|
|
if (action_type === 'create' && perm.get('action_type') === action_type) {
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Check for either no object id or a matching one
|
2013-06-25 15:43:15 +04:00
|
|
|
return !perm.get('object_id') || perm.get('object_id') === postModel.id;
|
|
|
|
});
|
|
|
|
|
|
|
|
// If this is the author of the post, allow it.
|
2013-08-16 03:22:08 +04:00
|
|
|
// Moved below the permissions checks because there may not be a postModel
|
|
|
|
// in the case like canThis(user).create.post()
|
|
|
|
hasPermission = hasPermission || (postModel && userId === postModel.get('author_id'));
|
2013-06-25 15:43:15 +04:00
|
|
|
|
2013-08-16 03:22:08 +04:00
|
|
|
// Resolve if we have appropriate permissions
|
2013-06-25 15:43:15 +04:00
|
|
|
if (hasPermission) {
|
|
|
|
return when.resolve();
|
2013-06-01 18:47:41 +04:00
|
|
|
}
|
|
|
|
|
2013-06-25 15:43:15 +04:00
|
|
|
// Otherwise, you shall not pass.
|
|
|
|
return when.reject();
|
2013-09-13 17:29:59 +04:00
|
|
|
},
|
|
|
|
|
|
|
|
add: function (newPostData, options) {
|
2013-09-23 02:20:08 +04:00
|
|
|
return ghostBookshelf.Model.add.call(this, newPostData, options).tap(function (post) {
|
2013-09-13 17:29:59 +04:00
|
|
|
// associated models can't be created until the post has an ID, so run this after
|
|
|
|
return post.updateTags(newPostData.tags);
|
|
|
|
});
|
2013-09-27 14:56:20 +04:00
|
|
|
},
|
|
|
|
destroy: function (_identifier, options) {
|
|
|
|
options = options || {};
|
|
|
|
return this.forge({id: _identifier}).fetch({withRelated: ['tags']}).then(function destroyTags(post) {
|
|
|
|
var tagIds = _.pluck(post.related('tags').toJSON(), 'id');
|
|
|
|
if (tagIds) {
|
|
|
|
return post.tags().detach(tagIds).then(function destroyPost() {
|
|
|
|
return post.destroy(options);
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
|
|
|
return post.destroy(options);
|
|
|
|
});
|
2013-06-25 15:43:15 +04:00
|
|
|
}
|
2013-06-01 18:47:41 +04:00
|
|
|
|
2013-06-25 15:43:15 +04:00
|
|
|
});
|
2013-06-01 18:47:41 +04:00
|
|
|
|
2013-09-23 02:20:08 +04:00
|
|
|
Posts = ghostBookshelf.Collection.extend({
|
2013-06-01 18:47:41 +04:00
|
|
|
|
2013-06-25 15:43:15 +04:00
|
|
|
model: Post
|
2013-06-01 18:47:41 +04:00
|
|
|
|
2013-06-25 15:43:15 +04:00
|
|
|
});
|
2013-06-01 18:47:41 +04:00
|
|
|
|
2013-06-25 15:43:15 +04:00
|
|
|
module.exports = {
|
|
|
|
Post: Post,
|
|
|
|
Posts: Posts
|
2013-07-04 23:53:45 +04:00
|
|
|
};
|