xNightR00T File Manager

<?php

namespace Issue\Db;

use Deployment\IdentityApplicationsAwareInterface;
use Deployment\IdentityFilterException;
use Deployment\IdentityFilterInterface;
use Zend\Db\Sql\Predicate\Predicate;
use Zend\Db\Sql\Expression;
use Audit\Container;
use Zend\Json\Json;
use Audit\AuditTypeInterface;
use Application\Module;
use ZendServer\Log\Log,
    ZendServer\Set,
    Zend\Db\TableGateway\TableGateway,
    Configuration\MapperAbstract,
    Zend\Db\Sql\Select,
    Zend\Db\Sql\Predicate\PredicateSet;
use Issue\Container as IssueContainer;
use Zend\Db\Adapter\Platform\Mysql as MysqlPlatform;
use ZendServer\Exception;
use Zend\Db\Sql\Where;
use MonitorUi\Wrapper;

class Mapper extends MapperAbstract implements IdentityApplicationsAwareInterface
{
    /**
     * @var Wrapper
     */
    private $wrapper;
    private $orderTranslated = array(
        'name' => 'issues.rule_name',
        'date' => 'last_timestamp',
        'severity' => 'events.severity',
        'id' => 'issues.cluster_issue_id',
        'repeats' => 'repeats',
    );

    /**
     * @var IdentityFilterInterface
     */
    private $identityFilter;
    
    /**
     * @var \JobQueue\Db\Mapper
     */
    private $jobQueueMapper;
    
    /**
     * @param \JobQueue\Db\Mapper $mapper 
     * @return  
     */
    public function setJobQueueMapper($mapper) {
        $this->jobQueueMapper = $mapper;
    }
    
    /**
     * @return \JobQueue\Db\Mapper
     */
    public function getJobQueueMapper() {
        return $this->jobQueueMapper;
    }

    /**
     * @param IdentityFilterInterface $filter
     */
    public function setIdentityFilter(IdentityFilterInterface $filter)
    {
        $this->identityFilter = $filter;
    }

    public function getRequestSummary($requestUid)
    {

    }

    /**
     *
     * @param array $issueIds
     * @throws Exception
     */
    public function getIssuesLastEventGroupData(array $issueIds = array())
    {
        Log::debug(__FILE__);

        $select = new \Zend\Db\Sql\Select();
        $select->from($this->getTableGateway()->getTable());
        $select->columns(array(
            'events.cluster_issue_id'
            )
        );
        $select->join("issues", "issues.cluster_issue_id = events.cluster_issue_id",
            array(
            "event_id",
            'tracer_dump_file'
            ), Select::JOIN_LEFT);

        $select->order("events.event_id DESC");
        $select->group('issues.cluster_issue_id');

        $result = $this->selectWith($select);

        return $result;
    }

    public function applyCommonColumns($select, $isJobRelatedIssues = false)
    {
        $columns = array(
            'cluster_issue_id' => new \Zend\Db\Sql\Expression('events.cluster_issue_id'),
            'rule_name' => new \Zend\Db\Sql\Expression('issues.rule_name'),
            'event_type' => new \Zend\Db\Sql\Expression('issues.event_type'),
            'agg_hint' => new \Zend\Db\Sql\Expression('issues.agg_hint'),
            'full_url' => new \Zend\Db\Sql\Expression('issues.full_url'),
            'status' => new \Zend\Db\Sql\Expression('issues.status'),
            'file_name' => new \Zend\Db\Sql\Expression('issues.file_name'),
            'function_name' => new \Zend\Db\Sql\Expression('issues.function_name'),
            'line' => new \Zend\Db\Sql\Expression('issues.line'),
            'severity' => new \Zend\Db\Sql\Expression('issues.severity'),
            'app_id' => new \Zend\Db\Sql\Expression('events.app_id'),
            'rule_id' => new \Zend\Db\Sql\Expression('matched_rules.id'),
            'last_timestamp' => new \Zend\Db\Sql\Expression('max(events.last_timestamp)'),
            'first_timestamp' => new \Zend\Db\Sql\Expression('min(events.first_timestamp)'),
            'repeats' => new \Zend\Db\Sql\Expression('sum(events.repeats)'),
            'max_event_id' => new \Zend\Db\Sql\Expression('max(events.event_id)'),
            'tracer_dump_file' => new \Zend\Db\Sql\Expression('max(events.tracer_dump_file)'));

        if ($isJobRelatedIssues) {
            $columns['job_id'] = new \Zend\Db\Sql\Expression('events_jobs.job_id');
        }
        $select->columns($columns);
        $select->group('issues.cluster_issue_id');
        return $select;
    }

