golden hour

/home/doctorbruno/public_html/taeionline.com/support/include

File/Folder	Size	Actions
.MANIFEST	194.97 KB
.htaccess	14 B
JSON.php	33.13 KB
PasswordHash.php	6.92 KB
Spyc.php	31.74 KB
UniversalClassLoader.php	8.61 KB
ajax.admin.php	7.29 KB
ajax.config.php	4.61 KB
ajax.content.php	9.76 KB
ajax.draft.php	13.03 KB
ajax.email.php	2.33 KB
ajax.export.php	1006 B
ajax.filter.php	874 B
ajax.forms.php	13.84 KB
ajax.i18n.php	5.1 KB
ajax.kbase.php	2.93 KB
ajax.note.php	2.05 KB
ajax.orgs.php	11.73 KB
ajax.plugins.php	2.15 KB
ajax.schedule.php	4.29 KB
ajax.search.php	12.72 KB
ajax.sequence.php	3.2 KB
ajax.staff.php	11.62 KB
ajax.tasks.php	33.87 KB
ajax.thread.php	8.81 KB
ajax.tickets.php	79.7 KB
ajax.tips.php	1.66 KB
ajax.upgrader.php	2.24 KB
ajax.users.php	18.33 KB
api.cron.php	1.06 KB
api.tickets.php	10.36 KB
class.2fa.php	7.76 KB
class.ajax.php	1.45 KB
class.api.php	15.31 KB
class.app.php	1.49 KB
class.attachment.php	6.95 KB
class.auth.php	50.73 KB
class.avatar.php	6.44 KB
class.banlist.php	2.58 KB
class.base32.php	4.07 KB
class.businesshours.php	7.08 KB
class.canned.php	9.05 KB
class.captcha.php	1.73 KB
class.category.php	11.14 KB
class.charset.php	3.41 KB
class.cli.php	9.48 KB
class.client.php	15.39 KB
class.collaborator.php	5.65 KB
class.company.php	2.65 KB
class.config.php	60.36 KB
class.controller.php	1.15 KB
class.cron.php	3.6 KB
class.crypto.php	18.92 KB
class.csrf.php	2.38 KB
class.dept.php	33.21 KB
class.dispatcher.php	7.12 KB
class.draft.php	6.23 KB
class.dynamic_forms.php	64.98 KB
class.email.php	49 KB
class.error.php	1.69 KB
class.export.php	32.92 KB
class.faq.php	15.05 KB
class.file.php	34.59 KB
class.filter.php	31.9 KB
class.filter_action.php	23.67 KB
class.format.php	44.3 KB
class.forms.php	195.58 KB
class.http.php	7.16 KB
class.i18n.php	24.28 KB
class.import.php	6.9 KB
class.json.php	2.71 KB
class.knowledgebase.php	5.8 KB
class.list.php	42 KB
class.lock.php	4.05 KB
class.log.php	1.55 KB
class.mail.php	35.76 KB
class.mailer.php	25.75 KB
class.mailfetch.php	9.72 KB
class.mailparse.php	30.99 KB
class.message.php	6.42 KB
class.migrater.php	5.2 KB
class.misc.php	7.5 KB
class.model.php	2.3 KB
class.nav.php	14.15 KB
class.note.php	2.39 KB
class.oauth2.php	4.04 KB
class.organization.php	22.45 KB
class.orm.php	120.9 KB
class.osticket.php	20.64 KB
class.ostsession.php	21.86 KB
class.page.php	10.59 KB
class.pagenate.php	5.53 KB
class.passwd.php	1.21 KB
class.pdf.php	3.83 KB
class.plugin.php	36.13 KB
class.priority.php	1.81 KB
class.queue.php	103.51 KB
class.report.php	11.76 KB
class.role.php	11.27 KB
class.schedule.php	46.28 KB
class.search.php	61.66 KB
class.sequence.php	7.27 KB
class.session.php	19.25 KB
class.setup.php	3.55 KB
class.signal.php	4.16 KB
class.sla.php	9.11 KB
class.staff.php	60.21 KB
class.task.php	56.21 KB
class.team.php	12.31 KB
class.template.php	23.45 KB
class.thread.php	108.96 KB
class.thread_actions.php	17.08 KB
class.ticket.php	167.39 KB
class.timezone.php	21.94 KB
class.topic.php	20.06 KB
class.translation.php	34.79 KB
class.upgrader.php	13.76 KB
class.user.php	43.4 KB
class.usersession.php	7.55 KB
class.util.php	10.07 KB
class.validator.php	12.94 KB
class.variable.php	11.93 KB
class.xml.php	3.23 KB
class.yaml.php	1.15 KB
cli	-
client	-
config	-
fpdf	-
htmLawed.php	53.53 KB
html2text.php	33.71 KB
i18n	-
index.php	37 B
laminas-mail	-
mpdf	-
mysqli.php	9.55 KB
ost-config.php	5.63 KB
ost-sampleconfig.php	6.24 KB
pear	-
plugins	-
staff	-
tnef_decoder.php	19.82 KB
upgrader	-

