1:   2:   3:   4:   5:   6:   7:   8:   9:  10:  11:  12:  13:  14:  15:  16:  17:  18:  19:  20:  21:  22:  23:  24:  25:  26:  27:  28:  29:  30:  31:  32:  33:  34:  35:  36:  37:  38:  39:  40:  41:  42:  43:  44:  45:  46:  47:  48:  49:  50:  51:  52:  53:  54:  55:  56:  57:  58:  59:  60:  61:  62:  63:  64:  65:  66:  67:  68:  69:  70:  71:  72:  73:  74:  75:  76:  77:  78:  79:  80:  81:  82:  83:  84:  85:  86:  87:  88:  89:  90:  91:  92:  93:  94:  95:  96:  97:  98:  99: 100: 101: 102: 103: 104: 105: 106: 107: 108: 109: 110: 111: 112: 113: 114: 115: 116: 117: 118: 119: 120: 121: 122: 123: 124: 125: 126: 127: 128: 129: 130: 131: 132: 133: 134: 135: 136: 137: 138: 139: 140: 141: 142: 143: 144: 145: 146: 147: 148: 149: 150: 151: 152: 153: 154: 155: 156: 157: 158: 159: 160: 161: 162: 163: 164: 165: 166: 167: 168: 169: 170: 171: 172: 173: 174: 175: 176: 177: 178: 179: 180: 181: 182: 183: 184: 185: 186: 187: 188: 189: 190: 191: 192: 193: 194: 195: 196: 197: 198: 199: 200: 201: 202: 203: 204: 205: 206: 207: 208: 209: 210: 211: 212: 213: 214: 215: 216: 217: 218: 219: 220: 221: 222: 223: 224: 225: 226: 227: 228: 229: 230: 231: 232: 233: 234: 235: 236: 237: 238: 239: 240: 241: 242: 243: 244: 245: 246: 247: 248: 249: 250: 251: 252: 253: 254: 255: 256: 257: 258: 259: 260: 261: 262: 263: 264: 265: 266: 267: 268: 269: 270: 271: 272: 273: 274: 275: 276: 277: 278: 279: 280: 281: 282: 283: 284: 285: 286: 287: 288: 289: 290: 291: 292: 293: 294: 295: 296: 297: 298: 299: 300: 301: 302: 303: 304: 305: 306: 307: 308: 309: 310: 311: 312: 313: 314: 315: 316: 317: 318: 319: 320: 321: 322: 323: 324: 325: 326: 327: 328: 329: 330: 331: 332: 333: 334: 335: 336: 337: 338: 339: 340: 341: 342: 343: 344: 345: 346: 347: 348: 349: 350: 351: 352: 353: 354: 355: 356: 357: 358: 359: 360: 361: 362: 363: 364: 365: 366: 367: 368: 369: 370: 371: 372: 373: 374: 375: 376: 377: 378: 379: 380: 381: 382: 383: 384: 385: 386: 387: 388: 389: 390: 391: 392: 393: 394: 395: 396: 397: 398: 399: 400: 401: 402: 403: 404: 405: 406: 407: 408: 409: 410: 411: 412: 413: 

<?php

namespace DispatchModule;

/**
 * SearchParser is responsible for parsing form query (from user) and running services for needed tools
 * - it also contains support functions for connecting search form with tools
 */
class SearchParser extends \DispatchModule\BaseParser {

    /**
     * DB Temporary directory 
     *  - is used when the DB searching is off.
     *  - stores resultSet generated from other tools
     * @var string
     */
    public $dbTempDirectory;

    /**
     * DB Temporary file 
     *  - is used when the DB searching is off.
     *  - stores resultSet generated from other tools
     * @var string
     */
    public $dbTempFile;

    /**
     * Constructor used to save container
     *
     * @param \Nette\DI\Container $container
     */
    public function __construct(\Nette\DI\Container $container) {
        parent::__construct($container);
        $this->dbTempFile = (session_id()) ? session_id() : (time() . rand());
        $this->dbTempDirectory = TEMP_PATH . DIRECTORY_SEPARATOR . "dbTemp" . DIRECTORY_SEPARATOR;
    }

