DBStaticPlanet - 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

DBStaticPlanet C

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	311
Duplicated Lines	39.87 %

Coupling/Cohesion

Components	1
Dependencies	4

Test Coverage

Coverage

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
c	1
b	0
f	0
dl	124
loc	311
ccs	0
cts	198
cp	0
rs	6.433
wmc	57
lcom	1
cbo	4

23 Methods

Rating	Name	Duplication	Size	Complexity
A	getResources()	0	10	2
A	db_planets_purge()	0	9	1
A	db_planet_by_id()	0	5	2
A	db_planet_by_gspt_safe()	0	4	1
A	db_planet_by_gspt()	0	8	1
B	db_planet_by_vector()	0	10	7
A	db_planet_by_vector_object()	0	6	3
A	db_planet_by_parent()	14	14	2
A	db_planet_by_id_and_owner()	8	8	3
A	db_planet_list_moon_other()	8	8	3
A	db_planet_list_in_system()	0	7	1
B	db_planet_list_sorted()	0	21	5
A	db_planet_list_by_user_or_planet()	8	8	4
A	db_planet_update_resources()	16	16	3
A	db_planet_update_set_by_id()	0	3	1
A	db_planet_update_adjust_by_id()	0	3	1
A	db_planet_update_by_gspt()	0	20	4
A	db_planet_set_by_parent()	14	14	3
A	db_planet_set_by_owner()	14	14	3
A	db_planet_delete_by_id()	14	14	2
A	db_planet_list_delete_by_owner()	14	14	2
A	db_planet_count_by_type()	12	12	2
A	db_planet_list_resources_by_owner()	0	3	1

How to fix Duplicated Code Complexity

Duplicated Code

Duplicate code is one of the most pungent code smells. A rule that is often used is to re-structure code once it is duplicated in three or more places.

Common duplication problems, and corresponding solutions are:

If you have the same expression in different places: Extract expression to a method
If you have the same method in different sub-classes: Extract method, and pull up field to the parent class
If you have the same code in unrelated classes: Consider extracting the code to a new class, and injecting that class

Complex Class

Tip: Before tackling complexity, make sure that you eliminate any duplication first. This often can reduce the size of classes significantly.

Complex classes like DBStaticPlanet often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes. You can also have a look at the cohesion graph to spot any un-connected, or weakly-connected components.

Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.

While breaking up the class, it is a good idea to analyze how other classes use DBStaticPlanet, and based on these observations, apply Extract Interface, too.

<?php

namespace DBStatic;

use classSupernova;
use mysqli_result;
use Vector\Vector;

class DBStaticPlanet {

  /**
   * @param array $rowUser
   * @param array $rowPlanet
   *
   * @return array
   */
  public static function getResources($rowUser, $rowPlanet) {
    $planetResources = array();

    $sn_group_resources = sn_get_groups('resources_loot');
    foreach ($sn_group_resources as $resource_id) {
      $planetResources[$resource_id] = floor(mrc_get_level($rowUser, $rowPlanet, $resource_id));
    }

    return $planetResources;
  }


  public static function db_planets_purge() {
    classSupernova::$db->doDeleteSql(
      'DELETE FROM `{{planets}}` 
      WHERE 
        `id_owner` NOT IN (
          SELECT `id` FROM `{{users}}`
        );'
    );
  }


  /**
   * @param int    $planet_id
   * @param bool   $for_update
   * @param string $fields
   *
   * @return array|null
   */
  public static function db_planet_by_id($planet_id, $for_update = false, $fields = '*') {
    $result = classSupernova::$gc->cacheOperator->db_get_record_by_id(LOC_PLANET, $planet_id, $for_update, $fields);
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.
}

