Code Forge

<?php

/**

*

* @package phpBB3

* @copyright (c) 2005 phpBB Group

* @license http://opensource.org/licenses/gpl-2.0.php GNU General Public License v2

*

*/

/**

*/

if (!defined('IN_PHPBB'))

{

        exit;

}

/*

        Ability to simply add own rules by doing three things:

                1) Add an appropriate constant

                2) Add a new check array to the global_privmsgs_rules variable and the condition array (if one is required)

                3) Implement the rule logic in the check_rule() function

                4) Add a new language variable to ucp.php

                The user is then able to select the new rule. It will be checked against and handled as specified.

                To add new actions (yes, checks can be added here too) to the rule management, the core code has to be modified.

*/

define('RULE_IS_LIKE', 1);                // Is Like

define('RULE_IS_NOT_LIKE', 2);        // Is Not Like

define('RULE_IS', 3);                        // Is

define('RULE_IS_NOT', 4);                // Is Not

define('RULE_BEGINS_WITH', 5);        // Begins with

define('RULE_ENDS_WITH', 6);        // Ends with

define('RULE_IS_FRIEND', 7);        // Is Friend

define('RULE_IS_FOE', 8);                // Is Foe

define('RULE_IS_USER', 9);                // Is User

define('RULE_IS_GROUP', 10);        // Is In Usergroup

define('RULE_ANSWERED', 11);        // Answered

define('RULE_FORWARDED', 12);        // Forwarded

define('RULE_TO_GROUP', 14);        // Usergroup

define('RULE_TO_ME', 15);                // Me

define('ACTION_PLACE_INTO_FOLDER', 1);

define('ACTION_MARK_AS_READ', 2);

define('ACTION_MARK_AS_IMPORTANT', 3);

define('ACTION_DELETE_MESSAGE', 4);

define('CHECK_SUBJECT', 1);

define('CHECK_SENDER', 2);

define('CHECK_MESSAGE', 3);

define('CHECK_STATUS', 4);

define('CHECK_TO', 5);

/**

* Global private message rules

* These rules define what to do if a rule is hit

*/

$global_privmsgs_rules = array(

        CHECK_SUBJECT        => array(

                RULE_IS_LIKE                => array('check0' => 'message_subject'),

                RULE_IS_NOT_LIKE        => array('check0' => 'message_subject'),

                RULE_IS                                => array('check0' => 'message_subject'),

                RULE_IS_NOT                        => array('check0' => 'message_subject'),

                RULE_BEGINS_WITH        => array('check0' => 'message_subject'),

                RULE_ENDS_WITH                => array('check0' => 'message_subject'),

        ),

        CHECK_SENDER        => array(

                RULE_IS_LIKE                => array('check0' => 'username'),

                RULE_IS_NOT_LIKE        => array('check0' => 'username'),

                RULE_IS                                => array('check0' => 'username'),

                RULE_IS_NOT                        => array('check0' => 'username'),

                RULE_BEGINS_WITH        => array('check0' => 'username'),

                RULE_ENDS_WITH                => array('check0' => 'username'),

                RULE_IS_FRIEND                => array('check0' => 'friend'),

                RULE_IS_FOE                        => array('check0' => 'foe'),

                RULE_IS_USER                => array('check0' => 'author_id'),

                RULE_IS_GROUP                => array('check0' => 'author_in_group'),

        ),

        CHECK_MESSAGE        => array(

                RULE_IS_LIKE                => array('check0' => 'message_text'),

                RULE_IS_NOT_LIKE        => array('check0' => 'message_text'),

                RULE_IS                                => array('check0' => 'message_text'),

                RULE_IS_NOT                        => array('check0' => 'message_text'),

        ),

        CHECK_STATUS        => array(

                RULE_ANSWERED                => array('check0' => 'pm_replied'),

                RULE_FORWARDED                => array('check0' => 'pm_forwarded'),

        ),

        CHECK_TO                => array(

                RULE_TO_GROUP                => array('check0' => 'to', 'check1' => 'bcc', 'check2' => 'user_in_group'),

                RULE_TO_ME                        => array('check0' => 'to', 'check1' => 'bcc'),

        )

);

/**

* This is for defining which condition fields to show for which Rule

*/

$global_rule_conditions = array(

        RULE_IS_LIKE                => 'text',

        RULE_IS_NOT_LIKE        => 'text',

        RULE_IS                                => 'text',

        RULE_IS_NOT                        => 'text',

        RULE_BEGINS_WITH        => 'text',

        RULE_ENDS_WITH                => 'text',

        RULE_IS_USER                => 'user',

        RULE_IS_GROUP                => 'group'

);