    /**
     * Generate a file name to save results
     * @param string $fileId identifier of the search
     * @return string file name
     */
    public function getFileName($fileId = null) {
        if (isset($fileId) && !empty($fileId)) {
            return $this->dbTempFile . "." . md5($fileId);
        }
        return $this->dbTempFile;
    }

    /**
     * Generate a file path to save results
     * @param string $fileName file name
     * @return string file path
     */
    public function getFilePath($fileName = null) {
        $filePath = $this->dbTempDirectory;
        if (isset($fileName) && !empty($fileName)) {
            $filePath = $filePath . $fileName;
        } else {
            $filePath = $filePath . $this->getFileName();
        }
        return $filePath . ".txt";
    }

    /**
     * Main method parses form and initializes tool classes
     *
     * @param \Nette\Application\UI\Form $form
     * @return \DispatchModule\ResultSet result of the search
     */
    public function parseForm(\BaseModule\Form $form) {
        $formValues = $form->values;

        if (!isset($formValues['offset']) || $formValues['offset'] == 0) {
            $formValues['search_id'] = sha1(microtime() . PHP_EOL . serialize($formValues) . PHP_EOL . mt_rand());
        }
        $fileName = $this->getFileName($formValues['search_id']);

        // list all active available tools with its prefixes
        $activeTools = $this->getActiveTools($formValues);
        foreach ($activeTools as $tool) {
            $tool->fileName = $fileName;
            $tool->completeData = $this->container->httpRequest->post;
        }

        // process all submitted values
        foreach ($formValues as $inputName => $value) {
            // remove input name prefix
            list($name, $prefix) = $this->getAttributeProperties($inputName);

            // non-empty prefixes for active tools are added
            if (array_key_exists($prefix, $activeTools)) {
//file_put_contents('logDbTool.txt', $prefix . ' -> ' . $name . ' = ' . $value, FILE_APPEND);
                $activeTools[$prefix]->addCriteria($name, $value);
//file_put_contents('logDbTool.txt', '  //' . ($activeTools[$prefix] ? ' true' : ' false') . ' ok' . PHP_EOL, FILE_APPEND);
            }
        }

        $usedTools = array();
        foreach ($activeTools as $key => $value) {
            if ($value->used()) {
                $usedTools[$key] = $value;
            }
        }

        // special case for search speed-up: only DB search performed => first sequence is loaded fully, rest only simple and additionally searched by ajax
        if ($this->isActiveDbOnly($usedTools) /*&& isset($formValues['offset']) && isset($formValues['limit'])*/ ) {
            if (!isset($formValues['offset'])) {
                $formValues['offset'] = 0;
            }
            if (!isset($formValues['limit'])) {
                $formValues['limit'] = 1;
            }
            if (isset($formValues['db_perform_full']) && $formValues['db_perform_full'] == 'true') {
                $usedTools['db']->addCriteria('offset', $formValues['offset']);
                $usedTools['db']->addCriteria('limit', $formValues['limit']);
                $resultSet = $usedTools['db']->execute();
            } else {
                $resultSet = $this->performSimplesearch($usedTools['db'], $formValues);
                if ($formValues['offset'] == 0) {
                    $resultSet->setTotalCount($this->getResultCount($formValues));
                }
            }
        } else {
            // run all tools and merge results
            $resultSet = new \DispatchModule\ResultSet;
            foreach ($usedTools as $prefix => $tool) {
                // active tools are executed
                if (!\Nette\Utils\Strings::endsWith($prefix, 'db')) {
                    $resultSet->add($tool->execute());
                }
            }
            if ($this->isActiveDb($usedTools)) {
                $data = $resultSet->getData();
                $resultSet = new ResultSet();
                foreach ($data as $seq) {
                    if ($usedTools['db']->getCount($seq->accession, $seq->startPosition, $seq->stopPosition) > 0) {
                        $resultSet->addSequence($seq);
                    }
                }
            }
            $resultSet->sortScores();
            $resultSet->sortByScore();

            // run dbtool to fill results with additional data from database (in case using external tool without DB tool)
            if (!$this->isActiveDbOnly($usedTools)) {
                $data = $resultSet->getData();
                if (empty($data)) {
                    $resultSet = new ResultSet();
                } else {
                    $size = $this->save($resultSet, $fileName);
                    $resultSet = new ResultSet();
                    $resultSet->setTotalCount($size);
                }
                $resultSet->add($this->load($fileName));
                $data = $resultSet->getData();
                if (!empty($data)) {
                    $accessions = array();
                    foreach ($resultSet->getData() as $seq) {
                        $accessions[] = $seq->accession;
                    }
                    $usedTools['db']->addCriteria("accession", $accessions);
                    // return only 1 record for each accession; actually inactive
                    $usedTools['db']->addCriteria("aggregateByAccession", true);
                    $resultSet->leftJoin($usedTools['db']->execute());
                }
            }
        }

        $resultSet->id = $formValues['search_id'];
        return $resultSet;
    }