    return empty($result) ? null : $result;
  }

  public static function db_planet_by_gspt_safe($galaxy, $system, $planet, $planet_type, $for_update = false, $fields = '*') {

    return classSupernova::$gc->cacheOperator->db_get_record_list(LOC_PLANET,
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.
}
      "`{{planets}}`.`galaxy` = {$galaxy} AND `{{planets}}`.`system` = {$system} AND `{{planets}}`.`planet` = {$planet} AND `{{planets}}`.`planet_type` = {$planet_type}", true);
  }

  public static function db_planet_by_gspt($galaxy, $system, $planet, $planet_type, $for_update = false, $fields = '*') {
    $galaxy = intval($galaxy);
    $system = intval($system);
    $planet = intval($planet);
    $planet_type = intval($planet_type);

    return DBStaticPlanet::db_planet_by_gspt_safe($galaxy, $system, $planet, $planet_type, $for_update, $fields);
  }

  public static function db_planet_by_vector($vector, $prefix = '', $for_update = false, $fields = '*') {
    $galaxy = isset($vector[$prefix . 'galaxy']) ? intval($vector[$prefix . 'galaxy']) : 0;
    $system = isset($vector[$prefix . 'system']) ? intval($vector[$prefix . 'system']) : 0;
    $planet = isset($vector[$prefix . 'planet']) ? intval($vector[$prefix . 'planet']) : 0;
    $planet_type = isset($vector[$prefix . 'planet_type']) ? intval($vector[$prefix . 'planet_type']) :
      (isset($vector[$prefix . 'type']) ? intval($vector[$prefix . 'type']) : 0);
    $planet_type = $planet_type == PT_DEBRIS ? PT_PLANET : $planet_type;

    return DBStaticPlanet::db_planet_by_gspt_safe($galaxy, $system, $planet, $planet_type, $for_update, $fields);
  }

  /**
   * @param Vector $vector
   * @param bool   $for_update
   * @param string $fields
   *
   * @return array
   */
  public static function db_planet_by_vector_object($vector, $for_update = false, $fields = '*') {
    $planet_type = $vector->type == PT_DEBRIS ? PT_PLANET : $vector->type;
    $result = DBStaticPlanet::db_planet_by_gspt_safe($vector->galaxy, $vector->system, $vector->planet, $planet_type, $for_update, $fields);

    return !empty($result) ? $result : array();
  }

  public static function db_planet_by_parent($parent_id, $for_update = false, $fields = '*') {

    if (!($parent_id = idval($parent_id))) {
      return false;
    }

    return classSupernova::$gc->cacheOperator->db_get_record_list(
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_PLANET,
      array('parent_planet' => $parent_id, 'planet_type' => PT_MOON),
function acceptsInteger($int) { }

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

// Instead of
acceptsInteger($x);

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

//    return classSupernova::$gc->cacheOperator->db_get_record_list(LOC_PLANET,

//      "`parent_planet` = {$parent_id} AND `planet_type` = " . PT_MOON, true);
  }

  public static function db_planet_by_id_and_owner($planet_id, $owner_id, $for_update = false, $fields = '*') {

    if (!($planet_id = idval($planet_id)) || !($owner_id = idval($owner_id))) {
      return false;
    }

    return classSupernova::$gc->cacheOperator->db_get_record_list(LOC_PLANET,
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.
}
      "`id` = {$planet_id} AND `id_owner` = {$owner_id}", true);
  }


  public static function db_planet_list_moon_other($user_id, $this_moon_id) {

    if (!($user_id = idval($user_id)) || !($this_moon_id = idval($this_moon_id))) {
      return false;
    }

    return classSupernova::$gc->cacheOperator->db_get_record_list(LOC_PLANET,
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.
}
      "`planet_type` = " . PT_MOON . " AND `id_owner` = {$user_id} AND `id` != {$this_moon_id}");
  }

  public static function db_planet_list_in_system($galaxy, $system) {
    $galaxy = intval($galaxy);
    $system = intval($system);

    return classSupernova::$gc->cacheOperator->db_get_record_list(LOC_PLANET,
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.
}
      "`galaxy` = {$galaxy} AND `system` = {$system}");
  }

  public static function db_planet_list_sorted($user_row, $skip_planet_id = false, $field_list = '', $conditions = '') {

    if (!is_array($user_row)) {
      return false;
    }
    // $field_list = $field_list != '*' ? "{{planets}}.`id`, `name`, `image`, {{planets}}.`galaxy`, {{planets}}.`system`, {{planets}}.`planet`, `planet_type`{$field_list}" : $field_list;

    $conditions .= $skip_planet_id ? " AND `id` <> {$skip_planet_id} " : '';

    $sort_orders = array(
      SORT_ID       => '{{planets}}.`id`',
      SORT_LOCATION => '{{planets}}.`galaxy`, {{planets}}.`system`, {{planets}}.`planet`, {{planets}}.`planet_type`',
      SORT_NAME     => '`name`',
      SORT_SIZE     => '({{planets}}.`field_max`)',
    );
    $order_by = classSupernova::$user_options[PLAYER_OPTION_PLANET_SORT];
    empty($sort_orders[$order_by]) ? $order_by = SORT_ID : false;
    $order_by = $sort_orders[$order_by] . ' ' . (classSupernova::$user_options[PLAYER_OPTION_PLANET_SORT_INVERSE] == SORT_ASCENDING ? 'ASC' : 'DESC');

    // Compilating query
    return classSupernova::$gc->cacheOperator->db_get_record_list(LOC_PLANET,
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.
}
      "`id_owner` = '{$user_row['id']}' {$conditions} ORDER BY {$order_by}");
  }

  public static function db_planet_list_by_user_or_planet($user_id, $planet_id) {

    if (!($user_id = idval($user_id)) && !($planet_id = idval($planet_id))) {
      return false;
    }

    return classSupernova::$gc->cacheOperator->db_get_record_list(LOC_PLANET,
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.
}
      $planet_id = idval($planet_id) ? "{{planets}}.`id` = {$planet_id}" : "`id_owner` = {$user_id}", $planet_id);
  }

  /**
   * @param array $planetRowFieldChanges - array of $resourceId => $amount
   * @param int   $planetId
   *
   * // TODO - DEDUPLICATE
   * @see DBStaticUser::db_user_update_resources
   */
  public static function db_planet_update_resources($planetRowFieldChanges, $planetId) {

    $fields = array();
    foreach ($planetRowFieldChanges as $resourceId => $value) {
      $fields[pname_resource_name($resourceId)] = $value;
    }
    if (!empty($fields)) {
      classSupernova::$gc->db->doUpdateRowAdjust(
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_PLANETS,
        array(),
        $fields,
        array(
          'id' => $planetId
        )
      );
    }
  }

  /**
   * @param        $planet_id
   * @param array  $set
   *
   * @return array|bool|mysqli_result|null
   */
  public static function db_planet_update_set_by_id($planet_id, $set) {
    return classSupernova::$gc->cacheOperator->db_upd_record_by_id(LOC_PLANET, $planet_id, $set, array());
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.
}
  }

  /**
   * @param        $planet_id
   * @param array  $adjust
   *
   * @return array|bool|mysqli_result|null
   */
  public static function db_planet_update_adjust_by_id($planet_id, $adjust) {
    return classSupernova::$gc->cacheOperator->db_upd_record_by_id(LOC_PLANET, $planet_id, array(), $adjust);
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.
}
  }

  // TODO - adjust separate

  public static function db_planet_update_by_gspt($ui_galaxy, $ui_system, $ui_planet, $ui_planet_type = PT_ALL, $set, $adjust) {
    if (empty($set) && empty($adjust)) {
      return;
    }

    $where = array(
      'galaxy' => $ui_galaxy,
      'system' => $ui_system,
      'planet' => $ui_planet,
    );
    if (intval($ui_planet_type)) {
      $where['planet_type'] = $ui_planet_type;
    }
    classSupernova::$gc->cacheOperator->db_upd_record_list(
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_PLANET,
      $set,
      $adjust,
      $where
    );
  }

  /**
   * @param int   $ui_parent_id
   * @param array $set
   */
  public static function db_planet_set_by_parent($ui_parent_id, $set) {

    if (!idval($ui_parent_id) || empty($set)) {
      return;
    }

    classSupernova::$gc->cacheOperator->db_upd_record_list(
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_PLANET,
      $set,
      array(),
      array(
        'parent_planet' => $ui_parent_id,
      )
    );
  }

  /**
   * @param       $ui_owner_id
   * @param array $set
   */
  public static function db_planet_set_by_owner($ui_owner_id, $set) {

    if (!idval($ui_owner_id) || empty($set)) {
      return;
    }

    classSupernova::$gc->cacheOperator->db_upd_record_list(
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_PLANET,
      $set,
      array(),
      array(
        'id_owner' => $ui_owner_id
      )
    );
  }


  public static function db_planet_delete_by_id($planet_id) {

    // if(!($planet_id = intval($planet_id))) return false;

    if (!($planet_id = idval($planet_id))) {
      return false;
    }
    classSupernova::$gc->cacheOperator->db_del_record_by_id(LOC_PLANET, $planet_id);
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.
}
    classSupernova::$gc->cacheOperator->db_del_record_list(LOC_UNIT, array(
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.
}
      'unit_location_type' => LOC_PLANET,
      'unit_location_id'   => $planet_id,
    ));

    // Очереди очистятся автоматически по FOREIGN KEY
    return true;
  }

  public static function db_planet_list_delete_by_owner($ui_owner_id) {

    // if(!($si_owner_id = intval($ui_owner_id))) return false;

    if (!($si_owner_id = idval($ui_owner_id))) {
      return false;
    }
    classSupernova::$gc->cacheOperator->db_del_record_list(LOC_PLANET, array('id_owner' => $si_owner_id));
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.
}
    classSupernova::$gc->cacheOperator->db_del_record_list(LOC_UNIT, array(
      'unit_location_type' => LOC_PLANET,
      'unit_player_id'     => $si_owner_id,
    ));

    // Очереди очистятся автоматически по FOREIGN KEY
    return true;
  }


  public static function db_planet_count_by_type($ui_user_id, $ui_planet_type = PT_PLANET) {

    // $si_user_id = intval($ui_user_id);

    $si_user_id = idval($ui_user_id);
    $si_planet_type = intval($ui_planet_type);

    // Лочим запись-родителя - если она есть и еще не залочена
    $record_list = classSupernova::$gc->cacheOperator->db_get_record_list(LOC_PLANET, "`id_owner` = {$si_user_id} AND `planet_type` = {$si_planet_type}");
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.
}

    return is_array($record_list) ? count($record_list) : 0;
    // $planets = doquery("SELECT COUNT(*) AS planet_count FROM {{planets}} WHERE `id_owner` = {$si_user_id} AND `planet_type` = {$si_planet_type}", true);

    // return isset($planets['planet_count']) ? $planets['planet_count'] : 0;

  }

  public static function db_planet_list_resources_by_owner() {
    return classSupernova::$db->doSelect("SELECT `id_owner`, sum(metal) AS metal, sum(crystal) AS crystal, sum(deuterium) AS deuterium FROM `{{planets}}` WHERE id_owner <> 0 /*AND id_owner is not null*/ GROUP BY id_owner;");
  }

}


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

DBStaticPlanet C

Complexity

Size/Duplication

Coupling/Cohesion

Test Coverage

Importance

23 Methods

How to fix Duplicated Code Complexity

Duplicated Code

Complex Class

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

supernova-ws / SuperNova

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

DBStaticPlanet C

Complexity

Size/Duplication

Coupling/Cohesion

Test Coverage

Importance

23 Methods

How to fix Duplicated Code Complexity

Duplicated Code

Complex Class

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Duplication Side-by-Side

Filter issues like