    private function getOrderTranslated($orderby)
    {

        if (isset($this->orderTranslated [$orderby])) {
            return $this->orderTranslated [$orderby];
        } else {
            throw \Exception("Unknown order by - $orderby");
        }
    }

    /**
     * get array like ['<trace file>' => '<issue ID>', ...]
     * @param array $traceFiles 
     * @return  
     */
    public function getIssueIdsByTraceFiles(array $traceFiles)
    {
        if (empty($traceFiles)) return array();

        $resultArray                = array();
        $numOfTraceFilesInIteration = 256;

        // execute the query for maximum `$numOfTraceFilesInIteration` trace
        // files each time to avoid very long queries
        for ($i = 0; $i < ceil(count($traceFiles) / $numOfTraceFilesInIteration); $i++) {
            // create the query
            $select = new \Zend\Db\Sql\Select();
            $select->from($this->getTableGateway()->getTable());

            // add condition
            $condition             = new Predicate;
            // take a specific chunk of trace files
            $partialTraceFilesList = array_slice($traceFiles, $i * $numOfTraceFilesInIteration,
                $numOfTraceFilesInIteration);
            $condition->in('tracer_dump_file', $partialTraceFilesList);

            $select->where($condition);

            $select->limit($numOfTraceFilesInIteration);
            $select->offset($i * $numOfTraceFilesInIteration);

            // execute the query
            $result = $this->selectWithRetries($select);

            // build the result array ['<trace file>' => '<event ID>', ...]
            foreach ($result as $row) {
                $resultArray[$row['tracer_dump_file']] = $row['issue_id'];
            }
        }

        return $resultArray;
    }

    /**
     * 
     * @param mixed $params 
     * @return  
     */
    public function getJobIssuesBySeverity($params)
    {
        $limit     = $params['limit'];
        $direction = $params['direction'];

        // fixed #ZSRV-17421, the sevirity sorting
        $direction = strtoupper($direction);
        $result    = $this->getIssuesBySeverityOrder($params, $limit, $direction, true);
        return new Set($result, 'Issue\Container');
    }

    /**
     *
     * @param array $params
     * @param <unknown> $limit
     * @param <unknown> $offset
     * @param <unknown> $orderby
     * @param <unknown> $direction
     * @return Set
     */
    public function getIssues(array $params, $limit, $offset, $orderby, $direction)
    {

        if ($orderby == "severity" && $offset == 0) {

            // fixed #ZSRV-17421, the sevirity sorting
            $direction          = strtoupper($direction);
            $isJobRelatedIssues = false;
            if (isset($params['tags']) && is_array($params['tags']) && in_array('jobqueue', $params['tags'])) {
                $isJobRelatedIssues = true;
            }
            $result = $this->getIssuesBySeverityOrder($params, $limit, $direction, $isJobRelatedIssues);
            $result = $this->addRequestComponentsToResultSet($result);
        } else {

            $issues = $this->getRelevantIssueIds($params, $limit, $offset, $orderby, $direction);
            if ($issues) {
                $result      = array();
                $issuesArray = array_chunk($issues, 900); // limit 1000
                foreach ($issuesArray as $chunk) {
                    $select = new \Zend\Db\Sql\Select ();

                    $select->from($this->getTableGateway()->getTable());
                    $select->join("issues", "issues.id = events.issue_id", array());
                    $select->join("matched_rules", "events.event_id = matched_rules.event_id", array(), Select::JOIN_LEFT);
                    $select->join("events_jobs", "events.event_id = events_jobs.event_id", array('job_id' => 'job_id'), Select::JOIN_LEFT);
                    
                    // $select->join ( "request_components", "issues.cluster_issue_id = request_components.cluster_issue_id", array(), Select::JOIN_LEFT );

                    $select = $this->applyCommonColumns($select);

                    $select->where(array(
                        'issues.cluster_issue_id IN ('.implode(",", $chunk).")", 
                        "issues.status != ".ZM_STATUS_DELETED
                    ));

                    $select->order(array(
                        $this->getOrderTranslated($orderby) => $direction
                    ));

                    $selectResult = $this->selectWith($select);
                    $selectResult = $this->addRequestComponentsToResultSet($selectResult);
                    $result       = array_merge($selectResult, $result);
                }
            } else {
                $result = array();
            }
        }

        return new Set($result, 'Issue\Container');
    }

