Add search by size

classes/torrentsearch.class.php

   const SPH_BOOL_OR = ' | ';
 
   // Map of sort mode => attribute name for ungrouped torrent page
-  public static $SortOrders = array(
+  public static $SortOrders = [
     'year' => 'year',
     'time' => 'id',
     'size' => 'size',
     'leechers' => 'leechers',
     'snatched' => 'snatched',
     'cataloguenumber' => 'cataloguenumber',
-    'random' => 1);
+    'random' => 1
+  ];
 
   // Map of sort mode => attribute name for grouped torrent page
-  private static $SortOrdersGrouped = array(
+  private static $SortOrdersGrouped = [
     'year' => 'year',
     'time' => 'id',
     'size' => 'maxsize',
     'leechers' => 'sumleechers',
     'snatched' => 'sumsnatched',
     'cataloguenumber' => 'cataloguenumber',
-    'random' => 1);
+    'random' => 1
+  ];
 
   // Map of sort mode => aggregate expression required for some grouped sort orders
-  private static $AggregateExp = array(
+  private static $AggregateExp = [
     'size' => 'MAX(size) AS maxsize',
     'seeders' => 'SUM(seeders) AS sumseeders',
     'leechers' => 'SUM(leechers) AS sumleechers',
-    'snatched' => 'SUM(snatched) AS sumsnatched');
+    'snatched' => 'SUM(snatched) AS sumsnatched'
+  ];
 
   // Map of attribute name => global variable name with list of values that can be used for filtering
-  private static $Attributes = array(
+  private static $Attributes = [
     'filter_cat' => false,
     'releasetype' => 'ReleaseTypes',
     'freetorrent' => false,
     'censored' => false,
-    'year' => false);
+    'size_unit' => false,
+    'year' => false
+  ];
 
   // List of fields that can be used for fulltext searches
-  private static $Fields = array(
+  private static $Fields = [
     'artistname' => 1,
     'audioformat' => 1,
     'cataloguenumber' => 1,
     'studio' => 1,
     'subber' => 1,
     'subbing' => 1,
-    'taglist' => 1);
+    'taglist' => 1
+  ];
 
   // List of torrent-specific fields that can be used for filtering
-  private static $TorrentFields = array(
+  private static $TorrentFields = [
     'description' => 1,
     'encoding' => 1,
     'censored' => 1,
     'language' => 1,
     'filelist' => 1,
     'format' => 1,
-    'media' => 1);
+    'media' => 1
+  ];
 
   // Some form field names don't match the ones in the index
-  private static $FormsToFields = array(
+  private static $FormsToFields = [
     'searchstr' => '(groupname,groupnamerj,groupnamejp,artistname,studio,series,dlsiteid,cataloguenumber,yearfulltext)',
-    'advgroupname' => '(groupname,groupnamerj,groupnamejp)');
+    'advgroupname' => '(groupname,groupnamerj,groupnamejp)'
+  ];
 
   // Specify the operator type to use for fields. Empty key sets the default
-  private static $FieldOperators = array(
+  private static $FieldOperators = [
     '' => self::SPH_BOOL_AND,
     'encoding' => self::SPH_BOOL_OR,
     'format' => self::SPH_BOOL_OR,
-    'media' => self::SPH_BOOL_OR);
+    'media' => self::SPH_BOOL_OR
+  ];
 
   // Specify the separator character to use for fields. Empty key sets the default
-  private static $FieldSeparators = array(
+  private static $FieldSeparators = [
     '' => ' ',
     'encoding' => '|',
     'format' => '|',
     'media' => '|',
-    'taglist' => ',');
+    'taglist' => ','
+  ];
 
   // Primary SphinxqlQuery object used to get group IDs or torrent IDs for ungrouped searches
   private $SphQL;
   // Number of results
   private $NumResults = 0;
   // Array with info from all matching torrent groups
-  private $Groups = array();
+  private $Groups = [];
   // Whether any filters were used
   private $Filtered = false;
   // Whether the random sort order is selected
    *     'operator' => self::SPH_BOOL_AND | self::SPH_BOOL_OR
    * ]], ...
    */