/**

* Get all folder

*/

function get_folder($user_id, $folder_id = false)

{

        global $db, $user, $template;

        global $phpbb_root_path, $phpEx;

        $folder = array();

        // Get folder information

        $sql = 'SELECT folder_id, COUNT(msg_id) as num_messages, SUM(pm_unread) as num_unread

                FROM ' . PRIVMSGS_TO_TABLE . "

                WHERE user_id = $user_id

                        AND folder_id <> " . PRIVMSGS_NO_BOX . '

                GROUP BY folder_id';

        $result = $db->sql_query($sql);

        $num_messages = $num_unread = array();

        while ($row = $db->sql_fetchrow($result))

        {

                $num_messages[(int) $row['folder_id']] = $row['num_messages'];

                $num_unread[(int) $row['folder_id']] = $row['num_unread'];

        }

        $db->sql_freeresult($result);

        // Make sure the default boxes are defined

        $available_folder = array(PRIVMSGS_INBOX, PRIVMSGS_OUTBOX, PRIVMSGS_SENTBOX);

        foreach ($available_folder as $default_folder)

        {

                if (!isset($num_messages[$default_folder]))

                {

                        $num_messages[$default_folder] = 0;

                }

                if (!isset($num_unread[$default_folder]))

                {

                        $num_unread[$default_folder] = 0;

                }

        }

        // Adjust unread status for outbox

        $num_unread[PRIVMSGS_OUTBOX] = $num_messages[PRIVMSGS_OUTBOX];

        $folder[PRIVMSGS_INBOX] = array(

                'folder_name'                => $user->lang['PM_INBOX'],

                'num_messages'                => $num_messages[PRIVMSGS_INBOX],

                'unread_messages'        => $num_unread[PRIVMSGS_INBOX]

        );

        // Custom Folder

        $sql = 'SELECT folder_id, folder_name, pm_count

                FROM ' . PRIVMSGS_FOLDER_TABLE . "

                        WHERE user_id = $user_id";

        $result = $db->sql_query($sql);

        while ($row = $db->sql_fetchrow($result))

        {

                $folder[$row['folder_id']] = array(

                        'folder_name'                => $row['folder_name'],

                        'num_messages'                => $row['pm_count'],

                        'unread_messages'        => ((isset($num_unread[$row['folder_id']])) ? $num_unread[$row['folder_id']] : 0)

                );

        }

        $db->sql_freeresult($result);

        $folder[PRIVMSGS_OUTBOX] = array(

                'folder_name'                => $user->lang['PM_OUTBOX'],

                'num_messages'                => $num_messages[PRIVMSGS_OUTBOX],

                'unread_messages'        => $num_unread[PRIVMSGS_OUTBOX]

        );

        $folder[PRIVMSGS_SENTBOX] = array(

                'folder_name'                => $user->lang['PM_SENTBOX'],

                'num_messages'                => $num_messages[PRIVMSGS_SENTBOX],

                'unread_messages'        => $num_unread[PRIVMSGS_SENTBOX]

        );

        // Define Folder Array for template designers (and for making custom folders usable by the template too)

        foreach ($folder as $f_id => $folder_ary)

        {

                $folder_id_name = ($f_id == PRIVMSGS_INBOX) ? 'inbox' : (($f_id == PRIVMSGS_OUTBOX) ? 'outbox' : 'sentbox');

                $template->assign_block_vars('folder', array(

                        'FOLDER_ID'                        => $f_id,

                        'FOLDER_NAME'                => $folder_ary['folder_name'],

                        'NUM_MESSAGES'                => $folder_ary['num_messages'],

                        'UNREAD_MESSAGES'        => $folder_ary['unread_messages'],

                        'U_FOLDER'                        => ($f_id > 0) ? append_sid("{$phpbb_root_path}ucp.$phpEx", 'i=pm&folder=' . $f_id) : append_sid("{$phpbb_root_path}ucp.$phpEx", 'i=pm&folder=' . $folder_id_name),

                        'S_CUR_FOLDER'                => ($f_id === $folder_id) ? true : false,

                        'S_UNREAD_MESSAGES'        => ($folder_ary['unread_messages']) ? true : false,

                        'S_CUSTOM_FOLDER'        => ($f_id > 0) ? true : false)

                );

        }

        if ($folder_id !== false && !isset($folder[$folder_id]))

        {

                trigger_error('UNKNOWN_FOLDER');

        }

        return $folder;

}