    private function getRelevantIssueIds(array $params, $limit, $offset, $orderby, $direction)
    {
        $select = new \Zend\Db\Sql\Select ();
        $select->from($this->getTableGateway()->getTable());
        $select->join("issues", "issues.id = events.issue_id", array(), Select::JOIN_INNER);
        $select->join("matched_rules", "events.event_id = matched_rules.event_id", array(), Select::JOIN_LEFT);
        $select->join("request_components", "events.issue_id = request_components.cluster_issue_id", array(),
            Select::JOIN_LEFT);

        if (isset($params['tags']) && is_array($params['tags']) && in_array('jobqueue', $params['tags'])) {
            $select->join("events_jobs", "events_jobs.event_id = events.event_id", array(), Select::JOIN_LEFT);
        }

        $select->columns(array('repeats' => 'repeats',
            'cluster_issue_id' => new Expression("events.cluster_issue_id"),
            'last_timestamp' => new \Zend\Db\Sql\Expression('max(events.last_timestamp)'))
        );
        try {
            $this->applyParams($select, $params);
        } catch (IdentityFilterException $ex) {
            if (IdentityFilterException::EMPTY_APPLICATIONS_ARRAY == $ex->getCode()) {
                return array();
            }
        }
        if ($limit) {
            $select->limit(intval($limit));
        }
        if ($offset) {
            $select->offset(intval($offset));
        }

        $select->order(array(
            $this->orderTranslated [$orderby] => $direction
        ));

        $select->group('issues.cluster_issue_id');

        $result = $this->selectWith($select);

        $list = array();
        foreach ($result as $arr) {
            $arrayData = array_pop($arr);
            $list[]    = $arr['cluster_issue_id'];
        }

        Log::debug(__FUNCTION__." returned ".count($result)." issues");
        return $list;
    }

    public function getRelevantMvc(array $issues)
    {
        $result = array();
        if ($issues) {
            $result = $this->getTableGateway()->getAdapter()->query(
                    "select distinct cluster_issue_id, comp_name, comp_value from request_components where cluster_issue_id IN (".implode(",",
                        $issues).")"
                    , \Zend\Db\Adapter\Adapter::QUERY_MODE_EXECUTE)->toArray();
        }

        $mvcArrayById = array();
        foreach ($result as $issueMvc) {
            $mvcArrayById[$issueMvc['cluster_issue_id']][$issueMvc['comp_name']] = $issueMvc['comp_value'];
        }

        Log::debug(__FUNCTION__." returned ".count($mvcArrayById)." mvc issues");
        return $mvcArrayById;
    }
    