Edit: class.filter.php

<?php
/*********************************************************************
    class.filter.php

Ticket Filter

Peter Rotich <peter@osticket.com>
    Copyright (c)  2006-2013 osTicket
    http://www.osticket.com

Released under the GNU General Public License WITHOUT ANY WARRANTY.
    See LICENSE.TXT for details.

vim: expandtab sw=4 ts=4 sts=4:
**********************************************************************/

require_once INCLUDE_DIR . 'class.filter_action.php';

class Filter
extends VerySimpleModel {
    static $meta = array(
        'table' => FILTER_TABLE,
        'pk' => array('id'),
        'ordering' => array('execorder'),
        'joins' => array(
            'rules' => array(
                'reverse' => 'FilterRule.filter',
            ),
            'actions' => array(
                'reverse' => 'FilterAction.filter',
            ),
        ),
    );

const FLAG_INACTIVE_HT = 0x0001;
    const FLAG_INACTIVE_DEPT  = 0x0002;
    const FLAG_DELETED_OBJECT  = 0x0004;

static $match_types = array(
        /* @trans */ 'User Information' => array(
            array('name'      =>    /* @trans */ 'Name',
                'email'     =>      /* @trans */ 'Email',
            ),
            900
        ),
        /* @trans */ 'Email Meta-Data' => array(
            array('reply-to'  =>    /* @trans */ 'Reply-To Email',
                'reply-to-name' =>  /* @trans */ 'Reply-To Name',
                'addressee' =>      /* @trans */ 'Addressee (To and Cc)',
            ),
            200
        ),
    );

function __construct($vars=array()) {
        parent::__construct($vars);
        $this->created = SqlFunction::NOW();
    }

function getId() {
        return $this->id;
    }

function getTarget() {
        return $this->target;
    }

function getName() {
        return $this->name;
    }

function getNotes() {
        return $this->notes;
    }

function getInfo() {
        $ht = $this->ht;
        if (static::$meta['joins'])
            foreach (static::$meta['joins'] as $k => $v)
                unset($ht[$k]);
        return $ht;
    }

function getNumRules() {
        return $this->rules->count();
    }

function getExecOrder() {
        return $this->execorder;
    }

function getEmailId() {
        return $this->email_id;
    }

function isActive() {
        return ($this->isactive);
    }

function isSystemBanlist() {
        return !strcasecmp($this->getName(),'SYSTEM BAN LIST');
    }

function getDeptId() {
        return $this->dept_id;
    }

function getStatusId() {
        return $this->status_id;
    }

function getPriorityId() {
        return $this->priority_id;
    }

function getSLAId() {
        return $this->sla_id;
    }

function getStaffId() {
        return $this->staff_id;
    }

function getTeamId() {
        return $this->team_id;
    }

function getCannedResponse() {
        return $this->canned_response_id;
    }

function getHelpTopic() {
        return $this->topic_id;
    }

public function setFlag($flag, $val) {
        $vars = array();
        $errors = array();
        if ($val)
            $this->flags |= $flag;
        else
            $this->flags &= ~$flag;
        $vars['rules']= $this->getRules();
        $this->ht['pass'] = true;
        $this->update($this->ht, $errors);
    }

function hasFlag($flag) {
        return 0 !== ($this->ht['flags'] & $flag);
    }

function stopOnMatch() {
        return ($this->stop_onmatch);
    }

function matchAllRules() {
        return ($this->match_all_rules);
    }

function rejectOnMatch() {
        return ($this->reject_ticket);
    }

function useReplyToEmail() {
        return ($this->use_replyto_email);
    }

static function disableFilters($object) {
        switch (get_class($object)) {
            case 'Topic':
                $object_id = 'topic_id';
                $FAClass = 'FA_AssignTopic';
                break;
            case 'Dept':
                $object_id = 'dept_id';
                $FAClass = 'FA_RouteDepartment';
                break;
            case 'Staff':
                $object_id = 'staff_id';
                $FAClass = 'FA_AssignAgent';
                break;
            case 'Team':
                $object_id = 'team_id';
                $FAClass = 'FA_AssignTeam';
                break;
            case 'SLA':
                $object_id = 'sla_id';
                $FAClass = 'FA_AssignSLA';
                break;
            case 'TicketStatus':
                $object_id = 'status_id';
                $FAClass = 'FA_SetStatus';
                break;
            case 'Email':
                $object_id = 'from';
                $FAClass = 'FA_SendEmail';
                break;
            case 'Canned':
                $object_id = 'canned_id';
                $FAClass = 'FA_AutoCannedResponse';
            default:
                return false;
        }
        $id = $object->getId();
        $actions = FilterAction::objects()
            ->filter(array('type' => $FAClass::$type,
                           'configuration__like' => sprintf('%%"%s":%s}', $object_id, $id)));
        foreach($actions as $fa) {
            // Put a flag on the filter
            FilterAction::setFilterFlags($fa, 'Filter::FLAG_DELETED_OBJECT', true);
            $fa->save();

// Disable the filter
            $filter = Filter::lookup($fa->filter_id);
            $filter->isactive = 0;
            $filter->save();
        }
    }

function disableAlerts() {
        return ($this->disable_autoresponder);
    }

function sendAlerts() {
        return (!$this->disableAlerts());
    }

function getRules() {
        $rules = [];
        foreach ($this->rules as $r)
            $rules[] = array('w'=>$r->what,'h'=>$r->how,'v'=>$r->val);

return $rules;
    }

function addRule($what, $how, $val,$extra=array()) {
        if (isset($extra['notes']))
            $extra['notes'] = Format::sanitize($extra['notes']);
        $rule = array_merge($extra,array('what'=>$what, 'how'=>$how, 'val'=>$val));
        $rule = new FilterRule($rule);
        $rule->created = SqlFunction::NOW();
        $this->rules->add($rule);
        if ($rule->save())
            return true;
    }

function removeRule($what, $how, $val) {
        return $this->rules->filter([
            'what' => $what,
            'how' => $how,
            'val' => $val,
        ])->delete();
    }

function getRule($id) {
        return $this->getRuleById($id);
    }

function getRuleById($id) {
        return FilterRule::lookup(array('id'=>$id, 'filter_id'=>$this->getId()));
    }

function containsRule($what, $how, $val) {
        return $this->rules->filter([
            'what' => $what,
            'how' => $how,
            'val' => $val,
        ])->exists();
    }

/**
     * Simple true/false if the rules defined for this filter match the
     * incoming email
     *
     * $info is an ARRAY, which has valid keys
     *   email - FROM email address of the ticket owner
     *   name - name of ticket owner
     *   subject - subject line of the ticket
     *   body - body content of the message (no attachments, please)
     *   reply-to - reply-to email address
     *   reply-to-name - name of sender to reply-to
     *   headers - array of email headers
     *   emailId - osTicket system email id
     */
    function matches($what) {

if(!$what || !is_array($what)) return false;

$how = array(
            # how => array(function, null or === this, null or !== this)
            'equal'     => array('strcasecmp', 0),
            'not_equal' => array('strcasecmp', null, 0),
            'contains'  => array('stripos', null, false),
            'dn_contain'=> array('stripos', false),
            'starts'    => array('stripos', 0),
            'ends'      => array('iendsWith', true),
            'match'     => array('pregMatchB', 1),
            'not_match' => array('pregMatchB', null, 1),
        );

$match = false;
        # Respect configured filter email-id
        if ($this->getEmailId()
                && !strcasecmp($this->getTarget(), 'Email')
                && $this->getEmailId() != $what['emailId'])
            return false;

foreach ($this->getRules() as $rule) {
            if (!isset($how[$rule['h']])) continue;
            list($func, $pos, $neg) = $how[$rule['h']];

$result = call_user_func($func, $what[$rule['w']], $rule['v']);
            if (($pos === null && $result !== $neg) or ($result === $pos)) {
                # Match.
                $match = true;
                if (!$this->matchAllRules()) break;
            } else {
                # No match. Continue?
                if ($this->matchAllRules()) {
                    $match = false;
                    break;
                }
            }
        }

return $match;
    }

function getActions() {
        return $this->actions;
    }

/**
     * If the matches() method returns TRUE, send the initial ticket to this
     * method to apply the filter actions defined
     */
    function apply(&$ticket, $vars, $postCreate=false) {
        foreach ($this->getActions() as $a) {
            //control when certain actions should be applied
            //if action is send email and postCreate == false, skip
            //if action is not send email and postCreate == true, skip
            if ((($a->type == 'email') ? !$postCreate : $postCreate))
                continue;

$a->setFilter($this);
            $a->apply($ticket, $vars);
        }
    }

function getVars() {
        return $this->vars;
    }

static function getSupportedMatches() {
        foreach (static::$match_types as $k=>&$v) {
            if (is_callable($v[0]))
                $v[0] = $v[0]();
        }
        unset($v);
        uasort(static::$match_types, function($a, $b) { return $a[1] - $b[1]; });
        return array_map(function($a) { return $a[0]; }, static::$match_types);
    }

static function addSupportedMatches($group, $callable, $order=10) {
        static::$match_types[$group] = array($callable, $order);
    }

static function getSupportedMatchFields() {
        $keys = array();
        foreach (static::getSupportedMatches() as $group=>$matches) {
            foreach ($matches as $key=>$label) {
                $keys[] = $key;
            }
        }
        return $keys;
    }

static function getSupportedMatchTypes() {
        return array(
            'equal'=>       __('Equal'),
            'not_equal'=>   __('Not Equal'),
            'contains'=>    __('Contains'),
            'dn_contain'=>  __('Does Not Contain'),
            'starts'=>      __('Starts With'),
            'ends'=>        __('Ends With'),
            'match'=>       __('Matches Regex'),
            'not_match'=>   __('Does Not Match Regex'),
        );
    }

function update($vars,&$errors) {
        //validate filter actions before moving on
        if (!self::validate_actions($vars, $errors))
            return false;

$vars['flags'] = $this->flags;

if(!$vars['execorder'])
            $errors['execorder'] = __('Order required');
        elseif(!is_numeric($vars['execorder']))
            $errors['execorder'] = __('Must be numeric value');

if(!$vars['name'])
            $errors['name'] = __('Name required');
        elseif(($filter=static::getByName($vars['name'])) && $filter->id!=$this->id)
            $errors['name'] = __('Name already in use');

if(!$errors && !$this->validate_rules($vars,$errors) && !$errors['rules'])
            $errors['rules'] = __('Unable to validate rules as entered');

$targets = self::getTargets();
        if(!$vars['target'])
            $errors['target'] = __('Target required');
        else if(!is_numeric($vars['target']) && !$targets[$vars['target']])
            $errors['target'] = __('Unknown or invalid target');

if($errors) return false;

$emailId = 0;
        if(is_numeric($vars['target'])) {
            $emailId = $vars['target'];
            $vars['target'] = 'Email';
        }

//Note: this will be set when validating filters
        if ($vars['email_id'])
            $emailId = $vars['email_id'];
        $this->isactive = $vars['isactive'];
        $this->flags = $vars['flags'];
        $this->target = $vars['target'];
        $this->name = $vars['name'];
        $this->execorder = $vars['execorder'];
        $this->email_id = $emailId;
        $this->match_all_rules = $vars['match_all_rules'];
        $this->stop_onmatch = $vars['stop_onmatch'];
        $this->notes = Format::sanitize($vars['notes']);

if (!$this->save()) {
            if (!$this->__new__) {
                $errors['err']=sprintf(__('Unable to update %s.'), __('this ticket filter'))
                   .' '.__('Internal error occurred');
            }
            else {
                $errors['err']=sprintf(__('Unable to add %s.'), __('this ticket filter'))
                   .' '.__('Internal error occurred');
            }
            return false;
        }

// Attempt to create/update the actions. Collect the errors
        $this->save_actions($this->getId(), $vars, $errors);
        if ($errors)
            return false;

//Success with update/create...save the rules. We can't recover from any errors at this point.
        # Don't care about errors stashed in $xerrors
        $xerrors = array();
        if (!$this->save_rules($vars,$xerrors))
            return false;

return true;
    }

/** static functions **/
    static function getTargets() {
        return array(
                'Any' => __('Any'),
                'Web' => __('Web Forms'),
                'API' => __('API Calls'),
                'Email' => __('Emails'));
    }

static function getByName($name) {
        return static::lookup(['name' => $name]);
    }

function validate_rules($vars,&$errors) {
        $matches = self::getSupportedMatchFields();
        $types = array_keys(self::getSupportedMatchTypes());
        $rules = array();
        foreach ($vars['rules'] as $i=>$rule) {
            if ($rule->ht) {
                $rule = $rule->ht;
                $rule["w"] = $rule["what"];
                $rule["h"] = $rule["how"];
                $rule["v"] = $rule["val"];
            }

if (is_array($rule)) {
                if($rule["w"] || $rule["h"]) {
                    // Check for REGEX compile errors
                    if (in_array($rule["h"], array('match','not_match'))) {
                        $wrapped = "/".$rule["v"]."/iu";
                        if (false === @preg_match($rule["v"], ' ')
                                && (false !== @preg_match($wrapped, ' ')))
                            $rule["v"] = $wrapped;
                    }

if(!$rule["w"] || !in_array($rule["w"],$matches))
                        $errors["rule_$i"]=__('Invalid match selection');
                    elseif(!$rule["h"] || !in_array($rule["h"],$types))
                        $errors["rule_$i"]=__('Invalid match type selection');
                    elseif(!$rule["v"])
                        $errors["rule_$i"]=__('Value required');
                    elseif($rule["w"]=='email'
                            && $rule["h"]=='equal'
                            && !Validator::is_email($rule["v"]))
                        $errors["rule_$i"]=__('Valid email required for the match type');
                    elseif (in_array($rule["h"], array('match','not_match'))
                            && (false === @preg_match($rule["v"], ' ')))
                        $errors["rule_$i"] = sprintf(__('Regex compile error: (#%s)'),
                            preg_last_error());
                    else //for everything-else...we assume it's valid.
                        $rules[]=array('what'=>$rule["w"],
                            'how'=>$rule["h"],'val'=>trim($rule["v"]));
                } elseif($rule["v"]) {
                    $errors["rule_$i"]=__('Incomplete selection');
                }
            }
        }

if(!$rules && !$errors)
            $errors['rules']=__('You must set at least one rule.');

return $rules;
    }

function save_rules($vars, &$errors) {
        $rules = $this->validate_rules($vars, $errors);

if ($errors)
            return false;

//Clear existing rules...we're doing mass replace on each save!!
        $this->rules->expunge();
        $num = 0;
        foreach ($rules as $rule) {
            $rule = new FilterRule($rule);
            $this->rules->add($rule);
            $rule->save();
            $num++;
        }

return $num;
    }

function save($refetch=false) {
        if ($this->dirty)
            $this->updated = SqlFunction::NOW();
        return parent::save($refetch || $this->dirty);
    }

static function __create($vars,&$errors) {
        $filter = new static($vars);
        if ($filter->save()) {
            $filter->save_rules($vars, $errors);
            $filter->save_actions($filter->getId(), $vars, $errors);
            return $filter;
        }
    }

static function create($vars,&$errors) {
        $filter = new static($vars);
        if ($filter->save())
            return $filter;
    }

static function validate_actions($vars, &$errors) {
        //allow the save if it is to set a filter flag
        if ($vars['pass'])
            return true;

if (!is_array(@$vars['actions']))
            return;
        foreach ($vars['actions'] as $sort=>$v) {
          if (is_array($v)) {
              $info = $v['type'];
              $sort = $v['sort'] ?: $sort;
          } else
              $info = substr($v, 1);
          $action = new FilterAction(array(
              'type'=>$info,
              'sort' => (int) $sort,
          ));
          $err = array();
          $action->setConfiguration($err, $vars);
          $config = json_decode($action->ht['configuration'], true);
          if (is_numeric($action->ht['type'])) {
              foreach ($config as $key => $value) {
                  switch ($key) {
                      case 'topic_id':
                          $action->ht['type'] = 'topic';
                          $config['topic_id'] = $value;
                          break;
                      case 'dept_id':
                          $action->ht['type'] = 'dept';
                          $config['dept_id'] = $value;
                          break;
                      case 'sla_id':
                          $action->ht['type'] = __('SLA');
                          break;
                      case 'team_id':
                          $action->ht['type'] = __('Team');
                          break;
                      case 'staff_id':
                          $action->ht['type'] = __('Agent');
                          break;
                      case 'status_id':
                          $action->ht['type'] = __('Ticket Status');
                          break;
                      case 'canned_id':
                          $action->ht['type'] = __('Canned Response');
                          break;
                      default:
                          $action->ht['type'] = __('All Actions');
                          break;
                  }
              }
          }

// do not throw an error if we are deleting an action
          if (substr($v, 0, 1) != 'D') {
              switch ($action->ht['type']) {
                case 'dept':
                  $dept = Dept::lookup($config['dept_id']);
                  if (!$dept || !$dept->isActive()) {
                    $errors['err'] = sprintf(__('Unable to save: Please choose an active %s'), 'Department');
                  }
                  break;
                case 'topic':
                  $topic = Topic::lookup($config['topic_id']);
                  if (!$topic || !$topic->isActive()) {
                    $errors['err'] = sprintf(__('Unable to save: Please choose an active %s'), 'Help Topic');
                  }
                  break;
                default:
                  foreach ($config as $key => $value) {
                    if (!$value || is_null($value)) {
                        $errors['err'] = sprintf(__('Unable to save: Please insert a value for %s'), $action->ht['type']);
                        return 1;
                    }
                  }
                  break;
              }
          }
      }
      if (count($errors) == 0) {
          $fa = FilterAction::lookup($info);
          if ($fa) {
              $filter = Filter::lookup($fa->getFilterId());
              //Clear flags that may have been set on a successful save
              $filter->setFlag(constant('Filter::FLAG_DELETED_OBJECT'), false);
              $filter->setFlag(constant('Filter::FLAG_INACTIVE_DEPT'), false);
              $filter->setFlag(constant('Filter::FLAG_INACTIVE_HT'), false);
          }
      }
      return count($errors) == 0;
    }

class FilterRule
extends VerySimpleModel {
    static $meta = array(
        'table' => FILTER_RULE_TABLE,
        'pk' => array('id'),
        'joins' => array(
            'filter' => array(
                'constraint' => array('filter_id' => 'Filter.id'),
            ),
        ),
    );

function getId() {
        return $this->id;
    }

function isActive() {
        return ($this->isactive);
    }

function getHashtable() {
        return $this->ht;
    }

function getInfo() {
        return $this->getHashtable();
    }

function getFilterId() {
        return $this->filter_id;
    }

function getFilter() {
        return $this->filter;
    }

function update($vars, &$errors) {
        if (!$vars['filter_id'])
            $errors['err']=__('Parent filter ID required');

if ($errors)
            return false;

$this->what = $vars['what'];
        $this->how = $vars['how'];
        $this->val = $vars['val'];
        $this->isactive = isset($vars['isactive']) ? (int) $vars['isactive'] : 1;

if (isset($vars['notes']))
            $this->notes = Format::sanitize($vars['notes']);

if ($this->save())
            return true;
    }

function save($refetch=false) {
        if ($this->dirty)
            $this->updated = SqlFunction::NOW();

return parent::save($refetch || $this->dirty);
    }
}

/**
 * Applies rules defined in the admin control panel > Settings tab > "Ticket Filters". Each
 * filter can have up to 25 rules (*currently). This will attempt to match
 * the incoming tickets against the defined rules, and, if the email matches,
 * the ticket will be modified as described in the filter actions.
 */
class TicketFilter {

var $target;
    var $vars;

/**
     * Construct a list of filters to handle a new ticket
     * taking into account the source/origin of the ticket.
     *
     * $vars is an ARRAY, which has valid keys
     *  *email - email address of user
     *   name - name of user
     *   subject - subject of the ticket
     *   emailId - id of osTicket's system email (for emailed tickets)
     *  ---------------
     *  @see Filter::matches() for a complete list of supported keys
     */
    function __construct($origin, $vars=array()) {

//Normalize the target based on ticket's origin.
        $this->target = self::origin2target($origin);

//Extract the vars we care about (fields we filter by!).
        $this->vars = array('body'=>$vars['message']);
        $interest = Filter::getSupportedMatchFields();
        // emailId is always significant to the filter process
        $interest[] = 'emailId';
        foreach ($vars as $k=>$v) {
            if (in_array($k, $interest))
                $this->vars[$k] = trim($v);
        }
        if (isset($vars['recipients']) && $vars['recipients']) {
            foreach ($vars['recipients'] as $r) {
                $this->vars['addressee'][] = $r['name'];
                $this->vars['addressee'][] = $r['email'];
            }
            $this->vars['addressee'] = implode(' ', $this->vars['addressee']);
        }

//Init filters.
        $this->build();
    }

function build() {
        //Clear any memoized filters
        $this->filters = array();
        $this->short_list = null;

//Query DB for "possibly" matching filters.
        foreach ($this->getAllActive() as $filter)
            $this->filters[] = $filter;

return $this->filters;
    }

function getTarget() {
        return $this->target;
    }

/**
     * Fetches the short list of filters that match the ticket vars received in the
     * constructor. This function is memoized so subsequent calls will
     * return immediately.
     */
    function getMatchingFilterList() {

if (!isset($this->short_list)) {
            $this->short_list = array();
            foreach ($this->filters as $filter)
                if ($filter->matches($this->vars))
                    $this->short_list[] = $filter;
        }

return $this->short_list;
    }
    /**
     * Determine if any filters match the received email, and if so, apply
     * actions defined in those filters to the ticket-to-be-created.
     *
     * Throws:
     * RejectedException if the email should not be acceptable. If the email
     * should be rejected, the first filter that matches and has reject
     * ticket set is returned.
     */
    function apply(&$ticket, $postCreate=false) {
        foreach ($this->getMatchingFilterList() as $filter) {
            $filter->apply($ticket, $this->vars, $postCreate);
            if ($filter->stopOnMatch()) break;
        }
    }

function getAllActive() {
        $filters = Filter::objects()->filter([
            'isactive' => 1,
            'target__in' => array('Any', $this->getTarget()),
        ]);

#Take into account email ID.
        if ($this->vars['emailId'])
            $filters = $filters->filter([
                'email_id__in' => array(0, $this->vars['emailId'])
            ]);

return $filters->order_by('execorder')->all();
    }

/**
     * Simple true/false if the headers of the email indicate that the email
     * is an automatic response.
     *
     * Thanks to http://wiki.exim.org/EximAutoReply
     * X-Auto-Response-Supress is outlined here,
     *    http://msdn.microsoft.com/en-us/library/ee219609(v=exchg.80).aspx
     */
    /* static */
    static function isAutoReply($headers) {

if($headers && !is_array($headers))
            $headers = Mail_Parse::splitHeaders($headers);

$auto_headers = array(
            'Auto-Submitted'    => array('AUTO-REPLIED', 'AUTO-GENERATED'),
            'Precedence'        => array('AUTO_REPLY', 'BULK', 'JUNK', 'LIST'),
            'X-Precedence'      => array('AUTO_REPLY', 'BULK', 'JUNK', 'LIST'),
            'X-Autoreply'       => 'YES',
            'X-Auto-Response-Suppress' => array('AutoReply'),
            'X-Autoresponse'    => '*',
            'X-AutoReply-From'  => '*',
            'X-Autorespond'     => '*',
            'X-Mail-Autoreply'  => '*',
            'X-Autogenerated'   => 'REPLY',
            'X-AMAZON-MAIL-RELAY-TYPE' => 'NOTIFICATION',
        );

foreach ($auto_headers as $header=>$find) {
            $header = strtolower($header);
            if(!isset($headers[$header])) continue;

$value = strtoupper($headers[$header]);
            # Search text must be found at the beginning of the header
            # value. This is especially import for something like the
            # subject line, where something like an autoreponse may
            # appear somewhere else in the value.

if (is_array($find)) {
                foreach ($find as $f)
                    if (strpos($value, $f) === 0)
                        return true;
            } elseif ($find === '*') {
                return true;
            } elseif (strpos($value, $find) === 0) {
                return true;
            }
        }

return false;
    }

static function isBounce($headers) {
        if ($headers && !is_array($headers))
            $headers = Mail_Parse::splitHeaders($headers);

$bounce_headers = array(
            'From'  => array('stripos',
                        array('MAILER-DAEMON', '<>', 'postmaster@'), null, false),
            'Subject'   => array('stripos',
                array('DELIVERY FAILURE', 'DELIVERY STATUS',
                    'UNDELIVERABLE:', 'Undelivered Mail Returned'), 0),
            'Return-Path'   => array('strcmp', array('<>'), 0),
            'Content-Type'  => array('stripos', array('report-type=delivery-status'), null, false),
            'X-Failed-Recipients' => array('strpos', array('@'), null, false)
        );

foreach ($bounce_headers as $header => $find) {
            $header = strtolower($header);
            if(!isset($headers[$header])) continue;

@list($func, $searches, $pos, $neg) = $find;

if(!($value = $headers[$header]) || !is_array($searches))
                continue;

foreach ($searches as $f) {
                $result = call_user_func($func, $value, $f);
                if (($pos === null && $result !== $neg) or ($result === $pos))
                    return true;
            }
        }

return false;
    }

/**
     * Normalize ticket source to supported filter target
     *
     */
    static function origin2target($origin) {
        $sources=array('web' => 'Web', 'email' => 'Email', 'phone' => 'Web', 'staff' => 'Web', 'api' => 'API');

return $sources[strtolower($origin)];
    }
}

class RejectedException extends Exception {
    var $filter;
    var $vars;

function __construct(Filter $filter, $vars) {
        parent::__construct('Ticket rejected by a filter');
        $this->filter = $filter;
        $this->vars = $vars;
    }

function getRejectingFilter() {
        return $this->filter;
    }

function get($what) {
        return $this->vars[$what];
    }
}

class FilterDataChanged extends Exception {
    var $data;

function __construct($data) {
         parent::__construct('Ticket filter data changed');
         $this->data = $data;
    }

function getData() {
        return $this->data;
    }
}

/**
 * Function: endsWith
 *
 * Returns TRUE if the haystack ends with needle and FALSE otherwise.
 * Thanks, http://stackoverflow.com/a/834355
 */
function iendsWith($haystack, $needle)
{
    $length = mb_strlen($needle);
    if ($length == 0) {
        return true;
    }

return (strcasecmp(mb_substr($haystack, -$length), $needle) === 0);
}

function pregMatchB($subject, $pattern) {
    return preg_match($pattern, $subject);
}
?>