/**

* Delete Messages From Sentbox

* we are doing this here because this saves us a bunch of checks and queries

*/

function clean_sentbox($num_sentbox_messages)

{

        global $db, $user, $config;

        // Check Message Limit

        if ($user->data['message_limit'] && $num_sentbox_messages > $user->data['message_limit'])

        {

                // Delete old messages

                $sql = 'SELECT t.msg_id

                        FROM ' . PRIVMSGS_TO_TABLE . ' t, ' . PRIVMSGS_TABLE . ' p

                        WHERE t.msg_id = p.msg_id

                                AND t.user_id = ' . $user->data['user_id'] . '

                                AND t.folder_id = ' . PRIVMSGS_SENTBOX . '

                        ORDER BY p.message_time ASC';

                $result = $db->sql_query_limit($sql, ($num_sentbox_messages - $user->data['message_limit']));

                $delete_ids = array();

                while ($row = $db->sql_fetchrow($result))

                {

                        $delete_ids[] = $row['msg_id'];

                }

                $db->sql_freeresult($result);

                delete_pm($user->data['user_id'], $delete_ids, PRIVMSGS_SENTBOX);

        }

}

/**

* Check Rule against Message Information

*/

function check_rule(&$rules, &$rule_row, &$message_row, $user_id)

{

        global $user, $config;

        if (!isset($rules[$rule_row['rule_check']][$rule_row['rule_connection']]))

        {

                return false;

        }

        $check_ary = $rules[$rule_row['rule_check']][$rule_row['rule_connection']];

        $result = false;

        $check0 = $message_row[$check_ary['check0']];

        switch ($rule_row['rule_connection'])

        {

                case RULE_IS_LIKE:

                        $result = preg_match("/" . preg_quote($rule_row['rule_string'], '/') . '/i', $check0);

                break;

                case RULE_IS_NOT_LIKE:

                        $result = !preg_match("/" . preg_quote($rule_row['rule_string'], '/') . '/i', $check0);

                break;

                case RULE_IS:

                        $result = ($check0 == $rule_row['rule_string']);

                break;

                case RULE_IS_NOT:

                        $result = ($check0 != $rule_row['rule_string']);

                break;

                case RULE_BEGINS_WITH:

                        $result = preg_match("/^" . preg_quote($rule_row['rule_string'], '/') . '/i', $check0);

                break;

                case RULE_ENDS_WITH:

                        $result = preg_match("/" . preg_quote($rule_row['rule_string'], '/') . '$/i', $check0);

                break;

                case RULE_IS_FRIEND:

                case RULE_IS_FOE:

                case RULE_ANSWERED:

                case RULE_FORWARDED:

                        $result = ($check0 == 1);

                break;

                case RULE_IS_USER:

                        $result = ($check0 == $rule_row['rule_user_id']);

                break;

                case RULE_IS_GROUP:

                        $result = in_array($rule_row['rule_group_id'], $check0);

                break;

                case RULE_TO_GROUP:

                        $result = (in_array('g_' . $message_row[$check_ary['check2']], $check0) || in_array('g_' . $message_row[$check_ary['check2']], $message_row[$check_ary['check1']]));

                break;

                case RULE_TO_ME:

                        $result = (in_array('u_' . $user_id, $check0) || in_array('u_' . $user_id, $message_row[$check_ary['check1']]));

                break;

        }

        if (!$result)

        {

                return false;

        }

        switch ($rule_row['rule_action'])

        {

                case ACTION_PLACE_INTO_FOLDER:

                        return array('action' => $rule_row['rule_action'], 'folder_id' => $rule_row['rule_folder_id']);

                break;

                case ACTION_MARK_AS_READ:

                case ACTION_MARK_AS_IMPORTANT:

                        return array('action' => $rule_row['rule_action'], 'pm_unread' => $message_row['pm_unread'], 'pm_marked' => $message_row['pm_marked']);

                break;

                case ACTION_DELETE_MESSAGE:

                        global $db, $auth;

                        // Check for admins/mods - users are not allowed to remove those messages...

                        // We do the check here to make sure the data we use is consistent

                        $sql = 'SELECT user_id, user_type, user_permissions

                                FROM ' . USERS_TABLE . '

                                WHERE user_id = ' . (int) $message_row['author_id'];

                        $result = $db->sql_query($sql);

                        $userdata = $db->sql_fetchrow($result);

                        $db->sql_freeresult($result);

                        $auth2 = new auth();

                        $auth2->acl($userdata);

                        if (!$auth2->acl_get('a_') && !$auth2->acl_get('m_') && !$auth2->acl_getf_global('m_'))

                        {

                                return array('action' => $rule_row['rule_action'], 'pm_unread' => $message_row['pm_unread'], 'pm_marked' => $message_row['pm_marked']);

                        }

                        return false;

                break;

                default:

                        return false;

        }

        return false;

}

