DBStaticMessages::messageWrite() - Code Metrics - Inspection of "CODE-misc-41a52.18: Moved DBStaticXXX classes to s..." - supernova-ws/SuperNova - Measure and Improve Code Quality continuously with Scrutinizer

Completed
Push — work-fleets ( d7065d...1ee481 )

by SuperNova.WS
created 2016-08-13 14:27 UTC
DBStaticMessages::messageWrite() F

↳ Parent: DBStaticMessages
Complexity

Conditions	13
Paths	2304
Size

Total Lines	72
Code Lines	44
Duplication

Lines	6
Ratio	8.33 %
Code Coverage

Tests	0
CRAP Score	182
Importance

Changes	1
Bugs	0	Features	0
Metric	Value
cc	13
eloc	44
c	1
b	0
f	0
nc	2304
nop	1
dl	6
loc	72
ccs	0
cts	56
cp	0
crap	182
rs	2.3514
How to fix Long Method Complexity

<?php

namespace DBStatic;

use classLocale;
use classSupernova;
use DBStatic\DBStaticUser;
use mysqli_result;
use template;

class DBStaticMessages {
  public static $snMessageClassList = array(
    MSG_TYPE_NEW       => array(
      'name'       => 'new_message',
      'switchable' => false,
      'email'      => false,
    ),
    MSG_TYPE_ADMIN     => array(
      'name'       => 'msg_admin',
      'switchable' => false,
      'email'      => true,
    ),
    MSG_TYPE_PLAYER    => array(
      'name'       => 'mnl_joueur',
      'switchable' => false,
      'email'      => true,
    ),
    MSG_TYPE_ALLIANCE  => array(
      'name'       => 'mnl_alliance',
      'switchable' => false,
      'email'      => true,
    ),
    MSG_TYPE_SPY       => array(
      'name'       => 'mnl_spy',
      'switchable' => true,
      'email'      => true,
    ),
    MSG_TYPE_COMBAT    => array(
      'name'       => 'mnl_attaque',
      'switchable' => true,
      'email'      => true,
    ),
    MSG_TYPE_TRANSPORT => array(
      'name'       => 'mnl_transport',
      'switchable' => true,
      'email'      => true,
    ),
    MSG_TYPE_RECYCLE   => array(
      'name'       => 'mnl_exploit',
      'switchable' => true,
      'email'      => true,
    ),
    MSG_TYPE_EXPLORE   => array(
      'name'       => 'mnl_expedition',
      'switchable' => true,
      'email'      => true,
    ),
    //     97 => 'mnl_general',

    MSG_TYPE_QUE       => array(
      'name'       => 'mnl_buildlist',
      'switchable' => true,
      'email'      => true,
    ),
    MSG_TYPE_OUTBOX    => array(
      'name'       => 'mnl_outbox',
      'switchable' => false,
      'email'      => false,
    ),
  );
  public static $snMessageGroup = array(
    'switchable' => array(MSG_TYPE_SPY, MSG_TYPE_COMBAT, MSG_TYPE_RECYCLE, MSG_TYPE_TRANSPORT, MSG_TYPE_EXPLORE, MSG_TYPE_QUE),
    'email'      => array(MSG_TYPE_SPY, MSG_TYPE_PLAYER, MSG_TYPE_ALLIANCE, MSG_TYPE_COMBAT, MSG_TYPE_RECYCLE, MSG_TYPE_TRANSPORT,
      MSG_TYPE_ADMIN, MSG_TYPE_EXPLORE, MSG_TYPE_QUE),
  );