    /**
     * Saves result set
     *
     * @param \DispatchModule\ResultSet $result Saves the result set into the temporary file
     * @param string $name File name
     * @return int number of saved results
     */
    public function saveLog(\DispatchModule\ResultSet $result, $name) {
        $numberOfResults = 0;
        $file = new \BaseModule\Models\FileModel($name);
//        $file->removeContent();
        /* @var $seq \DispatchModule\Sequence */
        foreach ($result->getData() as $seq) {
            $file->appendContent(serialize($seq) . "\n");
            $numberOfResults++;
        }

        return $numberOfResults;
    }

    /**
     * Performs simple search - firtst sequence is loaded completely, but for the
     * rest only basic information is loaded
     *
     * @param \DispatchModule\SearchTools\DbTool $dbTool DBTool instance
     * @param array $formValues serach criterias (from the form)
     * @return \DispatchModule\ResultSet resulting sequences (only first complete)
     */
    protected function performSimplesearch($dbTool, $formValues) {
        $resultSet = new \DispatchModule\ResultSet;
        $dbTool->addCriteria('offset', $formValues['offset']);
        $dbTool->addCriteria('limit', 1);
        $resultSet->add($dbTool->execute());
        $dbTool->addCriteria('offset', $formValues['offset'] + 1);
        $dbTool->addCriteria('limit', $formValues['limit'] - 1);
        $dbTool->setSimpleSearch(true);
        $resultSet->add($dbTool->execute());
        return $resultSet;
    }

    /**
     * Get active tools based on the params of the search
     *
     * @param array $formValues search criteria (from the form)
     * @return array currently active tools (prefixes)
     */
    protected function getActiveTools($formValues) {
        $tools = $this->getTools();

        $dbTools = array();
        foreach ($tools as $name => $tool) {
            if (\Nette\Utils\Strings::endsWith($name, 'db')) {
                $dbTools[$name] = $tool;
            }
        }
        $activeTools = array();
        $activeTools['db'] = new \DispatchModule\Tools\DbTool($this->container, $dbTools);
        foreach ($tools as $name => $tool) {
            // active tools are executed
            if (isset($formValues[$name]) && $formValues[$name]) {
                if (\Nette\Utils\Strings::endsWith($name, 'db')) {
                    $activeTools[$name] = $activeTools['db'];
                } else {
                    $activeTools[$name] = $tool;
                }
            }
        }
        return $activeTools;
    }

    /**
     * Check whether there is any active database tool based on the params of the search
     * @param array currently active tools (prefixes)
     * @return bool TRUE if any database tool is active
     */
    protected function isActiveDb($activeTools) {
        foreach ($activeTools as $name => $tool) {
            if ($name !== 'db' && \Nette\Utils\Strings::endsWith($name, 'db')) {
                return true;
            }
        }
        return false;
    }

    /**
     * Check whether database tools are the only active based on the params of the search
     * @param array currently active tools (prefixes)
     * @return bool TRUE if no non-database tool is active
     */
    protected function isActiveDbOnly($activeTools) {
        foreach ($activeTools as $name => $tool) {
            if (!\Nette\Utils\Strings::endsWith($name, 'db')) {
                return false;
            }
        }
        return array_key_exists('db', $activeTools);
    }

    /**
     * Returns organism names containing $organismName
     * @param type $organismName
     */
    public function getNameValues($organismName) {
        //$tools = $this->getTools();
        /* @var $dbTool \DispatchModule\Tools\DbTool */
        //$dbTool = $tools['db'];
        $dbTool = new \DispatchModule\Tools\DbTool($this->container);
        return $dbTool->getNameValues($organismName);
    }