/**

* Update user PM count

*/

function update_pm_counts()

{

        global $user, $db;

        // Update unread count

        $sql = 'SELECT COUNT(msg_id) as num_messages

                FROM ' . PRIVMSGS_TO_TABLE . '

                WHERE pm_unread = 1

                        AND folder_id <> ' . PRIVMSGS_OUTBOX . '

                        AND user_id = ' . $user->data['user_id'];

        $result = $db->sql_query($sql);

        $user->data['user_unread_privmsg'] = (int) $db->sql_fetchfield('num_messages');

        $db->sql_freeresult($result);

        // Update new pm count

        $sql = 'SELECT COUNT(msg_id) as num_messages

                FROM ' . PRIVMSGS_TO_TABLE . '

                WHERE pm_new = 1

                        AND folder_id IN (' . PRIVMSGS_NO_BOX . ', ' . PRIVMSGS_HOLD_BOX . ')

                        AND user_id = ' . $user->data['user_id'];

        $result = $db->sql_query($sql);

        $user->data['user_new_privmsg'] = (int) $db->sql_fetchfield('num_messages');

        $db->sql_freeresult($result);

        $db->sql_query('UPDATE ' . USERS_TABLE . ' SET ' . $db->sql_build_array('UPDATE', array(

                'user_unread_privmsg'        => (int) $user->data['user_unread_privmsg'],

                'user_new_privmsg'                => (int) $user->data['user_new_privmsg'],

        )) . ' WHERE user_id = ' . $user->data['user_id']);

        // Ok, here we need to repair something, other boxes than privmsgs_no_box and privmsgs_hold_box should not carry the pm_new flag.

        if (!$user->data['user_new_privmsg'])

        {

                $sql = 'UPDATE ' . PRIVMSGS_TO_TABLE . '

                        SET pm_new = 0

                        WHERE pm_new = 1

                                AND folder_id NOT IN (' . PRIVMSGS_NO_BOX . ', ' . PRIVMSGS_HOLD_BOX . ')

                                AND user_id = ' . $user->data['user_id'];

                $db->sql_query($sql);

        }

}

/**

* Place new messages into appropriate folder

*/

function place_pm_into_folder(&$global_privmsgs_rules, $release = false)

