article_service.js

/*
 Copyright (C) 2015  PencilBlue, LLC

 This program is free software: you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation, either version 3 of the License, or
 (at your option) any later version.

 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.

 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

//dependencies
var async = require('async');
var util  = require('../../util.js');

/**
 * Reusable service classes to be called from controllers
 *
 * @module Services
 */
module.exports = function ArticleServiceModule(pb) {

    /**
     * Retrieves articles and pages
     *
     * @class ArticleService
     * @constructor
     *
     */
    function ArticleService(siteUid, onlyThisSite){
        this.object_type = ARTICLE_TYPE;
        this.site = pb.SiteService.getCurrentSite(siteUid);
        this.onlyThisSite = onlyThisSite;
        this.siteQueryService = new pb.SiteQueryService({site: this.site, onlyThisSite: onlyThisSite});
    }

    /**
     *
     * @private
     * @static
     * @readonly
     * @property ARTICLE_TYPE
     * @type {String}
     */
    var ARTICLE_TYPE = 'article';

    /**
     *
     * @private
     * @static
     * @readonly
     * @property PAGE_TYPE
     * @type {String}
     */
    var PAGE_TYPE = 'page';

    /**
     * Rerieves the content type
     *
     * @method getContentType
     * @return {String} Content type
     */
    ArticleService.prototype.getContentType = function() {
        return this.object_type;
    };

    /**
     * Sets the content type (article, page)
     *
     * @method setContentType
     * @param {String} type The content type
     */
    ArticleService.prototype.setContentType = function(type) {
        this.object_type = type;
    };

    /**
     * Finds an article or page by Id
     *
     * @method findById
     * @param {String}   articleId The article's object Id
     * @param {Function} cb        Callback function
     */
    ArticleService.prototype.findById = function(articleId, cb) {
        this.find(pb.DAO.getIdWhere(articleId), cb);
    };

    /**
     * Finds articles by section
     *
     * @method findBySection
     * @param {String}   sectionId The section's object Id
     * @param {Function} cb        Callback function
     */
    ArticleService.prototype.findBySection = function(sectionId, cb) {
        this.find({article_sections: sectionId}, cb);
    };

    /**
     * Finds articles and pages by topic
     *
     * @method findByTopic
     * @param {[type]}   topicId The topic's object Id
     * @param {Function} cb      Callback function
     */
    ArticleService.prototype.findByTopic = function(topicId, cb) {
        this.find({article_topics: topicId}, cb);
    };

    /**
     * Finds articles and pages matching criteria
     *
     * @method find
     * @param {Object} where Defines the where clause for the article search
     * @param {Object} options The options object that can provide query control
     * parameters
     * @param {Array} [options.order] The order that the results will be returned
     * in.  The default is publish date descending and created descending
     * @param {Object} [options.select] The fields that will be returned for each
     * article that matches the criteria
     * @param {Integer} [options.limit] The number of results to return
     * @param {Integer} [options.offset] The number of articles to skip before
     * returning results
     * @param {Function} cb Callback function that takes two parameters: the first
     * is an error, if occurred.  The second is an array of articles or possibly
     * null if an error occurs.
     */
    ArticleService.prototype.find = function(where, options, cb) {
        if (util.isFunction(options)) {
            cb      = options;
            options = {};
        }
        else if (!options) {
            options = {};
        }

        //verify the where is valid
        if (!util.isObject(where)) {
            return cb(new Error('The where clause must be an object'));
        }

        //build out query
        if(!where.publish_date) {
            where.publish_date = {$lt: new Date()};
        }
        if(!where.draft) {
            where.draft = {$ne: 1};
        }

        //build out the ordering
        var order;
        if (options.order) {
            order = options.order;
        }
        else {
            order = [{'publish_date': pb.DAO.DESC}, {'created': pb.DAO.DESC}];
        }

        //build out select
        var select;
        if (util.isObject(options.select)) {
            select = options.select;
        }
        else {
            select = pb.DAO.SELECT_ALL;
        }

        //build out the limit (must be a valid integer)
        var limit = undefined;
        if (pb.validation.isInt(options.limit, true, true)) {
            limit = options.limit;
        }

        //build out the limit (must be a valid integer)
        var offset = 0;
        if (pb.validation.isInt(options.offset, true, true)) {
            offset = options.offset;
        }

        var self = this;
        self.siteQueryService.q(this.getContentType(), {where: where, select: select, order: order, limit: limit, offset: offset}, function(err, articles) {
            if (util.isError(err)) {
                return cb(err, []);
            }
            else if (articles.length === 0) {
                return cb(null, []);
            }

            //get authors
            self.getArticleAuthors(articles, function(err, authors) {

                var contentService = new pb.ContentService({site: self.site});
                contentService.getSettings(function(err, contentSettings) {

                    var tasks = util.getTasks(articles, function(articles, i) {
                        return function(callback) {
                            self.processArticleForDisplay(articles[i], articles.length, authors, contentSettings, options, function(){
                                callback(null, null);
                            });
                        };
                    });
                    async.series(tasks, function(err, results) {
                        cb(err, articles);
                    });
                });
            });
        });

    };

    /**
     * Updates articles
     * @method update
     * @param {String} articleId	id of article
     * @param {Object} fields	fields to update
     * @param {Object} options
     * @param {Function} cb      Callback function
     */
    ArticleService.prototype.update = function(articleId, fields, options, cb) {
        if(!util.isObject(fields)){
            return cb(new Error('The fields parameter is required'));
        }

        var where = pb.DAO.getIdWhere(articleId);
        var content_type = this.getContentType();

        var dao  = new pb.DAO();
        dao.updateFields(content_type, where, fields, options, cb);
    };

    /**
     * Retrieves data necessary for displaying an articles and appends it to the
     * article object
     *
     * @method processArticleForDisplay
     * @param {Object}   article         The artice to process
     * @param {Number}   articleCount    The total number of articles
     * @param {Array}    authors         Available authors retrieved from the database
     * @param {Object}   contentSettings Content settings to use for processing
     * @param {Function} cb              Callback function
     */
    ArticleService.prototype.processArticleForDisplay = function(article, articleCount, authors, contentSettings, options, cb) {
        if (util.isFunction(options)) {
            cb = options;
            options = cb;
        }

        var self = this;

        if (this.getContentType() === ARTICLE_TYPE) {
            if(contentSettings.display_bylines) {

                for(var j = 0; j < authors.length; j++) {

                    if(pb.DAO.areIdsEqual(authors[j][pb.DAO.getIdField()], article.author)) {
                        if(authors[j].photo && contentSettings.display_author_photo) {
                            article.author_photo     = authors[j].photo;
                            article.media_body_style = '';
                        }

                        article.author_name     = pb.users.getFormattedName(authors[j]);
                        article.author_position = (authors[j].position && contentSettings.display_author_position) ? authors[j].position : '';
                        break;
                    }
                }
            }

            if(contentSettings.display_timestamp ) {
                article.timestamp = pb.ContentService.getTimestampTextFromSettings(
                  article.publish_date,
                  contentSettings
                );
            }

            if(article.article_layout.indexOf('^read_more^') > -1) {
                if(articleCount > 1) {
                    article.article_layout = article.article_layout.substr(0, article.article_layout.indexOf('^read_more^')) + ' <a href="' + pb.config.siteRoot + '/article/' + article.url + '">' + contentSettings.read_more_text + '...</a>';
                }
                else {
                    article.article_layout = article.article_layout.split('^read_more^').join('');
                }
            }
            else if(articleCount > 1 && contentSettings.auto_break_articles) {
                var breakString = '<br>';
                var tempLayout;

                // Firefox uses br and Chrome uses div in content editables.
                // We need to see which one is being used
                var brIndex = article.article_layout.indexOf('<br>');
                if(brIndex === -1) {
                    brIndex = article.article_layout.indexOf('<br />');
                    breakString = '<br />';
                }
                var divIndex = article.article_layout.indexOf('</div>');

                // Temporarily replace double breaks with a directive so we don't mess up the count
                if(divIndex === -1 || (brIndex > -1 && divIndex > -1 && brIndex < divIndex)) {
                    tempLayout = article.article_layout.split(breakString + breakString).join(breakString + '^dbl_pgf_break^');
                }
                else {
                    breakString = '</div>';
                    tempLayout = article.article_layout.split('<div><br></div>').join(breakString + '^dbl_pgf_break^')
                      .split('<div><br /></div>').join(breakString + '^dbl_pgf_break^');
                }

                // Split the layout by paragraphs and remove any empty indices
                var tempLayoutArray = tempLayout.split(breakString);
                for(var i = 0; i < tempLayoutArray.length; i++) {
                    if(!tempLayoutArray[i].length) {
                        tempLayoutArray.splice(i, 1);
                        i--;
                    }
                }

                // Only continue if we have more than 1 paragraph
                if(tempLayoutArray.length > 1) {
                    var newLayout = '';

                    // Cutoff the article at the right number of paragraphs
                    for(i = 0; i < tempLayoutArray.length && i < contentSettings.auto_break_articles; i++) {
                        if(i === contentSettings.auto_break_articles -1 && i != tempLayoutArray.length - 1) {
                            newLayout += tempLayoutArray[i] + '&nbsp;<a href="' + pb.config.siteRoot + '/article/' + article.url + '">' + contentSettings.read_more_text + '...</a>' + breakString;
                            continue;
                        }
                        newLayout += tempLayoutArray[i] + breakString;
                    }

                    if(breakString === '</div>') {
                        breakString = '<div><br /></div>';
                    }

                    // Replace the double breaks
                    newLayout = newLayout.split('^dbl_pgf_break^').join(breakString);

                    article.article_layout = newLayout;
                }
            }
        }

        article.layout  = article.article_layout;
        var mediaLoader = new MediaLoader({site: self.site, onlyThisSite: self.onlyThisSite});
        mediaLoader.start(article[this.getContentType()+'_layout'], options, function(err, newLayout) {
            article.layout = newLayout;
            delete article.article_layout;

            if (self.getContentType() === ARTICLE_TYPE && ArticleService.allowComments(contentSettings, article)) {

                var opts = {
                    where: {
                        article: article[pb.DAO.getIdField()].toString()
                    },
                    order: {
                        created: pb.DAO.ASC
                    }
                };
                var dao   = new pb.DAO();
                dao.q('comment', opts, function(err, comments) {
                    if(util.isError(err) || comments.length == 0) {
                        return cb(null, null);
                    }

                    self.getCommenters(comments, contentSettings, function(err, commentsWithCommenters) {
                        article.comments = commentsWithCommenters;
                        cb(null, null);
                    });
                });
            }
            else {
                cb(null, null);
            }
        });
    };

    /**
     * Retrieves the authors of an array of articles
     *
     * @method getArticleAuthors
     * @param {Array}    articles Array of article objects
     * @param {Function} cb       Callback function
     */
    ArticleService.prototype.getArticleAuthors = function(articles, cb) {

        //gather all author IDs
        var dao = new pb.DAO();
        dao.q('user', {where: pb.DAO.getIdInWhere(articles, 'author')}, cb);
    };

    /**
     * Retrieves the commenters for an array of comments
     *
     * @method getCommenters
     * @param {Array}    comments        Array of comment objects
     * @param {Object}   contentSettings Content settings to use for processing
     * @param {Function} cb              Callback function
     */
    ArticleService.prototype.getCommenters = function(comments, contentSettings, cb) {

        //callback for iteration to handle setting the commenter attributes
        var processComment = function(comment, commenter) {
            comment.commenter_name = 'Anonymous';
            comment.timestamp      = pb.ContentService.getTimestampTextFromSettings(comment.created, contentSettings);

            if (commenter) {
                comment.commenter_name = pb.users.getFormattedName(commenter);
                if(commenter.photo) {
                    comment.commenter_photo = commenter.photo;
                }
                if(commenter.position) {
                    comment.commenter_position = commenter.position;
                }
            }
        };

        var processedComments = [];
        var users             = {};
        var tasks             = util.getTasks(comments, function(comments, i) {
            return function(callback) {

                var comment   = comments[i];
                if (!comment.commenter || users[comment.commenter]) {

                    //user already commented so pull locally
                    processComment(comment, users[comment.commenter]);
                    processedComments.push(comment);
                    callback(null, true);
                    return;
                }

                //user has not already commented so load
                var dao = new pb.DAO();
                dao.loadById(comment.commenter, 'user', function(err, commenter) {
                    if(util.isError(err) || commenter == null) {
                        callback(null, false);
                        return;
                    }

                    //process the comment
                    users[commenter[pb.DAO.getIdField()].toString()] = commenter;
                    processComment(comment, commenter);
                    processedComments.push(comment);

                    callback(null, true);
                });
            };
        });
        async.series(tasks, function(err, result) {
            cb(err, processedComments);
        });
    };

    /**
     * Retrieves the article and byline templates
     *
     * @method getTemplates
     * @param {Object} [opts]
     * @param {Function} cb Callback function
     */
    ArticleService.prototype.getTemplates = function(opts, cb) {
        if (util.isFunction(opts)) {
            cb = opts;
            opts = {};
        }

        var ts = new pb.TemplateService(opts);
        ts.load('elements/article', function(err, articleTemplate) {
            ts.load('elements/article/byline', function(err, bylineTemplate) {
                cb(articleTemplate, bylineTemplate);
            });
        });
    };

    /**
     * Retrieves the SEO metadata for the specified content.
     * @method getMetaInfo
     * @param {Object} article The article to retrieve information for
     * @param {Function} cb A callback that takes two parameters.  The first is
     * an Error, if occurred.  The second is an object that contains 4
     * properties:
     * title - the SEO title,
     * description - the SEO description,
     * keywords - an array of SEO keywords that describe the content,
     * thumbnail - a URI path to the thumbnail image
     */
    ArticleService.prototype.getMetaInfo = function(article, cb) {
        var serviceV2 = new pb.ArticleServiceV2({site: this.site, onlyThisSite: this.onlyThisSite});
        serviceV2.getMetaInfo(article, cb);
    };

    /**
     * Retrieves the meta info for an article or page
     * @deprecated Since 0.4.1
     * @method getMetaInfo
     * @param {Object}   article An article or page object
     * @param {Function} cb      Callback function
     */
    ArticleService.getMetaInfo = function(article, cb) {
        if(util.isNullOrUndefined(article)) {
            return cb('', '', '');
        }

        //log deprecation
        pb.log.warn('ArticleService: ArticleService.getMetaInfo is deprecated and will be removed 0.5.0.  Use the prototype function getMetaInfo instead');

        //all wrapped up to ensure we can be multi-threaded here for backwards 
        //compatibility
        (function(cb) {

            var articleService = new ArticleService();
            articleService.getMetaInfo(article, function(err, meta) {
                if (util.isError(err)) {
                    return cb('', '', '');
                }

                cb(meta.keywords, meta.description, meta.title, meta.thumbnail);
            });
        })(cb);
    };

    /**
     * Provided the content descriptor and the content settings object the
     * function indicates if comments should be allowed within the given
     * context of the content.
     * @method allowComments
     * @param {Object} contentSettings The settings object retrieved from the
     * content service
     * @param {Object} content The page or article that should or should not
     * have associated comments.
     * @return {Boolean}
     */
    ArticleService.allowComments = function(contentSettings, content) {
        return contentSettings.allow_comments && content.allow_comments;
    };

    /**
     * Handles retrieval and injection of media in articles and pages
     *
     * @module Services
     * @class MediaLoader
     * @constructor
     * @submodule Entities
     */
    function MediaLoader(opts) {
        /**
         * @property mediaService
         * @type {MediaService}
         */
        this.mediaService = new pb.MediaService(null, opts.site, opts.onlyThisSite);
    };

    /**
     * Processes an article or page to insert media
     *
     * @method start
     * @param  {String}   articleLayout The HTML layout of the article or page
     * @param  {Function} cb            [description]
     */
    MediaLoader.prototype.start = function(articleLayout, options, cb) {
        if (util.isFunction(options)) {
            cb = options;
            options = {};
        }
        if (!util.isObject(options.media)) {
            options.media = {};
        }

        //scan for media that should be retrieved
        var flags = this.scanForFlags(articleLayout);
        if (flags.length === 0) {
            return cb(null, articleLayout);
        }

        //reconcile what media is already cached and that which should be loaded
        var idsToRetrieve = [];
        flags.forEach(function(flag) {
            if (!options.media[flag.id]) {
                idsToRetrieve.push(flag.id);
            };
        });

        //when all media is already cached just do the processing
        if (idsToRetrieve.length === 0) {
            return this.onMediaAvailable(articleLayout, options, cb);
        }

        //retrieve the media that we need
        var self = this;
        var opts = {
            where: idsToRetrieve.length === 1 ? pb.DAO.getIdWhere(idsToRetrieve[0]) : pb.DAO.getIdInWhere(idsToRetrieve)
        };
        this.mediaService.get(opts, function(err, media) {
            if (util.isError(err)) {
                return cb(err);
            }

            //cache the retrieved media
            var idField = pb.DAO.getIdField();
            media.forEach(function(mediaItem) {
                options.media[mediaItem[idField].toString()] = mediaItem;
            });

            self.onMediaAvailable(articleLayout, options, cb);
        });
    };

    /**
     * @method onMediaAvailable
     * @param {String} articleLayout
     * @param {Object} options
     * @param {Function} cb
     */
    MediaLoader.prototype.onMediaAvailable = function(articleLayout, options, cb) {
        var self = this;

        this.getMediaTemplate(options, function(err, mediaTemplate) {
            options.mediaTemplate = mediaTemplate;

            async.whilst(
              function() {return articleLayout.indexOf('^media_display_') >= 0;},
              function(callback) {
                  self.replaceMediaTag(articleLayout, mediaTemplate, options.media, function(err, newArticleLayout) {
                      articleLayout = newArticleLayout;
                      callback();
                  });
              },
              function(err) {
                  cb(err, articleLayout);
              }
            );
        });
    };

    /**
     * Retrieves the media template for rendering media
     * @method getMediaTemplate
     * @param {Object} options
     * @param {Function} cb
     */
    MediaLoader.prototype.getMediaTemplate = function(options, cb) {
        if (options.mediaTemplate) {
            return cb(null, options.mediaTemplate);
        }

        var templatePath = options.mediaTemplatePath || 'elements/media';
        var ts = new pb.TemplateService(options);
        ts.load('elements/media', cb);
    };

    /**
     * Scans a string for media flags then parses them to return an array of
     * each one that was found
     * @method scanForFlags
     * @param {String} layout
     * @return {Array}
     */
    MediaLoader.prototype.scanForFlags = function(layout) {
        if (!util.isString(layout)) {
            return [];
        }

        var flags = [];
        var index = 0;
        while( (index = layout.indexOf('^media_display_')) >= 0) {
            flags.push(pb.MediaService.extractNextMediaFlag(layout));

            var nexPosition = layout.indexOf('^', index + 1);
            layout = layout.substr(nexPosition);
        }
        return flags;
    };

    /**
     * Replaces an article or page layout's ^media_display^ tag with a media embed
     * @method replaceMediaTag
     * @param {String}   layout        The HTML layout of the article or page
     * @param {String}   mediaTemplate The template of the media embed
     * @param {Function} cb            Callback function
     */
    MediaLoader.prototype.replaceMediaTag = function(layout, mediaTemplate, mediaCache, cb) {
        var flag = pb.MediaService.extractNextMediaFlag(layout);
        if (!flag) {
            return cb(null, layout);
        }

        var mediaStyleString = flag.style;

        var data = mediaCache[flag.id];
        if (!data) {
            pb.log.warn("MediaLoader: Content contains reference to missing media [%s].", flag.id);
            return cb(null, layout.replace(flag.flag, ''));
        }

        //ensure the max height is set if explicity set for media replacement
        var options = {
            view: 'post',
            style: {

            },
            attrs: {
                frameborder: "0",
                allowfullscreen: ""
            }
        };
        if (flag.style.maxHeight) {
            options.style['max-height'] = flag.style.maxHeight;
        }
        this.mediaService.render(data, options, function(err, html) {
            if (util.isError(err)) {
                return cb(err);
            }

            //get the style for the container
            var containerStyleStr = pb.MediaService.getStyleForPosition(flag.style.position) || '';

            //finish up replacements
            var mediaEmbed = mediaTemplate.split('^media^').join(html);
            mediaEmbed     = mediaEmbed.split('^caption^').join(data.caption);
            mediaEmbed     = mediaEmbed.split('^display_caption^').join(data.caption ? '' : 'display: none');
            mediaEmbed     = mediaEmbed.split('^container_style^').join(containerStyleStr);
            cb(null, layout.replace(flag.flag, mediaEmbed));
        });
    };

    //exports
    return {
        ArticleService: ArticleService,
        MediaLoader: MediaLoader
    };
};