  /**
   * @param mixed|array $owners
   * @param integer     $sender
   * @param integer     $timestamp
   * @param integer     $message_type
   * @param string      $from_unsafe
   * @param string      $subject_unsafe
   * @param string      $text_unsafe
   * @param bool        $force
   */
  public static function msg_send_simple_message($owners, $sender, $timestamp, $message_type, $from_unsafe, $subject_unsafe, $text_unsafe, $force = false) {
    global $user;

    if (!$owners) {
      return;
    }

    $timestamp = $timestamp ? $timestamp : SN_TIME_NOW;
    $sender = intval($sender);
    if (!is_array($owners)) {
      $owners = array($owners);
    }

    // TODO - check for valid message_type ?
    $message_class = static::$snMessageClassList[$message_type];
    $message_class_name = $message_class['name'];

    $message_class_name_total = static::$snMessageClassList[MSG_TYPE_NEW]['name'];

    if ($owners[0] == '*') {
      if ($user['authlevel'] < 3) {
        return false;
      }
      // TODO Добавить $timestamp - рассылка может быть и отсроченной
      // TODO Добавить $sender - рассылка может быть и от кого-то
      static::db_message_insert_all($message_type, $from_unsafe, $subject_unsafe, $text_unsafe);
      $owners = array();
    } else {
      $insert_values = array();
      foreach ($owners as $owner) {
        if ($user['id'] != $owner) {
          $owner_row = DBStaticUser::db_user_by_id($owner);
        } else {
          $owner_row = $user;
        }
        sys_user_options_unpack($owner_row);

        if ($force || !$message_class['switchable'] || $owner_row["opt_{$message_class_name}"]) {
          $insert_values[] = "('" . idval($owner) . "', '{$sender}', '{$timestamp}', '{$message_type}', '" . db_escape($from_unsafe) . "', '" . db_escape($subject_unsafe) . "', '" . db_escape($text_unsafe) . "')";
        }

        // TODO - allow sending HTML email only from admin
        if ($message_class['email'] && classSupernova::$config->game_email_pm && $owner_row["opt_email_{$message_class_name}"]) {
          $text_unescaped = str_replace(array('\\r\\n', '\\n', "\r\n", "\n"), "<br />", $text_unsafe);
          @$result = mymail($owner_row['email'], $subject_unsafe, $text_unescaped, '', true);
// For example instead of
@mkdir($dir);

// Better use
if (@mkdir($dir) === false) {
    throw new \RuntimeException('The directory '.$dir.' could not be created.');
}
        }
      }

      if (empty($insert_values)) {
        return;
      }

      classSupernova::$db->doInsertValuesDeprecated(

        TABLE_MESSAGES,
        array(
          'message_owner',
          'message_sender',
          'message_time',
          'message_type',
          'message_from',
          'message_subject',
          'message_text',
        ),
        $insert_values
      );
    }
    if (!empty($owners)) {
      // Danger - 'cause if IN clause
      classSupernova::$gc->cacheOperator->db_upd_record_list_DANGER(
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
        LOC_USER,
        array(),
        array(
          $message_class_name       => +1,
          $message_class_name_total => +1,
        ),
        array(),
        array(
          // TODO DANGER
          '`id` IN (' . implode(',', $owners) . ')',
        )
      );
    }

    if (in_array($user['id'], $owners) || $owners[0] == '*') {
      $user[$message_class_name]++;
      $user[$message_class_name_total]++;
    }
  }

  public static function msg_ali_send($message, $subject, $ally_rank_id = 0, $ally_id = 0) {
    global $user;

    $ally_id = $ally_id ? $ally_id : $user['ally_id'];

    $sendList = array();
    $list = '';
    $query = DBStaticUser::db_user_list(
      "ally_id = '{$ally_id}'" . ($ally_rank_id >= 0 ? " AND ally_rank_id = {$ally_rank_id}" : ''),
      false, 'id, username');
    foreach ($query as $u) {
      $sendList[] = $u['id'];
      $list .= "<br>{$u['username']} ";
    }

    static::msg_send_simple_message($sendList, $user['id'], SN_TIME_NOW, MSG_TYPE_ALLIANCE, $user['username'], $subject, $message);

    return $list;
  }


  /**
   * @param mixed|array $owners
   * @param string      $subject
   * @param string      $text
   * @param bool        $force
   */
  public static function msgSendFromAdmin($owners, $subject, $text, $force = false) {
    static::msg_send_simple_message($owners, 0, SN_TIME_NOW, MSG_TYPE_ADMIN, classLocale::$lang['sys_administration'], $subject, $text, $force);
  }

  /**
   * @param        $senderPlayerId
   * @param        $senderPlayerNameAndCoordinates
   * @param mixed  $recipientId
   * @param string $subject
   * @param string $text
   */
  public static function msgSendFromPlayer($senderPlayerId, $senderPlayerNameAndCoordinates, $recipientId, $subject, $text) {
    static::msg_send_simple_message(
      $recipientId, $senderPlayerId, SN_TIME_NOW, MSG_TYPE_PLAYER, $senderPlayerNameAndCoordinates, $subject, $text
    );
  }

  /**
   * @param \Buddy\BuddyParams $params
   * @param string             $localeSubjectId
   * @param string             $localeTextId
   */
  public static function msgSendFromPlayerBuddy($params, $localeSubjectId, $localeTextId) {
    static::msgSendFromPlayer(
      $params->playerId,
      $params->playerNameAndCoordinates,
      $params->newFriendIdSafe,
      classLocale::$lang[$localeSubjectId],
      sprintf(classLocale::$lang[$localeTextId], $params->playerName)
    );
  }