-  private $Terms = array();
+  private $Terms = [];
   // Unprocessed search terms for retrieval
-  private $RawTerms = array();
+  private $RawTerms = [];
   // Storage for used torrent-specific attribute filters
   // ['Field name' => 'Search expression', ...]
-  private $UsedTorrentAttrs = array();
+  private $UsedTorrentAttrs = [];
   // Storage for used torrent-specific fulltext fields
   // ['Field name' => 'Search expression', ...]
-  private $UsedTorrentFields = array();
+  private $UsedTorrentFields = [];
 
   /**
    * Initialize and configure a TorrentSearch object
   public function __construct($GroupResults, $OrderBy, $OrderWay, $Page, $PageSize) {
     if ($GroupResults && !isset(self::$SortOrdersGrouped[$OrderBy])
         || !$GroupResults && !isset(self::$SortOrders[$OrderBy])
-        || !in_array($OrderWay, array('asc', 'desc'))
+        || !in_array($OrderWay, ['asc', 'desc'])
     ) {
       global $Debug;
       $ErrMsg = "TorrentSearch constructor arguments:\n" . print_r(func_get_args(), true);
    * @param array $Terms Array containing all search terms (e.g. $_GET)
    * @return array List of matching group IDs with torrent ID as key for ungrouped results
    */