    /**
     * 
     * @param array $params 
     * @param mixed $limit 
     * @param mixed $direction 
     * @param mixed $isJobRelatedIssues 
     * @return  
     */
    public function getIssuesBySeverityOrder(array $params, $limit, $direction, $isJobRelatedIssues = false)
    {

        Log::debug(__FUNCTION__." with limit $limit");

        $severities = array(
            ZM_SEVERITY_SEVERE,
            ZM_SEVERITY_NORMAL,
            ZM_SEVERITY_INFO
        );
        if ($direction == "ASC") {
            $severities = array_reverse($severities);
        }

        $result = array();

        foreach ($severities as $severity) {
            $select = new \Zend\Db\Sql\Select ();
            $select->from($this->getTableGateway()->getTable());
            $select->join("issues", "issues.id = events.issue_id", array(), Select::JOIN_LEFT);

            if ($isJobRelatedIssues || (isset($params['tags']) && is_array($params['tags']) && in_array('jobqueue',
                    $params['tags']))) {
                $select->join("events_jobs", "events_jobs.event_id = events.event_id", array(), Select::JOIN_LEFT);
            }
            
            $select->join("matched_rules", "events.event_id = matched_rules.event_id", array(), Select::JOIN_LEFT);
            $select = $this->applyCommonColumns($select, $isJobRelatedIssues);

            try {
                $select = $this->applyParams($select, $params, $isJobRelatedIssues);
            } catch (IdentityFilterException $ex) {
                if (IdentityFilterException::EMPTY_APPLICATIONS_ARRAY == $ex->getCode()) {
                    return array();
                }
            }

            $select->where(array(
                "issues.severity = $severity",
                "issues.status != ?" => ZM_STATUS_DELETED
            ));

            if ($limit) {
                $select->limit(intval($limit));
            }
            $select->offset(0);

            $select->order("issues.cluster_issue_id DESC");

            $result = array_merge($result, $this->selectWith($select));

            Log::debug(__FUNCTION__." Found ".count($result)." issues");
            $limit -= count($result);
            if ($limit <= 0) {
                break;
            }
        }

        $result = $this->addRequestComponentsToResultSet($result);

        return $result;
    }

    public function getIssuesCount(array $params)
    {
        $select = new \Zend\Db\Sql\Select ();
        $select->from($this->getTableGateway()->getTable());
        $select->join("issues", "issues.id = events.issue_id", array(), Select::JOIN_LEFT);
        $select->join("matched_rules", "events.event_id = matched_rules.event_id", array(), Select::JOIN_LEFT);
        $select->join("request_components", "events.issue_id = request_components.cluster_issue_id", array(),
            Select::JOIN_LEFT);

        if (isset($params['tags']) && is_array($params['tags']) && in_array('jobqueue', $params['tags'])) {
            $select->join("events_jobs", "events_jobs.event_id = events.event_id", array(), Select::JOIN_LEFT);
        }

        $select->columns(array(
            'total' => new \Zend\Db\Sql\Expression('count(distinct (issues.cluster_issue_id))')
        ));
        try {
            $this->applyParams($select, $params);
        } catch (IdentityFilterException $ex) {
            if (IdentityFilterException::EMPTY_APPLICATIONS_ARRAY == $ex->getCode()) {
                return 0;
            }
        }
        $result = $this->selectWith($select);
        return $result [0] ['total'];
    }

    /**
     * @param integer $issueId
     * @throws Exception
     * @return \Issue\Container
     */
    public function getIssue($issueId)
    {

        Log::debug(__FUNCTION__." with issue $issueId");

        $select = new Select ();
        $select->from($this->getTableGateway()->getTable());
        $select->where(array(
            "issues.cluster_issue_id = ?" => $issueId,
            "issues.status != ".ZM_STATUS_DELETED
        ));
        $select->join("issues", "issues.id = events.issue_id", array(), Select::JOIN_LEFT);
        $select->join("matched_rules", "events.event_id = matched_rules.event_id", array(), Select::JOIN_LEFT);
        $select->join("events_jobs", "events.event_id = events_jobs.event_id", array('job_id'), Select::JOIN_LEFT);
        $select = $this->applyCommonColumns($select);

        $result = $this->selectWith($select);
        if (!$result[0]['cluster_issue_id']) {
            throw new Exception(_t('Issue not found'));
        }

        // if the issue is related to a job, get job's details
        $result = $this->addJobDetailsToResultSet($result);
        $issue = $result [0];

        $result = $this->addRequestComponentsToResultSet(array($issue));
        $issue = $result [0];

        $moreIssueDetails = $this->getWrapper()->getIssueData($issueId);
        if (isset($moreIssueDetails[ZM_DATA_ISSUE_AGG_KEY_ATTRIBUTES])) {
            $issue[ZM_DATA_ISSUE_AGG_KEY_ATTRIBUTES] = $moreIssueDetails[ZM_DATA_ISSUE_AGG_KEY_ATTRIBUTES];
        }
        return new IssueContainer($issue);
    }

