articles.class.php

查看本檔案說明文件.

<?php

    include_once( PLOG_CLASS_PATH.'class/dao/model.class.php' );
    include_once( PLOG_CLASS_PATH.'class/dao/article.class.php' );
    include_once( PLOG_CLASS_PATH.'class/dao/articlecategories.class.php' );
    include_once( PLOG_CLASS_PATH.'class/dao/articlenotifications.class.php' );
    include_once( PLOG_CLASS_PATH.'class/dao/articlecomments.class.php' );
    include_once( PLOG_CLASS_PATH.'class/dao/articlecommentstatus.class.php' ); 
    include_once( PLOG_CLASS_PATH.'class/dao/users.class.php' );
    include_once( PLOG_CLASS_PATH.'class/dao/trackbacks.class.php' );
    include_once( PLOG_CLASS_PATH.'class/data/timestamp.class.php' );
    include_once( PLOG_CLASS_PATH.'class/config/config.class.php' );
    include_once( PLOG_CLASS_PATH.'class/dao/blogs.class.php' );
    include_once( PLOG_CLASS_PATH.'class/data/textfilter.class.php' );
    include_once( PLOG_CLASS_PATH.'class/dao/customfields/customfieldsvalues.class.php' );
    include_once( PLOG_CLASS_PATH.'class/dao/customfields/customfields.class.php' );

    include_once( PLOG_CLASS_PATH.'class/logger/LogUtil.php' );

    class Articles extends Model
    {

        // DAO objects that we keep for later, so that we don't have
        // to create them eeeeevery time!
        var $categories;
        var $comments;
        var $trackbacks;
        var $users;
        var $blogs;
        var $customfields;      
        var $_blogInfo;
        var $_blogSettings;
        var $_timeDiff;

        function Articles()
        {
            $this->Model();
            $this->categories = new ArticleCategories();
            $this->comments = new ArticleComments();
            $this->trackbacks = new Trackbacks();
            $this->users      = new Users();
            $this->blogs      = new Blogs();
            $this->customfields = new CustomFieldsValues();         
            // fine, this is not very nice but it helps a lot, specially if all the classes
            // that need to load articles share the same instance       
            $this->cache      = Array();    
            $this->_blogInfo  = null;
            $this->_timeDiff  = 0;
            $this->_blogsettings = null;
        }

        function getUserArticle( $artId, $userId = -1 )
        {
            $query = "SELECT * FROM ".$this->getPrefix()."articles WHERE id = '".Db::qstr($artId)."'";
            if( $userId != -1 )
                $query .= " AND user_id = '".Db::qstr($userId)."'";
            $query .= ";";

            // we send the query and then fetch the first array with the result
            $result = $this->Execute( $query );

            if ( $result->RecordCount() == 0)
                return false;

            $row = $result->FetchRow( $result );

            $article = $this->_fillArticleInformation( $row );
            
            $result->Close();            

            return $article;
        }

        function getBlogArticle( $artId, $blogId = -1, $includeHiddenFields = true, $date = -1, $categoryId = -1, $userId = -1, $status = POST_STATUS_ALL, $maxDate = -1 )
        {
            $prefix = $this->getPrefix();
            $query = "SELECT a.id, a.date,
                             a.user_id,a.blog_id,a.status,a.properties,
                             a.num_reads, a.slug FROM {$prefix}articles a ";
            // thanks jon for the tip :) You're right that the amount of rows will be too big if we don't really need these
            // fields!
            if($categoryId != -1 && $blogId != -1) {
                $query .= ", {$prefix}articles_categories c, {$prefix}article_categories_link l ";
            }
            
            $query .= "WHERE a.id = ".Db::qstr($artId);
                     
            if( $blogId != -1 )
                $query .= " AND a.blog_id = ".Db::qstr($blogId);
            if( $date != -1 && $maxDate == -1 ) {
                $query .= " AND a.date+0 LIKE '$date%'";
            } elseif ( $date != -1 && $maxDate != -1 ) {
                $query .= " AND a.date+0 >= $date AND a.date+0 <= $maxDate";
            }
            if( $userId != -1 ) 
                $query .= " AND a.user_id = ".Db::qstr($userId);
            if( $categoryId != -1 )
                $query .= " AND c.id = ".Db::qstr($categoryId)." AND c.id = l.category_id AND a.id = l.article_id";
            if( $status != POST_STATUS_ALL )
                $query .= " AND a.status = $status;";
                
            return $this->_getBlogArticleFromQuery( $query, $includeHiddenFields );
        }
        
        function getBlogArticleByTitle( $artTitle, $blogId = -1, $includeHiddenFields = true, $date = -1, $categoryId = -1, $userId = -1, $status = POST_STATUS_PUBLISHED, $maxDate = -1 )
        {
            $prefix = $this->getPrefix();
            $query = "SELECT a.id, a.date,
                             a.user_id,a.blog_id,a.status,a.properties,
                             a.num_reads, a.slug FROM {$prefix}articles a ";
            // thanks jon once again :)
            if($categoryId != -1 && $blogId != -1) {
                $query .= ",{$prefix}articles_categories c, {$prefix}article_categories_link l ";
            }
            $query .= "WHERE a.slug = '".Db::qstr($artTitle)."'";
            if( $blogId != -1 )
                $query .= " AND a.blog_id = ".Db::qstr($blogId);
            if( $date != -1 && $maxDate == -1 ) {
                $query .= " AND a.date+0 LIKE '$date%'";
            } elseif ( $date != -1 && $maxDate != -1 ) {
                $query .= " AND a.date+0 >= $date AND a.date+0 <= $maxDate";
            }
            if( $userId != -1 ) 
                $query .= " AND a.user_id = ".Db::qstr($userId);
            if( $categoryId != -1 ) {
                $query .= " AND c.id = ".Db::qstr($categoryId)." AND c.id = l.category_id AND a.id = l.article_id";
            }
                
            $query .= " AND a.status = $status;";
            
            return $this->_getBlogArticleFromQuery( $query, $includeHiddenFields );
        }
        
        function _getBlogArticleFromQuery( $query, $includeHiddenFields )
        {
            // we send the query and then fetch the first array with the result
            $result = $this->Execute( $query );

            if( $result == false )
                return false;

            if ( $result->RecordCount() == 0)
                return false;

            $row = $result->FetchRow( $result );

            $article = $this->_fillArticleInformation( $row, $includeHiddenFields );
            
            $result->Close();            

            return $article;        
        }

        function getBlogNextArticle( $article )
        {
            // we need to keep the timestamp in mind
            $date = $article->getDateObject();
            $articleCorrectedDate = Timestamp::getDateWithOffset( $article->getDate(), -($article->getTimeOffset()));
            $blogId = $article->getBlog();

            // gets the article that is just next in time
            $query = "SELECT * FROM ".$this->getPrefix()."articles 
                              WHERE date > '".$articleCorrectedDate."' AND status = '".Db::qstr(POST_STATUS_PUBLISHED)."' 
                                    AND blog_id = '".Db::qstr($blogId)."' ORDER BY date ASC LIMIT 1;";
            
            return( $this->_getBlogArticleFromQuery( $query, false ));
        }

        function getBlogPrevArticle( $article )
        {
            // we need to keep the timestamp in mind
            $date = $article->getDateObject();
            $articleCorrectedDate = Timestamp::getDateWithOffset( $article->getDate(), -($article->getTimeOffset()));
            $blogId = $article->getBlog();          
        
            // gets the article that is just previous in time
            $query = "SELECT * FROM ".$this->getPrefix()."articles 
                               WHERE date < '".$articleCorrectedDate."' AND status = ".POST_STATUS_PUBLISHED." 
                                     AND blog_id = '".Db::qstr($blogId)."' ORDER BY date DESC LIMIT 1;";
                                     
            return( $this->_getBlogArticleFromQuery( $query, false ));
        }
        
        function searchBlogArticles( $blogId, $searchTerms )
        {
            $posts = $this->getBlogArticles( $blogId,
                                             -1, // no date
                                             -1, // no amount
                                             0, // no category id
                                             0, // not any status
                                             0, // not belonging to any user id in particular
                                             0, // no maximum date
                                             $searchTerms // the only thing we're taking into account: the search terms!!
                                             );
                                                 
            return $posts;
        }
        
        function buildWhere( $blogid, $date = -1, $amount = -1, $categoryId = 0, $status = 0, $userId = 0, $maxDate = 0, $searchTerms = "" )
        {
            $postStatus = $status;
            $prefix = $this->getPrefix();
            if($blogid == -1){
                $query = "a.blog_id = a.blog_id";
            }
            else{
                $query = "a.blog_id = ".Db::qstr($blogid);
            }
            if( $date != -1 ) {
                // consider the time difference
                $blogSettings = $this->blogs->getBlogSettings( $blogid );
                $timeDifference = $blogSettings->getValue( "time_offset" );
                $SecondsDiff = $timeDifference * 3600;
                $query .= " AND FROM_UNIXTIME(UNIX_TIMESTAMP(a.date)+$SecondsDiff)+0 LIKE '$date%'";
            }

            // the common part "c.id = a.category_id" is needed so that
            // we don't get one article row as many times as the amount of categories
            // we have... due to the sql 'join' operation we're carrying out
            if( $categoryId == -1 )
                $query .= " AND c.id = l.category_id AND a.id = l.article_id ";
            else {
                if( $categoryId > 0 )
                    $query .= " AND a.id = l.article_id AND l.category_id = $categoryId AND c.id = l.category_id";
                else {
                    $query .= " AND c.id = l.category_id AND a.id = l.article_id AND c.in_main_page = 1";
                }
            }

            if( $status > 0 )
                $query .= " AND a.status = '$postStatus'";
            if( $userId > 0 )
                $query .= " AND a.user_id = ".Db::qstr($userId);
            if( $maxDate > 0 )
                $query .= " AND a.date <= '$maxDate'";
                
            // in case there were some search terms specified as parameters...
            if( $searchTerms != "" ) {
                // load the class dynamically so that we don't have to waste memory
                // if we're not going to need it!
                include_once( PLOG_CLASS_PATH."class/dao/searchengine.class.php" );         
                $searchEngine = new SearchEngine();
                
                // prepare the query string
                $searchTerms = $searchEngine->_adaptSearchString( $searchTerms );
                $whereString = $searchEngine->_generateSearchArticlesWhereString( $searchTerms );
                
                // and add it to the current search
                $query .=" AND {$whereString} ";    
            }
                
            if( $categoryId <= 0 )
                $query .= " GROUP BY a.id ";

                
            return $query;
        }
        
        function getNumBlogArticles( $blogid, $date = -1, $amount = -1, $categoryId = -1, $status = 0, $userId = 0, $maxDate = 0, $searchTerms = "" )
        {       
            $postStatus = $status;
            $prefix = $this->getPrefix();           
            $where = $this->buildWhere( $blogid, $date, $amount, $categoryId, $status, $userId, $maxDate, $searchTerms );   
            $query = "SELECT COUNT(*) AS total FROM {$prefix}articles a, {$prefix}articles_categories c, 
                             {$prefix}article_categories_link l";
            if( $searchTerms != "" )
                $query .= ", {$prefix}articles_text t ";
                
            if( $searchTerms != "" )
                $query .= "WHERE t.article_id = a.id AND $where";
            else
                $query .= " WHERE $where";          
                
            if( $categoryId != -1 )
                $query .= " GROUP BY a.id";
                                                              
            $result = $this->_db->Execute( $query );
            
            if( !$result )
                return 0;
                                
            $number = $result->RowCount();
            
            $result->Close();
            
            return( $number );            
        }

        function getBlogArticles( $blogid, $date = -1, $amount = -1, $categoryId = 0, $status = 0, $userId = 0, 
                                  $maxDate = 0, $searchTerms = "", $page = -1 )
        {
            // build the query
            // the query gets quite complicated to build because we have to take care of plenty
            // of conditions, such as the maximum date, the amount, the category,
            // wether the category has to be shown in the main page or not, etc...
            $postStatus = $status;
            $prefix = $this->getPrefix();
            $where = $this->buildWhere( $blogid, $date, $amount, $categoryId, $status, $userId, $maxDate, $searchTerms );
            $query = "SELECT a.id as id, a.id, a.date,
                             a.user_id,a.blog_id,a.status,a.properties,
                             a.num_reads, a.slug, 1 AS relevance FROM {$prefix}articles a, {$prefix}articles_categories c, 
                             {$prefix}article_categories_link l";
            if( $searchTerms != "" )
                $query .= ", {$prefix}articles_text t ";
            $query .= " WHERE ";
            if( $searchTerms != "" )
                $query .= " t.article_id = a.id AND ";
            $query .= " $where";
                      
    
            // if we're doing a search, we should sort by relevance
            if( $searchTerms != "" ) {
                $query .= " ORDER BY relevance";            
            }
            else {
                $query .= " ORDER BY a.date DESC";              
            }
            
            // we don't need limits if we're getting the posts for a given day
            if( ($amount > 0) && ($date == -1) && ($page == -1 ))
                $query .= " LIMIT $amount;"; 
            
            // in case we're using a paged display
            if( $page > 0 ) {
                $start = (($page - 1) * $amount);               
                $query .= " LIMIT $start, $amount";   
            }

            // execute the query
            $result = $this->Execute( $query );

            if( !$result )
                return Array();
                
            if( $result->RowCount() == 0 )
                return Array();
            
            $ids='';

            while( $row = $result->FetchRow()) {
                $ids.='"'.$row["id"].'",';
                $article = $this->_fillArticleHeaderInformation( $row );
                $articles[] =$article;
            }

            $ids = substr($ids, 0, -1);          
            //$articleComments = $this->comments->getPostCommentsByIds( $ids, COMMENT_ORDER_NEWEST_FIRST, COMMENT_STATUS_ALL );
            //$articleTrackbacks = $this->trackbacks->getArticleTrackbacksByIds( $ids );
            $articleCategories = $this->categories->getArticleCategoriesByIds( $ids, $blogid );
            $articleTexts = $this->getArticlesText( $ids );
            
            foreach( $articles as $article ) {
                $lastArticleId=$article->getId();
                // These are functions normally called by _fillArticleInformation
                // But now I moved to test getPostCommentsByIds
                $categoryIds = Array();
                
                // fill in the article texts
                $article->setText( $articleTexts[$lastArticleId]['text'] );
                $article->setTopic( $articleTexts[$lastArticleId]['topic'] );
                
                foreach( $articleCategories[$lastArticleId] as $category )
                    $categoryIds[] = $category->getId();
                    
                $article->setCategoryIds( $categoryIds );
                $article->setCategories( $articleCategories[$lastArticleId] );
                //$article->setNumTrackbacks(sizeof($articleTrackbacks[$lastArticleId]));
                //$article->setTrackbacks($articleTrackbacks[$lastArticleId]);
                //$article->setTotalComments(sizeof($articleComments[$lastArticleId]));
                //$article->setComments($articleComments[$lastArticleId]);
                //$article->setFields( $fields[$lastArticleId] );

                $fullarticles[]=$article;
                $this->cache[$lastArticleId] = $article;       
            }
            
            $result->Close();            
            
            return $fullarticles;
        }

        function getArticleIdFromName($articleName){
            $query = "SELECT id FROM ".$this->getPrefix()."articles ".
                     " WHERE slug = '".Db::qstr($articleName)."'";

            $result = $this->Execute($query);

            if($row = $result->FetchRow()){
              $result->Close();            
              if($row["id"])
                return $row["id"];
            }
            return 0;
        }       


        
        function getArticlesText( $articleIds )
        {
            $prefix = $this->getPrefix();
            $query = "SELECT article_id,text,topic FROM {$prefix}articles_text WHERE
                      article_id IN (".$articleIds.")";
                      
            $result = $this->Execute( $query );

            // it's impossible that an article has no categories, but
            // we'll bear with it...
            if( !$result )
                return Array();

            // otherwise, fetch them
            while ($row = $result->FetchRow()) {
                $lastArticleId=$row["article_id"];
                $postTexts[$lastArticleId]=$row;
            }
            
            $result->Close();           
            
            return( $postTexts );
        }

        function getBlogArticlesByQuery( $query )
        {
            $result = $this->Execute( $query );
            if( !$result ) return Array();
            $articles = Array();
            while( $row = $result->FetchRow()) {
                $article = $this->_fillArticleInformation( $row );
                $articles[] = $article;
            }
            
            $result->Close();            
            
            return $articles;
        }

        function getNumberPostsPerMonth( $blogId )
        {
            // query to get the earliest post
            // this must be my longest and most complex SQL query ever :)
            // $blogs = new Blogs();
            $blogSettings = $this->blogs->getBlogSettings( $blogId );
            if( $blogSettings->getValue( "show_future_posts_in_calendar" ))
                $numPostsPerMonthQuery = "SELECT COUNT(*) AS 'count',YEAR(date) AS 'year',MONTH(date) AS 'month',DAYOFMONTH(date) AS 'daymonth' FROM ".$this->getPrefix()."articles WHERE status = 1 AND blog_id = ".$blogId." GROUP BY YEAR(date),MONTH(date) ORDER BY YEAR(date) DESC,MONTH(date) DESC;";
            else
                $numPostsPerMonthQuery = "SELECT COUNT(*) AS 'count',YEAR(date) AS 'year',MONTH(date) AS 'month',DAYOFMONTH(date) AS 'daymonth' FROM ".$this->getPrefix()."articles WHERE status = 1 AND blog_id = ".$blogId." AND date <= NOW() GROUP BY YEAR(date),MONTH(date) ORDER BY YEAR(date) DESC,MONTH(date) DESC;";

            $result = $this->Execute( $numPostsPerMonthQuery);
            if( $result == false )
                return false;

            $archives = Array();
            while( $row = $result->FetchRow()) {
                $archives[$row["year"]][$row["month"]] = $row["count"];
            }
            
            $result->Close();            

            return $archives;
        }
        
        function getNumberPostsPerMonthAdmin( $blogId )
        {
            // query to get the earliest post
            // this must be my longest and most complex SQL query ever :)
            $numPostsPerMonthQuery = "SELECT COUNT(*) AS 'count', YEAR(date) AS 'year',
                                      MONTH(date) AS 'month', DAYOFMONTH(date) AS 'daymonth' 
                                      FROM ".$this->getPrefix()."articles 
                                      WHERE blog_id = $blogId 
                                      GROUP BY YEAR(date), MONTH(date) 
                                      ORDER BY YEAR(date) DESC,MONTH(date) DESC;";

            $result = $this->Execute( $numPostsPerMonthQuery);
            if( $result == false )
                return false;
                
            while( $row = $result->FetchRow()) {
                $archives[$row["year"]][$row["month"]] = $row["count"];
            }
            
            $result->Close();            

            return $archives;
        }

        function getNumberPostsPerDay( $blogId, $year = null , $month = null )
        {
            // if month and/or year are empty, get the current ones
            if( $year == null ) {
                $t = new Timestamp();
                $year = $t->getYear();
            }
            if( $month == null ) {
                $t = new Timestamp();
                $month = $t->getMonth();
            }

            // another long sql query :) the id and date fields are there just in case we need to debug
            // but they're not included in the resulting array
            // $blogs = new Blogs();
            $blogSettings = $this->blogs->getBlogSettings( $blogId );
            // consider the time difference
            $timeDifference = $blogSettings->getValue( "time_offset" );
            $SecondsDiff = $timeDifference * 3600;
            // check whether we're supposed to show posts that happen in the future or not
            if( $blogSettings->getValue( "show_future_posts_in_calendar" ))
                $numPostsPerDayQuery = "SELECT COUNT(*) AS 'count', DAYOFMONTH(FROM_UNIXTIME(UNIX_TIMESTAMP(date) + $SecondsDiff)) AS 'day', id AS 'id', date AS 'date' FROM ".$this->getPrefix()."articles WHERE status = 1 AND blog_id = ".$blogId." AND MONTH(FROM_UNIXTIME(UNIX_TIMESTAMP(date) + $SecondsDiff)) = ".$month." AND YEAR(FROM_UNIXTIME(UNIX_TIMESTAMP(date) + $SecondsDiff)) = ".$year." GROUP BY DAYOFMONTH(FROM_UNIXTIME(UNIX_TIMESTAMP(date) + $SecondsDiff));";
            else
                $numPostsPerDayQuery = "SELECT COUNT(*) AS 'count', DAYOFMONTH(FROM_UNIXTIME(UNIX_TIMESTAMP(date) + $SecondsDiff)) AS 'day', id AS 'id', date AS 'date' FROM ".$this->getPrefix()."articles WHERE status = 1 AND blog_id = ".$blogId." AND date <= NOW() AND MONTH(FROM_UNIXTIME(UNIX_TIMESTAMP(date) + $SecondsDiff)) = ".$month." AND YEAR(FROM_UNIXTIME(UNIX_TIMESTAMP(date) + $SecondsDiff)) = ".$year." GROUP BY DAYOFMONTH(FROM_UNIXTIME(UNIX_TIMESTAMP(date) + $SecondsDiff));";

            $result = $this->Execute( $numPostsPerDayQuery );

            if( $result == false )
                return 0;

            $postsPerDay = Array();
            while( $row = $result->FetchRow()) {
                $postsPerDay[$row["day"]] = $row["count"];
            }
            
            $result->Close();            

            return $postsPerDay;
        }

        function addPostCategoriesLink( $articleId, $categories )
        {
            // nothing to do if the $categories array is not ehem, an array :)
            if( !is_array( $categories ))
                return true;
                
            foreach( $categories as $categoryId ) {
                $query = "INSERT INTO ".$this->getPrefix()."article_categories_link
                          (article_id, category_id) VALUES ($articleId, $categoryId )";
                $this->Execute( $query );
            }

            return true;
        }

        function deletePostCategoriesLink( $articleId )
        {
            $query = "DELETE FROM ".$this->getPrefix()."article_categories_link
                      WHERE article_id = $articleId";

            return $this->Execute( $query );
        }

        function updatePostCategoriesLink( $articleId, $categories )
        {
            if( !$this->deletePostCategoriesLink( $articleId ))
                return false;

            return $this->addPostCategoriesLink( $articleId, $categories );
        }

        function addArticle( &$newArticle )
        {
            // first, we build up the query
            $query = "INSERT INTO ".$this->getPrefix()."articles( user_id,blog_id,status,date,properties, slug )
                      VALUES ( ".$newArticle->getUser().",".
                      $newArticle->getBlog().",'".
                      $newArticle->getStatus()."','".
                      $newArticle->getDate()."','".
                      serialize($newArticle->getProperties())."','".
                      $newArticle->getPostSlug()."');";
            // and then we send it to the db
            //$this->_db->debug=true;
            $result = $this->Execute( $query );

            if( !$result ){
                return false;
            }

            // get id of the post from the database
            $postId = $this->_db->Insert_ID();
            
            // save the post text
            $newArticle->setId( $postId );
            $this->addArticleText( $newArticle );

            // and create the link between the post and its categories?
            $this->addPostCategoriesLink( $postId, $newArticle->getCategoryIds());

            // and save the custom fields
            $this->addArticleCustomFields( $postId, $newArticle->getBlog(), $newArticle->getFields());

            return $postId;
        }
        
        function addArticleText( $newArticle )
        {
            $filter = new Textfilter();
            $prefix = $this->getPrefix();
            $query = "INSERT INTO {$prefix}articles_text
                                  (article_id, topic, text, normalized_text, normalized_topic)
                      VALUES( '".Db::qstr( $newArticle->getId())."', '".
                                Db::qstr($newArticle->getTopic())."','".
                                Db::qstr($newArticle->getText(false))."','".
                                $filter->normalizeText(Db::qstr($newArticle->getText(false)))."', '".
                                $filter->normalizeText(Db::qstr($newArticle->getTopic()))."')";
                                
            return( $this->Execute( $query ));
        }
        
        function getArticleText( $articleId )
        {
            $prefix = $this->getPrefix();
            $query = "SELECT text,topic FROM {$prefix}articles_text
                      WHERE article_id = '".Db::qstr($articleId)."'";
                      
            $result = $this->Execute( $query );
            
            if( !$result ) 
                return false;
                
            $row = $result->FetchRow();
            
            $result->Close();
            
            return( $row );         
        }
        
        function updateArticleText( $article )
        {
            $filter = new Textfilter();
            $query = "UPDATE ".$this->getPrefix()."articles_text SET 
                        topic = '".Db::qstr($article->getTopic())."'".
                     ", text = '".Db::qstr($article->getText(false))."'".
                     ", normalized_text = '".$filter->normalizeText(Db::qstr($article->getText(false)))."'".
                     ", normalized_topic = '".$filter->normalizeText(Db::qstr($article->getTopic()))."'".
                     " WHERE article_id = ".$article->getId().";";
            
            return($this->Execute( $query ));
        }

        function addArticleCustomFields( $artId, $blogId, $fields )
        {
            $customFields = new CustomFieldsValues();

            foreach( $fields as $field ) {
                $customFields->addCustomFieldValue( $field->getFieldId(), $field->getValue(), $artId, $blogId );
            }

            return true;
        }

        function updateArticle( $article )
        {
            // we have to build up the query, which will be pretty long...
            $articleDate = Timestamp::getDateWithOffset( $article->getDate(), -($article->getTimeOffset()));

            $query = "UPDATE ".$this->getPrefix()."articles SET id = ".$article->getId().
                     ", user_id = ".$article->getUser().
                     ", date = '".$articleDate. "'".
                     ", blog_id = ".$article->getBlog().
                     ", status = '".$article->getStatus()."'".
                     ", num_reads = ".$article->getNumReads().
                     ", properties = '".serialize($article->getProperties())."'".
                     ", slug = '".$article->getPostSlug()."'".
                     " WHERE id = ".$article->getId().";";

            $result = $this->Execute( $query );

            // we don't bother doing anything else if the query above failed...
            if( !$result )
                return false;
                
            // update the article text
            $this->updateArticleText( $article );

            if( !$this->updatePostCategoriesLink( $article->getId(), $article->getCategoryIds()))
                return false;

            if( !$this->updateArticleCustomFields( $article->getId(), $article->getBlog(), $article->getFields()))
                return false;

            return true;
        }

        function updateArticleCustomFields( $artId, $blogId, $fields )
        {
            $customFields = new CustomFieldsValues();

            // first remove the values
            if( !$customFields->removeArticleCustomFields( $artId ))
                return false;

            foreach( $fields as $field ) {
                $customFields->addCustomFieldValue( $field->getFieldId(), $field->getValue(), $artId, $blogId );
            }

            return true;
        }

        function updateArticleNumReads( $articleId )
        {
            // we have to build up the query, which will be pretty long...
            $query = "UPDATE ".$this->getPrefix()."articles SET ".
                     " num_reads = num_reads+1 ".
                     ", date = date ".
                     " WHERE id = '".Db::qstr($articleId)."'";

            $result = $this->Execute( $query );

            return $result;
        }
        
        function updateArticleNumReadsByName( $articleName )
        {
            // we have to build up the query, which will be pretty long...
            $query = "UPDATE ".$this->getPrefix()."articles SET ".
                     " num_reads = num_reads+1 ".
                     ", date = date ".
                     " WHERE slug = '".Db::qstr($articleName)."'";

            $result = $this->Execute( $query );

            return $result;
        }       

        function deleteArticle( $artId, $userId, $blogId, $forever = false )
        {
            if( $forever ) {
                $query = "DELETE FROM ".$this->getPrefix()."articles WHERE id = ".$artId." AND user_id = ".$userId." AND blog_id = ".$blogId.";";
                // -- text --
                $this->deleteArticleText( $artId );
                // we also have to remove its comments and trackbacks if the article is being deleted forever
                // -- comments --
                $comments = new ArticleComments();
                $comments->deletePostComments( $artId );
                // -- trackbacks --
                $trackbacks = new Trackbacks();
                $trackbacks->deletePostTrackbacks( $artId );
                // -- post-to-categories mappings --
                $this->deletePostCategoriesLink( $artId );
                // -- custom fields --
                $customFields = new CustomFieldsValues();
                $customFields->removeArticleCustomFields( $artId );
            }
            else {
                $query = "UPDATE ".$this->getPrefix()."articles SET date = date, status = 3 WHERE id = ".$artId." AND user_id = ".$userId." AND blog_id = ".$blogId.";";
            }

            $result = $this->Execute( $query );

            if( !$result )
                return false;

            if( $this->_db->Affected_Rows() == 0 )
                return false;

            return true;
        }
        
        function deleteArticleText( $articleId )
        {
            $query = "DELETE FROM ".$this->getPrefix()."articles_text WHERE article_id = '".Db::qstr($articleId)."'";
            
            return( $this->Execute( $query ));
        }

        function doesUserOwnArticle( $userinfo, $artid )
        {
            $article = $this->getArticle( $artid );
            $articleOwnerInfo = $article->getUserInfo();

            if( $articleOwnerInfo->getId() == $userinfo->getId())
                return true;
            else
                return false;
        }

        function getAllArticles( $maxPosts = 0, $date = 0)
        {
            $query = "SELECT * FROM ".$this->getPrefix()."articles WHERE status = 1";
            if( $date > 0 )
                $query .= " AND date < '$date'";

            $query .= " ORDER BY date DESC";

            if( $maxPosts > 0 )
                $query .= " LIMIT 0,".$maxPosts;

            $result = $this->Execute( $query );

            if( !$result )
                return false;

            $posts = Array();
            while( $row = $result->FetchRow()) {
                $posts[] = $this->_fillArticleInformation( $row );
            }
            
            $result->Close();            

            return $posts;
        }

        function deleteBlogPosts( $blogId )
        {
            $blogArticles = $this->getBlogArticles( $blogId );

            foreach( $blogArticles as $article ) {
                // the deleteArticle method will also take care of removing comments and
                // trackbacks
                $this->deleteArticle( $article->getId(), $article->getUser(), $article->getBlog(), true );
            }

            return true;
        }

        function purgePosts()
        {
            $query = "SELECT * FROM ".$this->getPrefix()."articles WHERE status = 3";

            $result = $this->Execute( $query );
            if( !$result )
                return false;

            while( $row = $result->FetchRow()) {
                $this->deleteArticle( $row["id"], $row["user_id"], $row["blog_id"], true );
            }
            
            $result->Close();            

            return true;
        }

        function getArticleCategories( $articleId, $blogId = -1 )
        {
            return $this->categories->getArticleCategories( $articleId, $blogId );
        }

        function getArticleCategoryIds( $articleId )
        {
            $query = "SELECT category_id FROM ".$this->getPrefix()."article_categories_link
                      WHERE article_id = $articleId";

            $result = $this->Execute( $query );

            // it's impossible that an article has no categories, but
            // we'll bear with it...
            if( !$result )
                return Array();

            // otherwise, fetch them
            $categories = Array();
            while( $row = $result->FetchRow()) {
                $categories[] = $row['category_id'];
            }
            
            $result->Close();            

            return $categories;
        }

        function _fillArticleInformation( $query_result, $includeHiddenFields = true )
        {
            $id = $query_result['id'];
            if( isset($this->cache[$id])) {
                return($this->cache[$id]);
            }

            // this is a little dirty trick or otherwise the old
            // that don't have the 'properties' field will not work
            // as they will appear to have comments disabled
            if( $query_result['properties'] == "" ) {
                $tmpArray = Array( 'comments_enabled' => true );
                $query_result['properties'] = serialize($tmpArray);
            }

            // ---
            // this, i do not like... but I couldn't find a more
            // "elegant" way to arrange it! This makes this method
            // totally dependant on the blog configuration so it basically
            // means an additional query every time we fetch an article
            // (just in case we didn't have enough!)
            // ---

            //
            // if there's a time difference applied to all dates, then we'd better
            // calculate it here!!
            //
            $blogId = $query_result['blog_id'];
            $blogInfo = $this->blogs->getBlogInfo( $blogId );
            $blogSettings = $blogInfo->getSettings();
            $timeDiff = $blogSettings->getValue( 'time_offset' );

            // we can use this auxiliary function to help us...
            $date = Timestamp::getDateWithOffset( $query_result['date'], $timeDiff );

            $articleCategories = $this->getArticleCategories( $query_result['id'], $query_result['blog_id'] );
            $categoryIds = Array();
            foreach( $articleCategories as $category )
                array_push( $categoryIds, $category->getId());
                
            // get the article text
            $postText = $this->getArticleText( $query_result['id'] );

            $article = new Article( $postText['topic'],
                                    $postText['text'],
                                    $categoryIds,
                                    $query_result['user_id'],
                                    $query_result['blog_id'],
                                    $query_result['status'],
                                    $query_result['num_reads'],
                                    unserialize($query_result['properties']),
                                    $query_result['slug'],
                                    $query_result['id'] );
                                    
            // and fill in all the fields with the information we just got from the db
            $article->setDate( $date );
            $article->setTimeOffset( $timeDiff