  /**
   * @param array $player
   *
   * @return template
   */
  public static function messageWrite($player) {
    $error_list = array();

    $recipientId = sys_get_param_id('id');
    $recipient_name_unescaped = sys_get_param_str_unsafe('recipient_name');
    $subject_unsafe = sys_get_param_str_unsafe('subject');

    if (!empty($recipientId)) {
      $recipient_row = DBStaticUser::db_user_by_id($recipientId);
    }

    if (empty($recipient_row)) {
      $recipient_row = DBStaticUser::db_user_by_username($recipient_name_unescaped);
    }

    if (!empty($recipient_row)) {
      $recipientId = $recipient_row['id'];
      $recipient_name_unescaped = $recipient_row['username'];
    } else {
      $recipientId = 0;
      $recipient_name_unescaped = '';
    }

    if ($recipientId == $player['id']) {

      $error_list[] = array('MESSAGE' => classLocale::$lang['msg_err_self_send'], 'STATUS' => ERR_ERROR);
    }

    $re = 0;
    while (strpos($subject_unsafe, classLocale::$lang['msg_answer_prefix']) !== false) {
      $subject_unsafe = substr($subject_unsafe, strlen(classLocale::$lang['msg_answer_prefix']));
      $re++;
    }
    $re ? $subject_unsafe = classLocale::$lang['msg_answer_prefix'] . $subject_unsafe : false;

    $subject_unsafe = $subject_unsafe ? $subject_unsafe : classLocale::$lang['msg_subject_default'];

    $textUnsafe = sys_get_param_str_unsafe('text');
    if (sys_get_param_str('msg_send')) {
      if (!$recipientId) {

        $error_list[] = array('MESSAGE' => classLocale::$lang['msg_err_player_not_found'], 'STATUS' => ERR_ERROR);
      }

      if (empty($textUnsafe)) {
        $error_list[] = array('MESSAGE' => classLocale::$lang['msg_err_no_text'], 'STATUS' => ERR_ERROR);
      }

      if (empty($error_list)) {
        $error_list[] = array('MESSAGE' => classLocale::$lang['msg_not_message_sent'], 'STATUS' => ERR_NONE);

        static::msgSendFromPlayer($player['id'], DBStaticUser::renderNameAndCoordinates($player), $recipientId, $subject_unsafe, $textUnsafe);

        $textUnsafe = '';
      }
    }

    $template = gettemplate('msg_message_compose', true);
    $template->assign_vars(array(
      'RECIPIENT_ID'   => $recipientId,
      'RECIPIENT_NAME' => htmlspecialchars($recipient_name_unescaped),
      'SUBJECT'        => htmlspecialchars($subject_unsafe),
      'TEXT'           => htmlspecialchars($textUnsafe),
    ));

    foreach ($error_list as $error_message) {
      $template->assign_block_vars('result', $error_message);
    }

    $message_query = static::db_message_list_get_last_20($player, $recipientId);
    static::messageRenderList(MSG_TYPE_OUTBOX, $template, $message_query);

    return $template;
  }


  /**
   * @param array  $player
   * @param string $current_class
   */
  public static function messageDelete($player, $current_class) {
    $message_range = sys_get_param_str('message_range');
    $marked_message_list = sys_get_param('mark', array());
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);

    $deleteAll = false;
    $where = array();
    $whereDanger = array();
    $not = '';
    switch ($message_range) {
      case 'unchecked':
        $not = 'NOT';
      case 'checked':
        if ($message_range == 'checked' && empty($marked_message_list)) {
          break;
        }

        foreach ($marked_message_list as &$messageId) {
$collection = json_decode($data, true);
if ( ! is_array($collection)) {
    throw new \RuntimeException('$collection must be an array.');
}

foreach ($collection as $item) { /** ... */ }
          $messageId = idval($messageId);
        }

        if ($query_add = implode(',', $marked_message_list)) {
          $whereDanger[] = "`message_id` {$not} IN ({$query_add})";
        }

      case 'class':
        if ($current_class != MSG_TYPE_OUTBOX && $current_class != MSG_TYPE_NEW) {
          $where['message_type'] = $current_class;
        }
      case 'all':
        $deleteAll = true;
      break;
    }