    /**
     * @return Wrapper
     */
    public function getWrapper()
    {
        if (is_null($this->wrapper)) {
            $this->wrapper = new Wrapper();
        }
        return $this->wrapper;
    }

    /**
     * @param \MonitorUi\Wrapper $wrapper
     */
    public function setWrapper($wrapper)
    {
        $this->wrapper = $wrapper;
    }

    /**
     *
     * @param Select $query
     * @param array $params
     * @throws IdentityFilterException
     */
    private function applyParams($query, $params, $isJobRelatedIssues = false)
    {

        $where = new Where();

        if (isset($params ['from']) && !empty($params['from'])) {
            $from  = (int) $params ['from'];
            $dates = new Predicate();
            $dates->greaterThanOrEqualTo('events.first_timestamp', $from)
                ->or
                ->greaterThanOrEqualTo('events.last_timestamp', $from);
            $where->andPredicate($dates);
        }
        if (isset($params ['to']) && !empty($params ['to'])) {
            $to    = (int) $params['to'];
            $dates = new Predicate();
            $dates->lessThanOrEqualTo('events.first_timestamp', $to)
                ->or
                ->lessThanOrEqualTo('events.last_timestamp', $to);
            $where->andPredicate($dates);
        }
        
        if (isset($params ['ruleNames']) && !empty($params ['ruleNames'])) {
            $where->in('matched_rules.id', $params ['ruleNames']);
        }

        if (isset($params ['eventTypes']) && !empty($params ['eventTypes'])) {
            $eventTypes = $this->applyEventTypes($params['eventTypes']);
            $where->in('issues.event_type', $eventTypes);
        }

        if (isset($params ['severities']) && !empty($params ['severities'])) {
            $severities[] = current($params['severities']);
            $where->in('issues.severity', $severities);
        }

        if (isset($params['applicationIds']) && !empty($params['applicationIds'])) {
            $this->identityFilter->setAddGlobalAppId(false);
            
            $appIds = $this->identityFilter->filterAppIds($params['applicationIds']);
            $where->in('events.app_id', $appIds);
        } else {
            // I'm not sure if that's necessary
            $this->identityFilter->setAddGlobalAppId(true);
        }
        

        if (isset($params ['aggKeys']) && is_array($params ['aggKeys']) && !empty($params ['aggKeys'])) {
            $where->in('issues.agg_key', $params ['aggKeys']);
        }

        if (isset($params['fullUrl']) && !empty($params ['fullUrl'])) {
            // search with the post and without
            if (strpos($params['fullUrl'], ':80') !== false) {
                $where->in('issues.full_url', array(
                    $params ['fullUrl'],
                    str_replace(':80/', '/', $params ['fullUrl']),
                ));
            } else {
                $where->equalTo('issues.full_url', $params ['fullUrl']);
            }
        }

        $where->equalTo('issues.status', ZM_STATUS_NEW);

        if (isset($params['tags']) && is_array($params['tags']) && in_array('jobqueue', $params['tags'])) {
            $jobRelatedEventsWhere = new Predicate();

            $jobRelatedEventsWhere->in('issues.event_type',
                    array(ZM_TYPE_JQ_JOB_EXEC_ERROR, ZM_TYPE_JQ_JOB_LOGICAL_FAILURE, ZM_TYPE_JQ_JOB_EXEC_DELAY))
                ->or
                ->notEqualTo('events_jobs.job_id', 'null');
            $where->andPredicate($jobRelatedEventsWhere);
        }

        if (isset($params ['freeText']) && !empty($params ['freeText'])) {
            $freeText = new Predicate();
            $freeText->like('issues.rule_name', "%{$params ['freeText']}%")
                ->or
                ->like('issues.function_name', "%{$params ['freeText']}%")
                ->or
                ->like('issues.id', "%{$params ['freeText']}%")
                ->or
                ->like('request_components.comp_value', "%{$params ['freeText']}%")
                ->or
                ->like('issues.full_url', "%{$params ['freeText']}%");

            // @TODO: add search in the routing: comp_name and comp_value
            $where->andPredicate($freeText);
        }


        if ($isJobRelatedIssues) {
            $jobRelatedEventsWhere = new Predicate();

            $jobRelatedEventsWhere->in('issues.event_type',
                    array(ZM_TYPE_JQ_JOB_EXEC_ERROR, ZM_TYPE_JQ_JOB_LOGICAL_FAILURE, ZM_TYPE_JQ_JOB_EXEC_DELAY))
                ->or
                ->notEqualTo('events_jobs.job_id', 'null');
            $where->andPredicate($jobRelatedEventsWhere);
        }

        $query->where($where);
        return $query;
    }


