DBStaticPlanet::db_planet_by_vector() - 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::db_planet_by_vector() B

↳ Parent: DBStaticPlanet

Complexity

Conditions	7
Paths	64

Size

Total Lines	10
Code Lines	8

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	56

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	7
eloc	8
c	1
b	0
f	0
nc	64
nop	4
dl	0
loc	10
ccs	0
cts	9
cp	0
crap	56
rs	8.2222

<?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::db_planet_by_vector() B

Complexity

Size

Duplication

Code Coverage

Importance

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

1			<?php
2
3			namespace DBStatic;
4
5			use classSupernova;
6			use mysqli_result;
7			use Vector\Vector;
8
9			class DBStaticPlanet {
10
11			/**
12			* @param array $rowUser
13			* @param array $rowPlanet
14			*
15			* @return array
16			*/
17			public static function getResources($rowUser, $rowPlanet) {
18			$planetResources = array();
19
20			$sn_group_resources = sn_get_groups('resources_loot');
21			foreach ($sn_group_resources as $resource_id) {
22			$planetResources[$resource_id] = floor(mrc_get_level($rowUser, $rowPlanet, $resource_id));
23			}
24
25			return $planetResources;
26			}
27
28
29			public static function db_planets_purge() {
30			classSupernova::$db->doDeleteSql(
31			'DELETE FROM `{{planets}}`
32			WHERE
33			`id_owner` NOT IN (
34			SELECT `id` FROM `{{users}}`
35			);'
36			);
37			}
38
39
40			/**

supernova-ws / SuperNova

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

DBStaticPlanet::db_planet_by_vector() B

Complexity

Size

Duplication

Code Coverage

Importance

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