system/classes/comment.php

<?php
namespace Habari;

class Comment extends QueryRecord implements IsContent
{
  private $post_object = null;

  private $inforecords = null;

  // static variables to hold comment status and comment type values
  static $comment_status_list = array();
  static $comment_type_list = array();
  static $comment_status_actions = array();

  public static function default_fields()
  {
    return array(
      'id' => 0,
      'post_id' => 0,
      'name' => '',
      'email' => '',
      'url' => '',
      'ip' => 0,
      'content' => '',
      'status' => self::status('unapproved'),
      'date' => DateTime::create(),
      'type' => self::type('comment')
    );
  }

  public function __construct( $paramarray = array() )
  {
    // Defaults
    $this->fields = array_merge( self::default_fields(), $this->fields );
    parent::__construct( $paramarray );
    $this->exclude_fields( 'id' );
  }

  public static function __static()
  {
    Pluggable::load_hooks(__CLASS__);
  }

  static function get( $id = 0 )
  {
    if ( ! $id ) {
      return false;
    }
    return DB::get_row( 'SELECT * FROM {comments} WHERE id = ?', array( $id ), 'Comment' );
  }

  static function create( $paramarray )
  {
    $comment = new Comment( $paramarray );
    $comment->insert();
    return $comment;
  }

  public function insert()
  {
    $allow = true;
    $allow = Plugins::filter( 'comment_insert_allow', $allow, $this );
    if ( ! $allow ) {
      return false;
    }
    Plugins::act( 'comment_insert_before', $this );
    // Invoke plugins for all fields, since they're all "changed" when inserted
    foreach ( $this->fields as $fieldname => $value ) {
      Plugins::act( 'comment_update_' . $fieldname, $this, $this->$fieldname, $value );
    }
    $result = parent::insertRecord( DB::table( 'comments' ) );
    $this->newfields['id'] = DB::last_insert_id(); // Make sure the id is set in the comment object to match the row id
    $this->fields = array_merge( $this->fields, $this->newfields );
    $this->newfields = array();
    $this->info->commit( $this->fields['id'] );
    Plugins::act( 'comment_insert_after', $this );
    return $result;
  }

  public static function add_type($type)
  {
    DB::insert(
      DB::table('commenttype'),
      array(
        'name' => $type,
        'active' => 1,
      )
    );
    return DB::last_insert_id();
  }

  public static function add_status($status, $internal = false)
  {
    DB::insert(
      DB::table('commentstatus'),
      array(
        'name' => $status,
        'internal' => $internal ? 1 : 0,
      )
    );
    return DB::last_insert_id();
  }

  public static function remove_type($type, $delete = false)
  {
    if($delete) {
      // Delete comments of this type, delete type
      $type_id = Comment::type($type);
      DB::delete(
        DB::table('comments'),
        array('type' => $type_id)
      );
      DB::exec('DELETE FROM {commentinfo} WHERE comment_id IN (SELECT {commentinfo}.comment_id FROM {commentinfo} LEFT JOIN {comments} ON {commentinfo}.comment_id = {comments}.id WHERE {comments}.id IS NULL)');
      DB::delete(
        DB::table('commenttype'),
        array('name' => Comment::type_name($type))
      );
    }
    else {
      DB::update(
        DB::table('commenttype'),
        array(
          'name' => Comment::type_name($type),
          'active' => 0,
        ),
        array('name')
      );
    }
  }

  public static function remove_status($status, $newstatus = null)
  {
    // Delete comments of this status, delete status
    $status_id = Comment::status($status);
    if(is_null($newstatus)) {
      DB::delete(
        DB::table('comments'),
        array('status' => $status_id)
      );
      DB::exec('DELETE FROM {commentinfo} WHERE comment_id IN (SELECT {commentinfo}.comment_id FROM {commentinfo} LEFT JOIN {comments} ON {commentinfo}.comment_id = {comments}.id WHERE {comments}.id IS NULL)');
    }
    else {
      DB::update(
        DB::table('comments'),
        array('status' => Comment::status($newstatus)),
        array('status' => $status_id)
      );
    }
    DB::delete(
      DB::table('commentstatus'),
      array('name' => Comment::status_name($status))
    );
  }

  public function update()
  {
    $allow = true;
    $allow = Plugins::filter( 'comment_update_allow', $allow, $this );
    if ( ! $allow ) {
      return false;
    }
    Plugins::act( 'comment_update_before', $this );
    // invoke plugins for all fields which have been updated
    foreach ( $this->newfields as $fieldname => $value ) {
      Plugins::act( 'comment_update_' . $fieldname, $this, $this->fields[$fieldname], $value );
    }
    $result = parent::updateRecord( DB::table( 'comments' ), array( 'id'=>$this->id ) );
    $this->fields = array_merge( $this->fields, $this->newfields );
    $this->newfields = array();
    $this->info->commit();
    Plugins::act( 'comment_update_after', $this );
    return $result;
  }