{

        global $db, $user, $config;

        if (!$user->data['user_new_privmsg'])

        {

                return array('not_moved' => 0, 'removed' => 0);

        }

        $user_message_rules = (int) $user->data['user_message_rules'];

        $user_id = (int) $user->data['user_id'];

        $action_ary = $move_into_folder = array();

        $num_removed = 0;

        // Newly processing on-hold messages

        if ($release)

        {

                $sql = 'UPDATE ' . PRIVMSGS_TO_TABLE . '

                        SET folder_id = ' . PRIVMSGS_NO_BOX . '

                        WHERE folder_id = ' . PRIVMSGS_HOLD_BOX . "

                                AND user_id = $user_id";

                $db->sql_query($sql);

        }

        // Get those messages not yet placed into any box

        $retrieve_sql = 'SELECT t.*, p.*, u.username, u.user_id, u.group_id

                FROM ' . PRIVMSGS_TO_TABLE . ' t, ' . PRIVMSGS_TABLE . ' p, ' . USERS_TABLE . " u

                WHERE t.user_id = $user_id

                        AND p.author_id = u.user_id

                        AND t.folder_id = " . PRIVMSGS_NO_BOX . '

                        AND t.msg_id = p.msg_id';

        // Just place into the appropriate arrays if no rules need to be checked

        if (!$user_message_rules)

        {

                $result = $db->sql_query($retrieve_sql);

                while ($row = $db->sql_fetchrow($result))

                {

                        $action_ary[$row['msg_id']][] = array('action' => false);

                }

                $db->sql_freeresult($result);

        }

        else

        {

                $user_rules = $zebra = $check_rows = array();

                $user_ids = $memberships = array();

                // First of all, grab all rules and retrieve friends/foes

                $sql = 'SELECT *

                        FROM ' . PRIVMSGS_RULES_TABLE . "

                        WHERE user_id = $user_id";

                $result = $db->sql_query($sql);

                $user_rules = $db->sql_fetchrowset($result);

                $db->sql_freeresult($result);

                if (sizeof($user_rules))

                {

                        $sql = 'SELECT zebra_id, friend, foe

                                FROM ' . ZEBRA_TABLE . "

                                WHERE user_id = $user_id";

                        $result = $db->sql_query($sql);

                        while ($row = $db->sql_fetchrow($result))

                        {

                                $zebra[$row['zebra_id']] = $row;

                        }

                        $db->sql_freeresult($result);

                }

                // Now build a bare-bone check_row array

                $result = $db->sql_query($retrieve_sql);

                while ($row = $db->sql_fetchrow($result))

                {

                        $check_rows[] = array_merge($row, array(

                                'to'                                => explode(':', $row['to_address']),

                                'bcc'                                => explode(':', $row['bcc_address']),

                                'friend'                        => (isset($zebra[$row['author_id']])) ? $zebra[$row['author_id']]['friend'] : 0,

                                'foe'                                => (isset($zebra[$row['author_id']])) ? $zebra[$row['author_id']]['foe'] : 0,

                                'user_in_group'                => array($user->data['group_id']),

                                'author_in_group'        => array())

                        );

                        $user_ids[] = $row['user_id'];

                }

                $db->sql_freeresult($result);

                // Retrieve user memberships

                if (sizeof($user_ids))

                {

                        $sql = 'SELECT *

                                FROM ' . USER_GROUP_TABLE . '

                                WHERE ' . $db->sql_in_set('user_id', $user_ids) . '

                                        AND user_pending = 0';

                        $result = $db->sql_query($sql);

                        while ($row = $db->sql_fetchrow($result))

                        {

                                $memberships[$row['user_id']][] = $row['group_id'];

                        }

                        $db->sql_freeresult($result);

                }

                // Now place into the appropriate folder

                foreach ($check_rows as $row)

                {

                        // Add membership if set

                        if (isset($memberships[$row['author_id']]))

                        {

                                $row['author_in_group'] = $memberships[$row['user_id']];

                        }

                        // Check Rule - this should be very quick since we have all information we need

                        $is_match = false;

                        foreach ($user_rules as $rule_row)

                        {

                                if (($action = check_rule($global_privmsgs_rules, $rule_row, $row, $user_id)) !== false)

                                {

                                        $is_match = true;

                                        $action_ary[$row['msg_id']][] = $action;

                                }

                        }

                        if (!$is_match)

                        {

                                $action_ary[$row['msg_id']][] = array('action' => false);

                        }

                }

                unset($user_rules, $zebra, $check_rows, $user_ids, $memberships);

        }

        // We place actions into arrays, to save queries.

        $sql = $unread_ids = $delete_ids = $important_ids = array();

        foreach ($action_ary as $msg_id => $msg_ary)

        {

                // It is allowed to execute actions more than once, except placing messages into folder

                $folder_action = $message_removed = false;

                foreach ($msg_ary as $pos => $rule_ary)

                {

                        if ($folder_action && $rule_ary['action'] == ACTION_PLACE_INTO_FOLDER)

                        {

                                continue;

                        }

                        switch ($rule_ary['action'])

                        {

                                case ACTION_PLACE_INTO_FOLDER:

                                        // Folder actions have precedence, so we will remove any other ones

                                        $folder_action = true;

                                        $move_into_folder[(int) $rule_ary['folder_id']][] = $msg_id;

                                break;

                                case ACTION_MARK_AS_READ:

                                        if ($rule_ary['pm_unread'])

                                        {

                                                $unread_ids[] = $msg_id;

                                        }

                                break;

                                case ACTION_DELETE_MESSAGE:

                                        $delete_ids[] = $msg_id;

                                        $message_removed = true;

                                break;

                                case ACTION_MARK_AS_IMPORTANT:

                                        if (!$rule_ary['pm_marked'])

                                        {

                                                $important_ids[] = $msg_id;

                                        }

                                break;

                        }

                }

                // We place this here because it could happen that the messages are doubled if a rule marks a message and then moves it into a specific

                // folder. Here we simply move the message into the INBOX if it gets not removed and also not put into a custom folder.

                if (!$folder_action && !$message_removed)

                {

                        $move_into_folder[PRIVMSGS_INBOX][] = $msg_id;

                }

        }

        // Do not change the order of processing

        // The number of queries needed to be executed here highly depends on the defined rules and are

        // only gone through if new messages arrive.

        // Delete messages

        if (sizeof($delete_ids))

        {

                $num_removed += sizeof($delete_ids);

                delete_pm($user_id, $delete_ids, PRIVMSGS_NO_BOX);

        }

        // Set messages to Unread

        if (sizeof($unread_ids))

        {

                $sql = 'UPDATE ' . PRIVMSGS_TO_TABLE . '

                        SET pm_unread = 0

                        WHERE ' . $db->sql_in_set('msg_id', $unread_ids) . "

                                AND user_id = $user_id

                                AND folder_id = " . PRIVMSGS_NO_BOX;

                $db->sql_query($sql);

        }

        // mark messages as important

        if (sizeof($important_ids))

        {

                $sql = 'UPDATE ' . PRIVMSGS_TO_TABLE . '

                        SET pm_marked = 1 - pm_marked

                        WHERE folder_id = ' . PRIVMSGS_NO_BOX . "

                                AND user_id = $user_id

                                AND " . $db->sql_in_set('msg_id', $important_ids);

                $db->sql_query($sql);

        }

        // Move into folder

        $folder = array();

        if (sizeof($move_into_folder))

        {

                // Determine Full Folder Action - we need the move to folder id later eventually

                $full_folder_action = ($user->data['user_full_folder'] == FULL_FOLDER_NONE) ? ($config['full_folder_action'] - (FULL_FOLDER_NONE*(-1))) : $user->data['user_full_folder'];

                $sql_folder = array_keys($move_into_folder);

                if ($full_folder_action >= 0)

                {

                        $sql_folder[] = $full_folder_action;

                }

                $sql = 'SELECT folder_id, pm_count

                        FROM ' . PRIVMSGS_FOLDER_TABLE . '

                        WHERE ' . $db->sql_in_set('folder_id', $sql_folder) . "

                                AND user_id = $user_id";

                $result = $db->sql_query($sql);

                while ($row = $db->sql_fetchrow($result))

                {

                        $folder[(int) $row['folder_id']] = (int) $row['pm_count'];

                }

                $db->sql_freeresult($result);

                unset($sql_folder);

                if (isset($move_into_folder[PRIVMSGS_INBOX]))

                {

                        $sql = 'SELECT COUNT(msg_id) as num_messages

                                FROM ' . PRIVMSGS_TO_TABLE . "

                                WHERE user_id = $user_id

                                        AND folder_id = " . PRIVMSGS_INBOX;

                        $result = $db->sql_query($sql);

                        $folder[PRIVMSGS_INBOX] = (int) $db->sql_fetchfield('num_messages');

                        $db->sql_freeresult($result);

                }

        }

        // Here we have ideally only one folder to move into

        foreach ($move_into_folder as $folder_id => $msg_ary)

        {

                $dest_folder = $folder_id;

                $full_folder_action = FULL_FOLDER_NONE;

                // Check Message Limit - we calculate with the complete array, most of the time it is one message

                // But we are making sure that the other way around works too (more messages in queue than allowed to be stored)

                if ($user->data['message_limit'] && $folder[$folder_id] && ($folder[$folder_id] + sizeof($msg_ary)) > $user->data['message_limit'])

                {

                        $full_folder_action = ($user->data['user_full_folder'] == FULL_FOLDER_NONE) ? ($config['full_folder_action'] - (FULL_FOLDER_NONE*(-1))) : $user->data['user_full_folder'];

                        // If destination folder itself is full...

                        if ($full_folder_action >= 0 && ($folder[$full_folder_action] + sizeof($msg_ary)) > $user->data['message_limit'])

                        {

                                $full_folder_action = $config['full_folder_action'] - (FULL_FOLDER_NONE*(-1));

                        }

                        // If Full Folder Action is to move to another folder, we simply adjust the destination folder

                        if ($full_folder_action >= 0)

                        {

                                $dest_folder = $full_folder_action;

                        }

                        else if ($full_folder_action == FULL_FOLDER_DELETE)

                        {

                                // Delete some messages. NOTE: Ordered by msg_id here instead of message_time!

                                $sql = 'SELECT msg_id

                                        FROM ' . PRIVMSGS_TO_TABLE . "

                                        WHERE user_id = $user_id

                                                AND folder_id = $dest_folder

                                        ORDER BY msg_id ASC";

                                $result = $db->sql_query_limit($sql, (($folder[$dest_folder] + sizeof($msg_ary)) - $user->data['message_limit']));

                                $delete_ids = array();

                                while ($row = $db->sql_fetchrow($result))