-  public function query($Terms = array()) {
+  public function query($Terms = []) {
     $this->process_search_terms($Terms);
     $this->build_query();
     $this->run_query();
       if (isset(self::$FormsToFields[$Field])) {
         $Field = self::$FormsToFields[$Field];
       }
-      $QueryParts = array('include' => array(), 'exclude' => array());
+      $QueryParts = ['include' => [], 'exclude' => []];
       if (!empty($Words['include'])) {
         foreach ($Words['include'] as $Word) {
           $QueryParts['include'][] = Sphinxql::sph_escape_string($Word);
       }
       $this->RawTerms[$Key] = $Term;
     }
-    $this->post_process_fields();
+    $this->post_process();
   }
 
   /**
    * @param mixed $Value The filter's condition for a match
    */
   private function process_attribute($Attribute, $Value) {
-    if ($Value === '') {
-      return;
-    }
-    switch ($Attribute) {
-      case 'year':
-        if (!$this->search_year($Value)) {
-          return;
-        }
-        break;
-
-      case 'freetorrent':
-        if ($Value == 3) {
-          $this->SphQL->where('freetorrent', 0, true);
-          $this->UsedTorrentAttrs['freetorrent'] = 3;
-        } elseif ($Value >= 0 && $Value < 3) {
-          $this->SphQL->where('freetorrent', $Value);
-          $this->UsedTorrentAttrs[$Attribute] = $Value;
+    if ($Value === '') { return; }
+
+    if ($Attribute === 'year') {
+      $this->search_year($Value);
+    } elseif ($Attribute === 'size_unit') {
+      // for the record, size_unit must appear in the GET parameters after size_min and size_max for this to work. Sorry.
+      if (is_numeric($this->RawTerms['size_min']) || is_numeric($this->RawTerms['size_max']))  {
+        $this->SphQL->where_between('size', [intval(($this->RawTerms['size_min'] ?? 0)*(1024**$Value)), intval(min(PHP_INT_MAX, ($this->RawTerms['size_max'] ?? INF)*(1024**$Value)))]);
+      }
+    } elseif ($Attribute === 'freetorrent') {
+      if ($Value == 3) {
+        $this->SphQL->where('freetorrent', 0, true);
+        $this->UsedTorrentAttrs['freetorrent'] = 3;
+      } elseif ($Value >= 0 && $Value < 3) {
+        $this->SphQL->where('freetorrent', $Value);
+        $this->UsedTorrentAttrs[$Attribute] = $Value;
+      }
+    } elseif ($Attribute === 'filter_cat') {
+      if (!is_array($Value)) {
+        $Value = array_fill_keys(explode('|', $Value), 1);
+      }
+      $CategoryFilter = [];
+      foreach (array_keys($Value) as $Category) {
+        if (is_number($Category)) {
+          $CategoryFilter[] = $Category;
         } else {
-          return;
-        }
-        break;
-
-      case 'filter_cat':
-        if (!is_array($Value)) {
-          $Value = array_fill_keys(explode('|', $Value), 1);
-        }
-        $CategoryFilter = array();
-        foreach (array_keys($Value) as $Category) {
-          if (is_number($Category)) {
-            $CategoryFilter[] = $Category;
-          } else {
-            global $Categories;
-            $ValidValues = array_map('strtolower', $Categories);
-            if (($CategoryID = array_search(strtolower($Category), $ValidValues)) !== false) {
-              $CategoryFilter[] = $CategoryID + 1;
-            }
+          global $Categories;
+          $ValidValues = array_map('strtolower', $Categories);
+          if (($CategoryID = array_search(strtolower($Category), $ValidValues)) !== false) {
+            $CategoryFilter[] = $CategoryID + 1;
           }
         }
-        if (empty($CategoryFilter)) {
-          $CategoryFilter = 0;
-        }
-        $this->SphQL->where('categoryid', $CategoryFilter);
-        break;
-
-      default:
-        if (!is_number($Value) && self::$Attributes[$Attribute] !== false) {
-          // Check if the submitted value can be converted to a valid one
-          $ValidValuesVarname = self::$Attributes[$Attribute];
-          global $$ValidValuesVarname;
-          $ValidValues = array_map('strtolower', $$ValidValuesVarname);
-          if (($Value = array_search(strtolower($Value), $ValidValues)) === false) {
-            // Force the query to return 0 results if value is still invalid
-            $Value = max(array_keys($ValidValues)) + 1;
-          }
+      }
+      $this->SphQL->where('categoryid', ($CategoryFilter ?? 0));
+    } else {
+      if (!is_number($Value) && self::$Attributes[$Attribute] !== false) {
+        // Check if the submitted value can be converted to a valid one
+        $ValidValuesVarname = self::$Attributes[$Attribute];
+        global $$ValidValuesVarname;
+        $ValidValues = array_map('strtolower', $$ValidValuesVarname);
+        if (($Value = array_search(strtolower($Value), $ValidValues)) === false) {
+          // Force the query to return 0 results if value is still invalid
+          $Value = max(array_keys($ValidValues)) + 1;
         }
-        $this->SphQL->where($Attribute, $Value);
-        $this->UsedTorrentAttrs[$Attribute] = $Value;
-        break;
+      }
+      $this->SphQL->where($Attribute, $Value);
+      $this->UsedTorrentAttrs[$Attribute] = $Value;
     }
+
     $this->Filtered = true;
   }
 
   /**
    * Some fields may require post-processing
    */
-  private function post_process_fields() {
+  private function post_process() {
     if (isset($this->Terms['taglist'])) {
       // Replace bad tags with tag aliases
       $this->Terms['taglist'] = Tags::remove_aliases($this->Terms['taglist']);
       if (isset($this->Terms['taglist']['include'])) {
         $AllTags = $this->Terms['taglist']['include'];
       } else {
-        $AllTags = array();
+        $AllTags = [];
       }
       if (isset($this->Terms['taglist']['exclude'])) {
         $AllTags = array_merge($AllTags, $this->Terms['taglist']['exclude']);
         $this->SphQL->where_gt('year', $Years[0], true);
       } elseif (is_number($Years[0]) && is_number($Years[1])) {
         // Range: 2005 - 2009
-        $this->SphQL->where_between('year', array(min($Years), max($Years)));
+        $this->SphQL->where_between('year', [min($Years), max($Years)]);
       } else {
         // Invalid input
         return false;
    * were used to get primary results and they are grouped
    */
   private function filter_torrents_sph() {
-    $AllTorrents = array();
+    $AllTorrents = [];
     foreach ($this->Groups as $GroupID => $Group) {
       if (!empty($Group['Torrents'])) {
         $AllTorrents += array_fill_keys(array_keys($Group['Torrents']), $GroupID);

sections/torrents/browse.php

   } else {
     $NewWay = $DefaultWay;
   }
-  return "torrents.php?order_way=$NewWay&order_by=$SortKey&".Format::get_url(array('order_way', 'order_by'));
+  return "torrents.php?order_way=$NewWay&order_by=$SortKey&".Format::get_url(['order_way', 'order_by']);
 }
 
 if (!empty($_GET['searchstr']) || !empty($_GET['groupname'])) {
 
 // Setting default search options
 if (!empty($_GET['setdefault'])) {
-  $UnsetList = array('page', 'setdefault');
+  $UnsetList = ['page', 'setdefault'];
   $UnsetRegexp = '/(&|^)('.implode('|', $UnsetList).')=.*?(&|$)/i';
 
   $DB->query("
   if (!empty($SiteOptions)) {
     $SiteOptions = unserialize($SiteOptions);
   } else {
-    $SiteOptions = array();
+    $SiteOptions = [];
   }
   $SiteOptions['DefaultSearch'] = preg_replace($UnsetRegexp, '', $_SERVER['QUERY_STRING']);
   $DB->query("
     SET SiteOptions = '".db_string(serialize($SiteOptions))."'
     WHERE UserID = '".db_string($LoggedUser['ID'])."'");
   $Cache->begin_transaction("user_info_heavy_$UserID");
-  $Cache->update_row(false, array('DefaultSearch' => $SiteOptions['DefaultSearch']));
+  $Cache->update_row(false, ['DefaultSearch' => $SiteOptions['DefaultSearch']]);
   $Cache->commit_transaction(0);
 
 // Clearing default search options
     SET SiteOptions = '".db_string(serialize($SiteOptions))."'
     WHERE UserID = '".db_string($LoggedUser['ID'])."'");
   $Cache->begin_transaction("user_info_heavy_$UserID");
-  $Cache->update_row(false, array('DefaultSearch' => ''));
+  $Cache->update_row(false, ['DefaultSearch' => '']);
   $Cache->commit_transaction(0);
 
 // Use default search options
             <input type="search" spellcheck="false" size="65" name="subber" class="inputtext smaller fti_advanced" placeholder="Translation Group" value="<?Format::form('subber')?>" />
           </td>
         </tr>
+        <tr id="size" class="ftr_advanced<?=$HideAdvanced?>">
+          <td class="label">Size:</td>
+          <td class="ft_size">
+            <input type="size_min" spellcheck="false" size="6" name="size_min" class="inputtext smaller fti_advanced" placeholder="Min" value="<?Format::form('size_min')?>" /> -
+            <input type="size_max" spellcheck="false" size="6" name="size_max" class="inputtext smaller fti_advanced" placeholder="Max" value="<?Format::form('size_max')?>" />
+            <select name="size_unit" class="ft_size fti_advanced">
+              <option value="">Unit</option>
+              <option value="0"<?Format::selected('size_unit', 0)?>>B</option>
+              <option value="1"<?Format::selected('size_unit', 1)?>>KiB</option>
+              <option value="2"<?Format::selected('size_unit', 2)?>>MiB</option>
+              <option value="3"<?Format::selected('size_unit', 3)?>>GiB</option>
+              <option value="4"<?Format::selected('size_unit', 4)?>>TiB</option>
+            </select>
+          </td>
+        </tr>
         <tr id="misc" class="ftr_advanced<?=$HideAdvanced?>">
           <td class="label">Misc:</td>
           <td class="nobr ft_misc">
     }
   } else {
     $TorrentID = $Key;
-    $Torrents = array($TorrentID => $GroupInfo['Torrents'][$TorrentID]);
+    $Torrents = [$TorrentID => $GroupInfo['Torrents'][$TorrentID]];
   }
 
   $TorrentTags = new Tags($GroupInfo['TagList']);