  public function delete()
  {
    $allow = true;
    $allow = Plugins::filter( 'comment_delete_allow', $allow, $this );
    if ( ! $allow ) {
      return false;
    }
    Plugins::act( 'comment_delete_before', $this );

    // Delete all info records associated with this comment
    $this->info->delete_all();

    $result = parent::deleteRecord( DB::table( 'comments' ), array( 'id'=>$this->id ) );
    Plugins::act( 'comment_delete_after', $this );
    return $result;
  }

  public function __get( $name )
  {
    $fieldnames = array_merge( array_keys( $this->fields ), array('post', 'info', 'editlink' ) );
    $filter = false;
    if ( !in_array( $name, $fieldnames ) && strpos( $name, '_' ) !== false ) {
      $field_matches = implode('|', $fieldnames);
      if(preg_match( '/^(' . $field_matches . ')_(.+)$/', $name, $matches )) {
        list( $unused, $name, $filter ) = $matches;
      }
    }

    switch ( $name ) {
      case 'name':
        if ( parent::__get( $name ) == '' ) {
          $out = _t( 'Anonymous' );
        }
        else {
          $out = parent::__get( $name );
        }
        break;
      case 'post':
        $out = $this->get_post();
        break;
      case 'info':
        $out = $this->get_info();
        break;
      case 'statusname':
        $out = self::status_name( $this->status );
        break;
      case 'typename':
        $out = self::type_name( $this->type );
        break;
      case 'editlink':
        $out = $this->get_editlink();
        break;
      default:
        if(preg_match('#^is_(.+)$#i', $name, $matches)) {
          $ts_field = $matches[1];
          if($index = array_search($ts_field, Comment::list_comment_statuses())) {
            $out = $this->status == $index;
          }
          if($index = array_search($ts_field, Comment::list_comment_types())) {
            $out = $this->type == $index;
          }
          // Dumb check for plurals
          $pluralize = function($s) {
            return $s . 's';
          };
          if($index = array_search($ts_field, array_map($pluralize, Comment::list_comment_statuses()))) {
            $out = $this->status == $index;
          }
          if($index = array_search($ts_field, array_map($pluralize, Comment::list_comment_types()))) {
            $out = $this->type == $index;
          }
        }
        else {
          $out = parent::__get( $name );
        }
        break;
    }
    //$out = parent::__get( $name );
    $out = Plugins::filter( "comment_{$name}", $out, $this );
    if ( $filter ) {
      $out = Plugins::filter( "comment_{$name}_{$filter}", $out, $this );
    }
    return $out;
  }

  public function __set( $name, $value )
  {
    switch ( $name ) {
      case 'status':
        $value = self::status($value);
        break;
      case 'date':
        if ( !( $value instanceOf DateTime ) ) {
          $value = DateTime::create( $value );
        }
        break;
      case 'post':
        if ( is_int( $value ) ) {
          // a post ID was passed
          $p = Post::get( array( 'id'=>$value ) );
          $this->post_id = $p->id;
          $this->post_object = $p;
        }
        elseif ( is_string( $value ) ) {
          // a post Slug was passed
          $p = Post::get( array( 'slug'=>$value ) );
          $this->post_id = $p->id;
          $this->post_object = $p;
        }
        elseif ( is_object( $value ) ) {
          // a Post object was passed, so just use it directly
          $this->post_id = $value->id;
          $this->post_object = $value;
        }
        return $value;
    }
    return parent::__set( $name, $value );
  }

  private function get_post( $use_cache = true )
  {
    if ( ! isset( $this->post_object ) || ( ! $use_cache)  ) {
      $this->post_object = Posts::get( array('id' => $this->post_id, 'fetch_fn' => 'get_row') );
    }
    return $this->post_object;
  }

  private function get_info()
  {
    if ( ! $this->inforecords ) {
      if ( 0 == $this->id ) {
        $this->inforecords = new CommentInfo();
      }
      else {
        $this->inforecords = new CommentInfo( $this->id );
      }
    }
    return $this->inforecords;
  }

  public static function list_comment_types( $refresh = false )
  {
    if ( $refresh || empty( self::$comment_type_list ) ) {
      self::$comment_type_list = DB::get_keyvalue('SELECT id, name FROM {commenttype} WHERE active = 1;');
    }
    self::$comment_type_list = Plugins::filter( 'list_comment_types', self::$comment_type_list );
    return self::$comment_type_list;
  }

  public static function list_comment_statuses( $refresh = false )
  {
    if ( $refresh || empty( self::$comment_status_list ) ) {
      self::$comment_status_list = DB::get_keyvalue('SELECT id, name FROM {commentstatus};');
    }
    self::$comment_status_list = Plugins::filter( 'list_comment_statuses', self::$comment_status_list );
    return self::$comment_status_list;
  }

