<?php

/*********************************************************************

class.filter.php

Ticket Filter

Peter Rotich <[email protected]>

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;

}

function delete() {

try {

parent::delete();

$type = array('type' => 'deleted');

Signal::send('object.deleted', $this, $type);

$this->rules->expunge();

$this->actions->expunge();

}

catch (OrmException $e) {

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;

}

function save_actions($id, $vars, &$errors) {

if (!is_array(@$vars['actions']))

return;

foreach ($vars['actions'] as $sort=>$v) {

if (is_array($v)) {

$info = $v['type'];

$sort = $v['sort'] ?: $sort;

$action = 'N';

}

else {

$action = $v[0];

$info = substr($v, 1);

}

switch ($action) {

case 'N': # new filter action

$I = new FilterAction(array(

'type'=>$info,

'filter_id'=>$id,

'sort' => (int) $sort,

));

$I->setConfiguration($errors, $vars);

$I->save();

break;

case 'I': # existing filter action

if ($I = FilterAction::lookup($info)) {

$I->setConfiguration($errors, $vars);

$I->sort = (int) $sort;

$I->save();

}

break;

case 'D': # deleted filter action

if ($I = FilterAction::lookup($info))

$I->delete();

break;

}

}

}

}

Signal::connect('object.deleted', array('Filter', 'disableFilters'));

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) {