    if ($deleteAll || !empty($where)) {
      $where['message_owner'] = $player['id'];
      // Malformed $where
      classSupernova::$gc->db->doDeleteDanger(
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
        TABLE_MESSAGES,
        $where,
        $whereDanger
      );
    }
  }

  /**
   * @param array $player
   * @param int   $current_class
   *
   * @return template
   */
  public static function messageShow(&$player, $current_class) {
    $SubUpdateQrySet = array();
    $SubUpdateQryAdjust = array();
    $SubSelectQry = '';
    if ($current_class == MSG_TYPE_OUTBOX) {
      $message_query = static::db_message_list_outbox_by_user_id($player['id']);
    } else {
      if ($current_class == MSG_TYPE_NEW) {
        foreach (static::$snMessageClassList as $message_class_id => $message_class) {
          if ($message_class_id != MSG_TYPE_OUTBOX) {
            $SubUpdateQrySet[$message_class['name']] = 0;
            $player[$message_class['name']] = 0;
          }
        }
      } else {
        $classFieldNameCurrent = static::$snMessageClassList[$current_class]['name'];
        $classFieldNameNew = static::$snMessageClassList[MSG_TYPE_NEW]['name'];
        $SubUpdateQrySet[$classFieldNameCurrent] = 0;
        $SubUpdateQryAdjust[$classFieldNameNew] = -$player[$classFieldNameCurrent];
        $SubSelectQry = "AND `message_type` = '{$current_class}'";

        $player[static::$snMessageClassList[MSG_TYPE_NEW]['name']] -= $player[static::$snMessageClassList[$current_class]['name']];
        $player[static::$snMessageClassList[$current_class]['name']] = 0;
      }

      DBStaticUser::db_user_set_by_id($player['id'], $SubUpdateQrySet);
      DBStaticUser::db_user_adjust_by_id($player['id'], $SubUpdateQryAdjust);
      $message_query = static::db_message_list_by_owner_and_string($player, $SubSelectQry);
    }

    if (sys_get_param_int('return')) {
      header('Location: messages.php');
      die();
    }

    $template = gettemplate('msg_message_list', true);
    static::messageRenderList($current_class, $template, $message_query);

    $current_class_text = classLocale::$lang['msg_class'][$current_class];

    $template->assign_vars(array(
      "MESSAGE_CLASS"      => $current_class,
      "MESSAGE_CLASS_TEXT" => $current_class_text,
    ));

    return $template;
  }


  /**
   * @param int      $current_class
   * @param template $template
   * @param          $message_query
   */
  public function messageRenderList($current_class, $template, $message_query) {
    while ($message_row = db_fetch($message_query)) {
      $template->assign_block_vars('messages', array(
        'ID'   => $message_row['message_id'],
        'DATE' => date(FMT_DATE_TIME, $message_row['message_time'] + SN_CLIENT_TIME_DIFF),
        'FROM' => htmlspecialchars($message_row['message_from']),
        'SUBJ' => htmlspecialchars($message_row['message_subject']),
        'TEXT' => in_array($message_row['message_type'], array(MSG_TYPE_PLAYER, MSG_TYPE_ALLIANCE)) && $message_row['message_sender']
          ? nl2br(htmlspecialchars($message_row['message_text']))
          : nl2br($message_row['message_text']),

        'FROM_ID'        => $message_row['message_sender'],
        'SUBJ_SANITIZED' => htmlspecialchars($message_row['message_subject']),
        'STYLE'          => $current_class == MSG_TYPE_OUTBOX
          ? static::$snMessageClassList[MSG_TYPE_OUTBOX]['name']
          : static::$snMessageClassList[$message_row['message_type']]['name'],
      ));
    }
  }