    /**
     * Gets resultset size for specific DbTool query
     *
     * @param array $data data for DbTool
     * @return int number of results
     */
    public function getResultCount($data) {
        $storage = new \Nette\Caching\Storages\FileStorage('../temp');
        $cache = new \Nette\Caching\Cache($storage);
        $uid = 'countResult' . md5(serialize($data));
        $result = null;
        if ($result === NULL) {
            // list all active available tools with its prefixes
            $activeTools = $this->getActiveTools($data);

            if (array_key_exists('db', $activeTools)) {
                $activeTools['db']->completeData = $this->container->httpRequest->post;
                foreach ($data as $inputName => $value) {
                    // remove input name prefix
                    list($name, $prefix) = $this->getAttributeProperties($inputName);
                    if (array_key_exists($prefix, $activeTools)) {
                        $activeTools[$prefix]->addCriteria($name, $value);
                    }
                }
                // perform query
                $result = $activeTools['db']->getCount();
            } else {
                $result = 0;
            }
            $cache->save($uid, $result, array(
                \Nette\Caching\Cache::EXPIRE => LONG_CACHE_TIME, // month
            ));
        }
        return $result;
    }

    /**
     * Extract name and prefix from input name
     *
     * @param string $inputName input name (with prefix)
     * @return array array with two elements - name and prefix
     */
    protected function getAttributeProperties($inputName) {
        $name = \Nette\Utils\Strings::substring($inputName, strpos($inputName, '_') + 1);
        $prefix = \Nette\Utils\Strings::substring($inputName, 0, strpos($inputName, '_'));
        /*if (\Nette\Utils\Strings::endsWith($prefix, 'db')) {
            $prefix = 'db';
        }*/
        return array($name, $prefix);
    }

    /**
     * Saves result set
     *
     * @param \DispatchModule\ResultSet $result Saves the result set into the temporary file
     * @param string $fileName name of the temporary file
     * @return int number of saved results
     */
    public function save(\DispatchModule\ResultSet $result, $fileName = null) {
        $fileName = $this->getFilePath($fileName);
        $numberOfResults = 0;
        $file = new \BaseModule\Models\FileModel($fileName);
        $file->removeContent();
        /* @var $seq \DispatchModule\Sequence */
        foreach ($result->getData() as $seq) {
            $file->appendContent(serialize($seq) . "\n");
            $numberOfResults++;
        }

        return $numberOfResults;
    }

    /**
     * Load sequences from the temporary file
     * @param string $fileName name of the temporary file
     * @return \DispatchModule\ResultSet Result set
     */
    public function load($fileName = null) {
        return $this->getResultSet($this->container->httpRequest->getPost("limit"), $fileName);
    }

    /**
     * Converts line (separated by ";") into sequence
     * @param string $line Line that will be converted
     * @return \DispatchModule\Sequence converted sequence
     */
    public function convertLineIntoSeq($line) {
        $seq = unserialize($line);
        return $seq;
    }

    /**
     * Gets result set of sequences
     * @param int $totalSeq maximal number of sequences
     * @param string $fileName name of the file with results
     * @return \DispatchModule\ResultSet Result set
     */
    public function getResultSet($totalSeq, $fileName = null) {
        $fileName = $this->getFilePath($fileName);
        $i = 0;
        $resultSet = new \DispatchModule\ResultSet();
        $otherSequences = new \BaseModule\Models\FileModel($fileName . "b");
        if (file_exists($fileName)) {
            $handle = fopen($fileName, "r");

            while (($line = fgets($handle)) !== false) {
                if ($i < $totalSeq) {
                    $resultSet->addSequence($this->convertLineIntoSeq($line));
                } else {
                    $rename = true;
                    $otherSequences->appendContent($line);
                }
                $i++;
            }
            fclose($handle);
            //deletes older temp file
            if (isset($rename) && $rename) {
                rename($fileName . "b", $fileName);
            } else {
                // less sequences than $totalSeq were loaded
                $temp = new \BaseModule\Models\FileModel($fileName);
                $temp->removeContent();
            }
        }
        return $resultSet;
    }

}