  public static function status_action( $status )
  {
    if ( empty( self::$comment_status_actions ) ) {
      self::$comment_status_actions = array(
        'unapproved' => _t( 'Unapprove' ),
        'approved' => _t( 'Approve' ),
        'spam' => _t( 'Spam' ),
      );
      self::$comment_status_actions = Plugins::filter( 'list_comment_actions', self::$comment_status_actions );
    }
    if ( isset( self::$comment_status_actions[$status] ) ) {
      return self::$comment_status_actions[$status];
    }
    if ( isset(self::$comment_status_actions[Comment::status_name($status)]) ) {
      return self::$comment_status_actions[Comment::status_name($status)];
    }

    return '';
  }


  public static function status( $name )
  {
    $statuses = Comment::list_comment_statuses();
    if ( is_numeric( $name ) && ( isset( $statuses[$name] ) ) ) {
      return $name;
    }
    $statuses = array_flip( $statuses );
    if ( isset( $statuses[$name] ) ) {
      return $statuses[$name];
    }
    return false;
  }

  public static function status_name( $status )
  {
    $statuses = Comment::list_comment_statuses();
    if ( is_numeric( $status ) && isset( $statuses[$status] ) ) {
      return $statuses[$status];
    }
    $statuses = array_flip( $statuses );
    if ( isset( $statuses[$status] ) ) {
      return $status;
    }
    return '';
  }

  public static function type( $name )
  {
    $types = Comment::list_comment_types();
    if ( is_numeric( $name ) && ( isset( $types[$name] ) ) ) {
      return $name;
    }
    $types = array_flip( $types );
    if ( isset( $types[$name] ) ) {
      return $types[$name];
    }
    return false;
  }

  public static function type_name( $type )
  {
    $types = Comment::list_comment_types();
    if ( is_numeric( $type ) && isset( $types[$type] ) ) {
      return $types[$type];
    }
    $types = array_flip( $types );
    if ( isset( $types[$type] ) ) {
      return $type;
    }
    return '';
  }

  public function content_type()
  {
    return Comment::type_name( $this->type );
  }

  public function get_access( $user = null )
  {
    if ( ! $user instanceof User ) {
      $user = User::identify();
    }

    // these tokens automatically grant full access to the comment
    if ( $user->can( 'super_user' ) || $user->can( 'manage_all_comments' ) ||
      ( $user->id == $this->post->user_id && $user->can( 'manage_own_post_comments' ) ) ) {
      return ACL::get_bitmask( 'full' );
    }

    /* If we got this far, we can't update or delete a comment. We still need to check if we have
     * read access to it. Collect a list of applicable tokens
     */
    $tokens = array(
      'post_any',
      'post_' . Post::type_name( $this->post->content_type ),
    );

    if ( $user->id == $this->post->user_id ) {
      $tokens[] = 'own_posts';
    }

    $tokens = array_merge( $tokens, $this->post->get_tokens() );

    $token_accesses = array();

    // grab the access masks on these tokens
    foreach ( $tokens as $token ) {
      $access = ACL::get_user_token_access( $user, $token );
      if ( $access instanceof Bitmask ) {
        $token_accesses[] = ACL::get_user_token_access( $user, $token )->value;
      }
    }

    // now that we have all the accesses, loop through them to build the access to the particular post
    if ( in_array( 0, $token_accesses ) ) {
      return ACL::get_bitmask( 0 );
    }

    if ( ACL::get_bitmask( Utils::array_or( $token_accesses ) )->read ) {
      return ACL::get_bitmask( 'read' );
    }

    // if we haven't returned by this point, we can neither manage the comment nor read it
    return ACL::get_bitmask( 0 );
  }

  private function get_editlink()
  {
    return URL::get( 'edit_comment', $this, false );
  }

  public function css_class ( $append = array() ) {

    $classes = $append;

    $classes[] = 'comment';
    $classes[] = 'comment-' . $this->id;
    $classes[] = 'type-' . $this->typename;
    $classes[] = 'status-' . $this->statusname;

    $classes[] = 'comment-post-' . $this->post->id;

    return implode( ' ', $classes );

  }

  public static function filter_comment_type_display_4( $type, $foruse )
  {
    $names = array(
      'comment' => array(
        'singular' => _t( 'comment' ),
        'plural' => _t( 'comments' ),
      ),
      'pingback' => array(
        'singular' => _t( 'pingback' ),
        'plural' => _t( 'pingbacks' ),
      ),
      'trackback' => array(
        'singular' => _t( 'trackback' ),
        'plural' => _t( 'trackbacks' ),
      ),
    );
    return isset( $names[$type][$foruse] ) ? $names[$type][$foruse] : $type;
  }

  public static function filter_comment_status_display_4( $status )
  {
    $names = array(
      'unapproved' => _t( 'unapproved' ),
      'approved' => _t( 'approved' ),
      'spam' => _t( 'spam' ),
    );
    return isset( $names[$status] ) ? $names[$status] : $status;
  }
}

?>