    /**
     * 
     * @param mixed $clusterIssueIds 
     * @return array
     */
    protected function getComponentRecords($clusterIssueIds) {
        $select = new \Zend\Db\Sql\Select('request_components');
        $select->columns(array(
            'cluster_issue_id',
            'comp_name' => new \Zend\Db\Sql\Expression('GROUP_CONCAT(comp_name)'),
            'comp_value' => new \Zend\Db\Sql\Expression('GROUP_CONCAT(comp_value)'),
        ));
        $select->where(array('cluster_issue_id' => array_unique($clusterIssueIds)));
        $select->group('cluster_issue_id');

        $tableGateway = new \Zend\Db\TableGateway\TableGateway(
            'request_components',
            $this->getTableGateway()->getAdapter()
        );
        $result = $tableGateway->selectWith($select);
        if (!$result) {
            return array();
        }

        $result = $result->toArray();
        if (empty($result)) {
            return array();
        }

        // reorder the result
        $compRecords = array();
        foreach ($result as $row) {
            $compRecords[$row['cluster_issue_id']] = $row;
        }

        return $compRecords;
    }
    
    /**
     * 
     * @param mixed $jobsIds 
     * @return  
     */
    protected function getJobsInfo($jobsIds) {
        $this->getJobQueueMapper()->getJobsList();
    }

    /**
     * @brief Add request components data to the result set
     * @param Set|array $resultSet
     * @return
     */
    protected function addRequestComponentsToResultSet($resultSet)
    {
        if (empty($resultSet)) {
            return $resultSet;
        }

        // gather IDs
        $clusterIssueIds = array();
        $jobIds = array();
        foreach ($resultSet as $row) {
            $clusterIssueIds[] = $row['cluster_issue_id'];
            if (isset($row['job_id'])) {
                $jobIds[] = $row['job_id'];
            }
        }

        // get request component
        $compRecords = $this->getComponentRecords($clusterIssueIds);

        $newResultSet = array();
        foreach ($resultSet as $row) {
            $clusterIssueId = $row['cluster_issue_id'];
            $newResultSet[] = array_merge($row,
                array(
                'comp_name' => isset($compRecords[$clusterIssueId]) && isset($compRecords[$clusterIssueId]['comp_name'])
                    ? $compRecords[$clusterIssueId]['comp_name'] : '',
                'comp_value' => isset($compRecords[$clusterIssueId]) && isset($compRecords[$clusterIssueId]['comp_value'])
                    ? $compRecords[$clusterIssueId]['comp_value'] : '',
            ));
        }

        return $newResultSet;
    }
    
