DBStaticPlanet::db_planet_update_set_by_id() - Code Metrics - Inspection of "DBAL-misc-41a51.43: Working on separate DANGER fro..." - supernova-ws/SuperNova - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — work-fleets ( 22b5bc...08ace7 )

by SuperNova.WS

created 2016-08-08 22:43 UTC

DBStaticPlanet::db_planet_update_set_by_id() A

↳ Parent: DBStaticPlanet

Complexity

Conditions	1
Paths	1

Size

Total Lines	3
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	2

Importance

Changes	2
Bugs	0	Features	0

Metric	Value
cc	1
eloc	2
c	2
b	0
f	0
nc	1
nop	2
dl	0
loc	3
rs	10
ccs	0
cts	3
cp	0
crap	2

<?php

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(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.
}
      "`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 = intval($planet_id)) || !($owner_id = intval($owner_id))) return false;

    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 = intval($user_id)) || !($this_moon_id = intval($this_moon_id))) return false;

    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
   *
   * @see DBStaticUser::db_user_update_resources
   * // TODO - DEDUPLICATE
   */
  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 string $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 string $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);
function acceptsInteger($int) { }

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

// Instead of
acceptsInteger($x);

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

  // 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 ( 22b5bc...08ace7 )

DBStaticPlanet::db_planet_update_set_by_id() A

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

supernova-ws / SuperNova

Push — work-fleets ( 22b5bc...08ace7 )

DBStaticPlanet::db_planet_update_set_by_id() A

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