// Messages *************************************************************************************************************
  public static function db_message_list_get_last_20($user, $recipient_id) {
    return classSupernova::$db->doSelect(
      "SELECT * FROM {{messages}}
        WHERE
          `message_type` = '" . MSG_TYPE_PLAYER . "' AND
          ((`message_owner` = '{$user['id']}' AND `message_sender` = '{$recipient_id}')
          OR
          (`message_sender` = '{$user['id']}' AND `message_owner` = '{$recipient_id}')) ORDER BY `message_time` DESC LIMIT 20;");
  }

  public static function db_message_list_outbox_by_user_id($user_id) {
    $user_id = idval($user_id);
    if (empty($user_id)) {
      return false;
    }

    return classSupernova::$db->doSelect("SELECT {{messages}}.message_id, {{messages}}.message_owner, {{users}}.id AS message_sender, {{messages}}.message_time,
          {{messages}}.message_type, {{users}}.username AS message_from, {{messages}}.message_subject, {{messages}}.message_text
       FROM
         {{messages}} LEFT JOIN {{users}} ON {{users}}.id = {{messages}}.message_owner WHERE `message_sender` = '{$user_id}' AND `message_type` = 1
       ORDER BY `message_time` DESC;");
  }

  public static function db_message_list_by_owner_and_string($user, $SubSelectQry) {
    return classSupernova::$db->doSelect("SELECT * FROM {{messages}} WHERE `message_owner` = '{$user['id']}' {$SubSelectQry} ORDER BY `message_time` DESC;");
  }

  public static function db_message_count_by_owner_and_type($user) {
    return classSupernova::$db->doSelect("SELECT message_owner, message_type, COUNT(message_owner) AS message_count FROM {{messages}} WHERE `message_owner` = {$user['id']} GROUP BY message_owner, message_type ORDER BY message_owner ASC, message_type;");
  }

  public static function db_message_count_outbox($user) {
    $row = classSupernova::$db->doSelectFetch("SELECT COUNT(message_sender) AS message_count FROM {{messages}} WHERE `message_sender` = '{$user['id']}' AND message_type = 1 GROUP BY message_sender;");

    return intval($row['message_count']);
  }

  public static function db_message_list_admin_by_type($int_type_selected, $StartRec) {
    return classSupernova::$db->doSelect("SELECT
  message_id as `ID`,
  message_from as `FROM`,
  message_owner as `OWNER_ID`,
  u.username as `OWNER_NAME`,
  message_text as `TEXT`,
  FROM_UNIXTIME(message_time) as `TIME`
FROM
  {{messages}} AS m
  LEFT JOIN {{users}} AS u ON u.id = m.message_owner " .
      ($int_type_selected >= 0 ? "WHERE `message_type` = {$int_type_selected} " : '') .
      "ORDER BY
  `message_id` DESC
LIMIT
  {$StartRec}, 25;");
  }

  public static function db_message_insert_all($message_type, $from_unsafe, $subject_unsafe, $text_unsafe) {
    $message_type_safe = intval($message_type);
    $from_safe = db_escape($from_unsafe);
    $subject_safe = db_escape($subject_unsafe);
    $text_safe = db_escape($text_unsafe);

    return classSupernova::$db->doInsertComplex('INSERT INTO {{messages}} (`message_owner`, `message_sender`, `message_time`, `message_type`, `message_from`, `message_subject`, `message_text`) ' .
      "SELECT `id`, 0, unix_timestamp(now()), {$message_type_safe}, '{$from_safe}', '{$subject_safe}', '{$text_safe}' FROM {{users}}");
  }

  /**
   * @param $int_type_selected
   *
   * @return array|bool|mysqli_result|null
   */
  public static function db_message_count_by_type($int_type_selected) {
    $page_max = classSupernova::$db->doSelectFetch('SELECT COUNT(*) AS `max` FROM `{{messages}}`' . ($int_type_selected >= 0 ? " WHERE `message_type` = {$int_type_selected};" : ''));

    return $page_max;
  }

  /**
   * @param string $message_delete
   */
  public static function db_message_list_delete_set($message_delete) {
    classSupernova::$db->doDeleteDanger(

      TABLE_MESSAGES,
      array(),
      array(
        "`message_id` IN ({$message_delete})",
      )
    );
  }

  public static function db_message_delete_by_id($messageId) {
    classSupernova::$gc->db->doDeleteRow(
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
      TABLE_MESSAGES,
      array(
        'message_id' => $messageId,
      )
    );
  }


  /**
   * @param $delete_date
   * @param $int_type_selected
   */
  public static function db_message_list_delete_by_date($delete_date, $int_type_selected) {
    $where = array();
    if ($int_type_selected >= 0) {
      $where['message_type'] = $int_type_selected;
    }
    classSupernova::$db->doDeleteDanger(

      TABLE_MESSAGES,
      $where,
      array(
        "message_time <= UNIX_TIMESTAMP('{$delete_date}')"
      )
    );
  }

}

Push — work-fleets ( d7065d...1ee481 )

DBStaticMessages::messageWrite() F

Complexity

Size

Duplication

Code Coverage

Importance

How to fix Long Method Complexity

Long Method

Available Fixes

Available Fixes

Available Fixes

supernova-ws / SuperNova

Push — work-fleets ( d7065d...1ee481 )

DBStaticMessages::messageWrite() F

Complexity

Size

Duplication

Code Coverage

Importance

How to fix Long Method Complexity

Long Method

Available Fixes

Available Fixes

Available Fixes

Duplication Side-by-Side

Filter issues like
