<?php
/**
* Model for moderators.
*
* @package XenForo_Moderator
*/
class XenForo_Model_Moderator extends XenForo_Model
{
/**
* Gets a general moderator records based on user ID.
*
* @param integer $userId
*
* @return array|false
*/
public function getGeneralModeratorByUserId($userId)
{
return $this->_getDb()->fetchRow('
SELECT moderator.*, user.username
FROM xf_moderator AS moderator
INNER JOIN xf_user AS user ON (user.user_id = moderator.user_id)
WHERE moderator.user_id = ?
', $userId);
}
/**
* Gets all general moderators, potentially limited by super moderator status.
*
* @param boolean|null $isSuperModerator If not null, limits to super or non-super mods only
*
* @return array Format: [user id] => info
*/
public function getAllGeneralModerators($isSuperModerator = null)
{
if ($isSuperModerator === null)
{
$moderatorClause = '1=1';
}
else if ($isSuperModerator)
{
$moderatorClause = 'moderator.is_super_moderator = 1';
}
else
{
$moderatorClause = 'moderator.is_super_moderator = 0';
}
return $this->fetchAllKeyed('
SELECT moderator.*, user.username,
user.avatar_date, user.gravatar
FROM xf_moderator AS moderator
INNER JOIN xf_user AS user ON (user.user_id = moderator.user_id)
WHERE ' . $moderatorClause . '
ORDER BY user.username
', 'user_id');
}
/**
* Gets a matching content moderator.
*
* @param array $conditions
* @param array $fetchOptions
*
* @return array|false
*/
public function getContentModerator(array $conditions, array $fetchOptions = array())
{
$moderators = $this->getContentModerators($conditions, $fetchOptions);
return reset($moderators);
}
/**
* Gets all matching content moderators.
*
* @param array $conditions
* @param array $fetchOptions
*
* @return array Format: [moderator id] => info
*/
public function getContentModerators(array $conditions = array(), array $fetchOptions = array())
{
$whereConditions = $this->prepareContentModeratorConditions($conditions, $fetchOptions);
$limitOptions = $this->prepareLimitFetchOptions($fetchOptions);
$sqlClauses = $this->prepareContentModeratorFetchOptions($fetchOptions);
return $this->fetchAllKeyed($this->limitQueryResults(
'
SELECT moderator_content.*, user.username
' . $sqlClauses['selectFields'] . '
FROM xf_moderator_content AS moderator_content
INNER JOIN xf_user AS user ON (user.user_id = moderator_content.user_id)
' . $sqlClauses['joinTables'] . '
WHERE ' . $whereConditions . '
' . $sqlClauses['orderClause'] . '
', $limitOptions['limit'], $limitOptions['offset']
), 'moderator_id');
}
/**
* Prepares the set of content moderator conditions.
*
* @param array $conditions
* @param array $fetchOptions
*
* @return string SQL clause value for conditions
*/
public function prepareContentModeratorConditions(array $conditions, array &$fetchOptions)
{
$sqlConditions = array();
$db = $this->_getDb();
if (isset($conditions['moderator_id']))
{
$sqlConditions[] = 'moderator_content.moderator_id = ' . $db->quote($conditions['moderator_id']);
}
if (!empty($conditions['content']))
{
if (is_array($conditions['content']))
{
$sqlConditions[] = 'moderator_content.content_type = ' . $db->quote($conditions['content'][0]);
$sqlConditions[] = 'moderator_content.content_id = ' . $db->quote($conditions['content'][1]);
}
else
{
$sqlConditions[] = 'moderator_content.content_type = ' . $db->quote($conditions['content']);
}
}
if (isset($conditions['user_id']))
{
$sqlConditions[] = 'moderator_content.user_id = ' . $db->quote($conditions['user_id']);
}
return $this->getConditionsForClause($sqlConditions);
}
/**
* Prepares the content moderator fetch options into select fields, joins, and ordering.
*
* @param array $fetchOptions
*
* @return array Keys: selectFields, joinTables, orderClause
*/
public function prepareContentModeratorFetchOptions(array $fetchOptions)
{
$selectFields = '';
$joinTables = '';
$orderBy = '';
if (isset($fetchOptions['order']))
{
switch ($fetchOptions['order'])
{
case 'username':
$orderBy = 'user.username';
break;
}
}
else
{
$orderBy = 'user.username';
}
return array(
'selectFields' => $selectFields,
'joinTables' => $joinTables,
'orderClause' => ($orderBy ? "ORDER BY $orderBy" : '')
);
}
/**
* Gets a content moderator by its unique ID.
*
* @param integer $id
*
* @return array|false
*/
public function getContentModeratorById($id)
{
return $this->getContentModerator(array('moderator_id' => $id));
}
/**
* Gets a content moderator by the unique combination of content and user ID.
*
* @param string $contentType
* @param integer $contentId
* @param integer $userId
*
* @return array|false
*/
public function getContentModeratorByContentAndUserId($contentType, $contentId, $userId)
{
return $this->getContentModerator(array(
'content' => array($contentType, $contentId),
'user_id' => $userId
));
}
/**
* Gets all content moderator info for a specified user ID
*
* @param integer $userId
*
* @return array Format: [moderator id] => info
*/
public function getContentModeratorsByUserId($userId)
{
return $this->getContentModerators(
array('user_id' => $userId),
array('order' => false)
);
}
/**
* Inserts or updates the necessary content moderator record.
*
* @param integer $userId
* @param string $contentType
* @param integer $contentId
* @param array $modPerms List of moderator permissions to apply to this content
* @param array $extra Extra info. Includes general_moderator_permissions and extra_user_group_ids
*
* @return integer Moderator ID
*/
public function insertOrUpdateContentModerator($userId, $contentType, $contentId, array $modPerms, array $extra = array())
{
$contentModerator = $this->getContentModeratorByContentAndUserId($contentType, $contentId, $userId);
$dw = XenForo_DataWriter::create('XenForo_DataWriter_ModeratorContent');
if ($contentModerator)
{
$dw->setExistingData($contentModerator, true);
}
else
{
$dw->set('content_type', $contentType);
$dw->set('content_id', $contentId);
$dw->set('user_id', $userId);
}
if (isset($extra['general_moderator_permissions']))
{
$dw->setExtraData(XenForo_DataWriter_ModeratorContent::DATA_GENERAL_PERMISSIONS, $extra['general_moderator_permissions']);
}
if (isset($extra['extra_user_group_ids']))
{
$dw->setExtraData(XenForo_DataWriter_ModeratorContent::DATA_EXTRA_GROUP_IDS, $extra['extra_user_group_ids']);
}
if (isset($extra['is_staff']))
{
$dw->setOption(XenForo_DataWriter_ModeratorContent::OPTION_SET_IS_STAFF, $extra['is_staff']);
}
$dw->set('moderator_permissions', $modPerms);
$dw->save();
return $dw->get('moderator_id');
}
/**
* Inserts or updates the necessary general moderator record.
*
* @param integer $userId
* @param array $modPerms General moderator permissions. Does not include content-specific super mod perms.
* @param boolean|null $isSuperModerator If non-null, the new super moderator setting
* @param array $extra Extra data, including extra_user_group_ids and super_moderator_permissions
*
* @return integer Moderator ID
*/
public function insertOrUpdateGeneralModerator($userId, array $modPerms, $isSuperModerator = null, array $extra = array())
{
$moderator = $this->getGeneralModeratorByUserId($userId);
$dw = XenForo_DataWriter::create('XenForo_DataWriter_Moderator');
if ($moderator)
{
$dw->setExistingData($moderator, true);
}
else
{
$dw->set('user_id', $userId);
}
if ($isSuperModerator !== null)
{
$dw->set('is_super_moderator', $isSuperModerator);
}
if (isset($extra['extra_user_group_ids']))
{
$dw->set('extra_user_group_ids', $extra['extra_user_group_ids']);
}
if (isset($extra['is_staff']))
{
$dw->setOption(XenForo_DataWriter_Moderator::OPTION_SET_IS_STAFF, $extra['is_staff']);
}
if (isset($extra['super_moderator_permissions']))
{
$modPerms = $this->mergeModeratorPermissions($modPerms, $extra['super_moderator_permissions']);
}
$dw->set('moderator_permissions', $modPerms);
$dw->save();
return $userId;
}
/**
* Merges 2 sets of "grouped" moderator permissions.
*
* @param array $modPerms Existing permissions like [group][permission] => info
* @param array $merge Merging permissions like [group][permission] => info
*
* @return array Merged set
*/
public function mergeModeratorPermissions(array $modPerms, array $merge)
{
foreach ($merge AS $generalGroupId => $generalGroup)
{
foreach ($generalGroup AS $generalId => $general)
{
$modPerms[$generalGroupId][$generalId] = $general;
}
}
return $modPerms;
}
/**
* Merges only general moderator permissions into a set of grouped permissions.
* The initial set may contain more than general moderator permissions.
*
* @param array $modPerms Existing permissions like [group][permission] => info
* @param array $merge Merging permissions like [group][permission] => info
*
* @return array Merged set
*/
public function mergeGeneralModeratorPermissions(array $modPerms, array $merge)
{
$generalModeratorPermissions = $this->getGeneralModeratorPermissions();
foreach ($merge AS $generalGroupId => $generalGroup)
{
foreach ($generalGroup AS $generalId => $general)
{
if (isset($generalModeratorPermissions[$generalGroupId][$generalId]))
{
$modPerms[$generalGroupId][$generalId] = $general;
}
}
}
return $modPerms;
}
/**
* Merges a set of permission differences for setting/updating permission entries.
*
* @param array|string $newPermissions Set of new permissions (ie, new effective value). May be serialized.
* @param array|string $existingPermissions Set of old permissions (ie, old effective value). May be serialized.
* @param string $allowValue If a permission is to be allowed, the name of the allow state (allow or content_allow).
*
* @return array New effective permissions, with non-matching old values returned to "unset" state
*/
public function getModeratorPermissionsForUpdate($newPermissions, $existingPermissions, $allowValue = 'allow')
{
$finalPermissions = array();
if (is_string($newPermissions))
{
$newPermissions = XenForo_Helper_Php::safeUnserialize($newPermissions);
}
else if (!is_array($newPermissions))
{
$newPermissions = array();
}
foreach ($newPermissions AS $permissionGroupId => $permissionGroup)
{
foreach ($permissionGroup AS $permissionId => $value)
{
$finalPermissions[$permissionGroupId][$permissionId] = $allowValue;
}
}
if (is_string($existingPermissions))
{
$existingPermissions = XenForo_Helper_Php::safeUnserialize($existingPermissions);
}
else if (!is_array($existingPermissions))
{
$existingPermissions = array();
}
foreach ($existingPermissions AS $permissionGroupId => $permissionGroup)
{
foreach ($permissionGroup AS $permissionId => $value)
{
if (!isset($finalPermissions[$permissionGroupId][$permissionId]))
{
$finalPermissions[$permissionGroupId][$permissionId] = 'unset';
}
}
}
return $finalPermissions;
}
/**
* Gets the permission interface group IDs that apply to all general moderators.
*
* @return array
*/
public function getGeneralModeratorInterfaceGroupIds()
{
return array('generalModeratorPermissions', 'profilePostModeratorPermissions', 'conversationModeratorPermissions');
}
/**
* Gets the permission interface group IDs that apply to the moderator in question.
* If a content moderator, only includes general and that content's groups;
* if a super moderator, includes all matching groups;
* otherwise, includes only the general groups.
*
* @param array $moderator
*
* @return array List of interface group IDs
*/
public function getModeratorInterfaceGroupIds(array $moderator)
{
$interfaceGroupIds = $this->getGeneralModeratorInterfaceGroupIds();
if (!empty($moderator['content_type']))
{
$handler = $this->getContentModeratorHandlers($moderator['content_type']);
$interfaceGroupIds = array_merge($interfaceGroupIds, $handler->getModeratorInterfaceGroupIds());
}
else if (!empty($moderator['is_super_moderator']))
{
foreach($this->getContentModeratorHandlers() AS $handler)
{
$interfaceGroupIds = array_merge($interfaceGroupIds, $handler->getModeratorInterfaceGroupIds());
}
}
return $interfaceGroupIds;
}
/**
* Gets all general moderator permissions.
*
* @return array Format: [group id][permission id] => permission info
*/
public function getGeneralModeratorPermissions()
{
return $this->getModeratorPermissions($this->getGeneralModeratorInterfaceGroupIds());
}
/**
* Gets moderator permissions from the specified interface groups.
*
* @param array $interfaceGroupIds
*
* @return array Format: [group id][permission id] => permission info
*/
public function getModeratorPermissions(array $interfaceGroupIds)
{
$permissions = $this->_getLocalCacheData('permissions');
if ($permissions === false)
{
$permissions = $this->_getPermissionModel()->getAllPermissions();
$this->setLocalCacheData('permissions', $permissions);
}
$validPermissions = array();
foreach ($permissions AS $permission)
{
if ($permission['permission_type'] != 'flag')
{
continue;
}
if (in_array($permission['interface_group_id'], $interfaceGroupIds))
{
$validPermissions[$permission['permission_group_id']][$permission['permission_id']] = $permission;
}
}
return $validPermissions;
}
/**
* Gets the necessary moderator permissions and interface groups for the UI,
*
* @param array $interfaceGroupIds List of interface groups to pull permissions from
* @param array $existingPermissions Existing permissions ([group id][permission id]), for selected values
*
* @return array List of interface groups, with "permissions" key (flat array)
*/
public function getModeratorPermissionsForInterface(array $interfaceGroupIds, array $existingPermissions = array())
{
$permissionModel = $this->_getPermissionModel();
$interfaceGroups = $permissionModel->getAllPermissionInterfaceGroups();
foreach ($interfaceGroups AS $interfaceGroupId => &$interfaceGroup)
{
if (!in_array($interfaceGroupId, $interfaceGroupIds))
{
unset($interfaceGroups[$interfaceGroupId]);
}
else
{
$interfaceGroup = $permissionModel->preparePermissionInterfaceGroup($interfaceGroup);
}
}
foreach ($this->getModeratorPermissions($interfaceGroupIds) AS $groupId => $group)
{
foreach ($group AS $permissionId => $permission)
{
if (isset($interfaceGroups[$permission['interface_group_id']]))
{
$permission = $permissionModel->preparePermission($permission);
$interfaceGroups[$permission['interface_group_id']]['permissions'][] = array(
'label' => $permission['title'],
'name' => "[$permission[permission_group_id]][$permission[permission_id]]",
'selected' => !empty($existingPermissions[$permission['permission_group_id']][$permission['permission_id']])
);
}
}
}
return $interfaceGroups;
}
/**
* Gets the list of possible extra user groups in "option" format.
*
* @param string|array $extraGroupIds List of existing extra group IDs; may be serialized.
*
* @return array List of user group options (keys: label, value, selected)
*/
public function getExtraUserGroupOptions($extraGroupIds)
{
return $this->getModelFromCache('XenForo_Model_UserGroup')->getUserGroupOptions(
$extraGroupIds
);
}
/**
* Gets all content moderator handler objects, or one for the specified content type.
*
* @param string|array|null $limitContentType If specified, gets handler for specified type(s) only
*
* @return XenForo_ModeratorHandler_Abstract|array|false
*/
public function getContentModeratorHandlers($limitContentType = null)
{
$contentTypes = $this->_getLocalCacheData('moderatorHandlerPairs');
if ($contentTypes === false)
{
$contentTypes = $this->getContentTypesWithField('moderator_handler_class');
$this->setLocalCacheData('moderatorHandlerPairs', $contentTypes);
}
if (is_string($limitContentType))
{
if (isset($contentTypes[$limitContentType]))
{
$class = $contentTypes[$limitContentType];
if (!class_exists($class))
{
return false;
}
$class = XenForo_Application::resolveDynamicClass($class);
return new $class();
}
else
{
return false;
}
}
else if (is_array($limitContentType))
{
$handlers = array();
foreach ($contentTypes AS $contentType => $handlerClass)
{
if (in_array($contentType, $limitContentType))
{
if (!class_exists($handlerClass))
{
continue;
}
$handlerClass = XenForo_Application::resolveDynamicClass($handlerClass);
$handlers[$contentType] = new $handlerClass();
}
}
}
else
{
$handlers = array();
foreach ($contentTypes AS $contentType => $handlerClass)
{
if (!class_exists($handlerClass))
{
continue;
}
$handlerClass = XenForo_Application::resolveDynamicClass($handlerClass);
$handlers[$contentType] = new $handlerClass();
}
}
return $handlers;
}
/**
* Goes through a list of content moderators and fetches the content titles for all of them.
* Items that are not returned by the handler will not have a "title" key.
*
* @param array $moderators
*
* @return array Moderators with "title" key where given
*/
public function addContentTitlesToModerators(array $moderators)
{
$types = array();
foreach ($moderators AS $key => $moderator)
{
if (!$moderator['content_type'])
{
continue;
}
$types[$moderator['content_type']][$key] = $moderator['content_id'];
}
if ($types)
{
$handlers = $this->getContentModeratorHandlers(array_keys($types));
foreach ($handlers AS $contentType => $handler)
{
$titles = $handler->getContentTitles($types[$contentType]);
foreach ($titles AS $key => $title)
{
$moderators[$key]['title'] = $title;
}
}
}
return $moderators;
}
/**
* Fetches an array containing $value for the value of each permission.
* Useful for automatically populating super moderator records with a full permission set.
*
* @param mixed Value for every permission
*
* @return array $permissionSet[$groupId][$permId] = $value;
*/
public function getFullPermissionSet($value = true)
{
$permissionSet = array();
foreach ($this->getModeratorPermissions($this->getModeratorInterfaceGroupIds(array('is_super_moderator' => true))) AS $groupId => $group)
{
foreach ($group AS $permId => $perm)
{
$permissionSet[$groupId][$permId] = $value;
}
}
return $permissionSet;
}
/**
* Returns the total number of members who are moderators
* Note: distinct on user_id
*
* @return integer
*/
public function countModerators()
{
return $this->_getDb()->fetchOne('SELECT COUNT(*) FROM xf_moderator');
}
/**
* @return XenForo_Model_Permission
*/
protected function _getPermissionModel()
{
return $this->getModelFromCache('XenForo_Model_Permission');
}
}