    // some events are related to a specific job execution. Job details
    // have to be fetched from jobqueue db. 
    protected function addJobDetailsToResultSet($resultSet) {
        
        // get jobqueue mapper
        $jqMapper = $this->getJobQueueMapper();
        
        $newResultSet = [];
        foreach ($resultSet as $row) {
            $row['job_details'] = [];
            if (isset($row['job_id']) && is_numeric($row['job_id'])) {
                $jobDetails = $jqMapper->getJob($row['job_id']);
                $row['job_details'] = $jobDetails;
                
                // udpate "full_url"
                if ($jobDetails['type'] == \JobQueue\JobQueueInterface::TYPE_CLI || $jobDetails['type'] == \JobQueue\JobQueueInterface::TYPE_CLI_PHP) {
                    $row['full_url'] = $jobDetails['script'];
                }
            }
            $newResultSet[] = $row;
        }
        
        return $newResultSet;
    }

    private function applyEventTypes($eventTypesParams)
    {
        $eventTypes = array();
        foreach ($eventTypesParams as $evType) {
            if (is_numeric($evType)) {// integer, already translated to const
                $eventTypes [] = $evType;
            } else {
                switch ($evType) {
                    case \Issue\Filter\Dictionary::TYPE_FUNCTION_ERROR :
                        $eventTypes [] = ZM_TYPE_FUNCTION_ERROR;
                        break;
                    case \Issue\Filter\Dictionary::TYPE_PHP_ERROR :
                        $eventTypes [] = ZM_TYPE_ZEND_ERROR;
                        break;
                    case \Issue\Filter\Dictionary::TYPE_JAVA_EXCEPTION :
                        $eventTypes [] = ZM_TYPE_JAVA_EXCEPTION;
                        break;
                    case \Issue\Filter\Dictionary::TYPE_JQ_JOB_EXECUTION_ERROR :
                        $eventTypes [] = ZM_TYPE_JQ_JOB_EXEC_ERROR;
                        break;
                    case \Issue\Filter\Dictionary::TYPE_JQ_JOB_LOGICAL_FAILURE :
                        $eventTypes [] = ZM_TYPE_JQ_JOB_LOGICAL_FAILURE;
                        break;
                    case \Issue\Filter\Dictionary::TYPE_JQ_JOB_EXECUTION_DELAY :
                        $eventTypes [] = ZM_TYPE_JQ_JOB_EXEC_DELAY;
                        break;
                    case \Issue\Filter\Dictionary::TYPE_CUSTOM :
                        $eventTypes [] = ZM_TYPE_CUSTOM;
                        break;
                    case \Issue\Filter\Dictionary::TYPE_SLOW_FUNCTION :
                        $eventTypes [] = ZM_TYPE_FUNCTION_SLOW_EXEC;
                        break;
                    case \Issue\Filter\Dictionary::TYPE_SLOW_SCRIPT :
                        $eventTypes [] = ZM_TYPE_REQUEST_SLOW_EXEC;
                        $eventTypes [] = ZM_TYPE_REQUEST_RELATIVE_SLOW_EXEC;
                        break;
                    case \Issue\Filter\Dictionary::TYPE_OUTPUT_SIZE :
                        $eventTypes [] = ZM_TYPE_REQUEST_RELATIVE_LARGE_OUT_SIZE;
                        break;
                    case \Issue\Filter\Dictionary::TYPE_MEMORY_USAGE :
                        $eventTypes [] = ZM_TYPE_REQUEST_LARGE_MEM_USAGE;
                        $eventTypes [] = ZM_TYPE_REQUEST_RELATIVE_LARGE_MEM_USAGE;
                        break;
                    default: // integer, already translated to const
                        $eventTypes [] = $evType;
                };
            }
        }
        return $eventTypes;
    }
}