Поддержка серверов

TASKS: методы, функции, константы класса Битрикс


Блог разработчика

9 августа 2016 ResizeImageGet и простой водяной знак налету

Сегодня поговорим о том как проще всего воткнуть водяной знак на картинки в Битрикс. Например, на все изображения каталога.

21 июля 2016 Добавление вкладки в CRM коробки Битрикс24

В этом посте я покажу, как легко и просто добавить вкладку в сущность CRM. И не просто добавить, а вывести там свой контент.

21 июля 2016 Как просто обращаться из коробки Битрикс24 на сайт на базе Битрикс

К примеру вам хочется внутренним скриптом дернуть с сайта-магазина информацию, которая там, в свою очередь, закрыта некоторыми правами. Например, админскими. Можно конечно мутить свой REST, или иной формат общения, но проще всего воспользоваться штатным инструментом:

События модуля tasks

СобытиеВызывается
OnBeforeTaskNotificationSendCTaskNotifications::fireMessageEvent
OnTaskToggleFavoriteCTaskItem::proceedAction
OnBaseAllowedActionsMapInitCTaskItem::getBaseAllowedActions
OnAfterCommentAddCTaskComments::fireOnAfterCommentAddEvent
OnTaskReminderAddCTaskReminders::Add
OnBeforeTaskElapsedTimeAddCTaskElapsedTime::Add
OnTaskElapsedTimeAddCTaskElapsedTime::Add
OnBeforeTaskElapsedTimeUpdateCTaskElapsedTime::Update
OnTaskElapsedTimeUpdateCTaskElapsedTime::Update
OnBeforeTaskElapsedTimeDeleteCTaskElapsedTime::Delete
OnTaskElapsedTimeDeleteCTaskElapsedTime::Delete
OnBeforeTaskAddCTasks::Add
OnTaskAddCTasks::Add
OnBeforeTaskUpdateCTasks::Update
OnTaskUpdateCTasks::Update
OnBeforeTaskDeleteCTasks::Delete
OnTaskDeleteCTasks::Delete
OnBeforeTaskZombieDeleteCTasks::terminateZombie
OnTaskZombieDeleteCTasks::terminateZombie
OnAfterCommentComment::fireEvent

Константы модуля tasks

КонстантаПроверяется
FORMAT_DATEUI::formatDateTime
SITE_SERVER_NAMEtasksServerName
LANGUAGE_IDCTasksTools::getPluralForm
BX_COMP_MANAGED_CACHESocialNetwork::getLogDestination
FORMAT_DATETIMEUI::getDateTimeFormat

Список функций и методов модуля tasks

Метод
TasksException::checkIsActionNotAllowed()
TasksException::checkOfType($type)
TasksException::dumpAuxError()
TasksException::__construct($message = false, $code = 0)
TasksException::renderErrorCode($e)
CTasksPerHitOption::set($moduleId, $optionName, $value)
CTasksPerHitOption::get($moduleId, $optionName)
CTasksPerHitOption::getHitTimestamp()
CTasksPerHitOption::managePerHitOptions($operation, $moduleId, $optionName, $value = null)
tasksFormatDate($in_date)
tasksPeriodToStr($arParams)
taskMessSuffix($number)
tasksFormatName($name, $lastName, $login, $secondName = "", $nameTemplate = "", $bEscapeSpecChars = false)
tasksFormatNameShort($name, $lastName, $login, $secondName = "", $nameTemplate = "", $bEscapeSpecChars = false)
tasksFormatHours($hours)
tasksTimeCutZeros($time)
tasksGetItemMenu($task, $arPaths, $site_id = SITE_ID, $bGantt = false, $top = false, $bSkipJsMenu = false, array $params = array())
tasksRenderListItem(N/A)
templatesGetListItemActions($template, $arPaths)
templatesRenderListItem($template, $arPaths, $depth = 0, $plain = false, $defer = false, $nameTemplate = "")
tasksRenderJSON(N/A)
tasksJSDateObject($date, $top = false)
tasksStatus2String($status)
tasksServerName($server_name = false)
tasksGetLastSelected($arManagers, $bSubordinateOnly = false, $nameTemplate = "")
tasksGetFilter($fieldName)
tasksPredefinedFilters($userID, $roleFilterSuffix = "")
ShowInFrame(&$component, $bShowError = false, $errText = '')
__checkForum($forumID)
deleteUploadedFiles($arFileIDs)
addUploadedFiles($arFileIDs)
cleanupUploadedFiles()
tasksFormatFileSize($in)
CTaskCountersProcessorHomeostasis::injectMarker($arFilter, $curSection, $counterId, $userId)
CTaskCountersProcessorHomeostasis::calcFilterChecksum($arFilter)
CTaskCountersProcessorHomeostasis::onTaskGetList($arFilter, $tasksCountInList)
CTaskCountersProcessorHomeostasis::pendCountersRecalculation()
CTaskCountersProcessorHomeostasis::onExpirityRecountAgent()
CTaskCountersProcessorHomeostasis::onCalculationComplete()
CTaskCountersProcessorHomeostasis::getCountersRecheckForSubTasksNeed()
CTaskListState::getInstance($userId)
CTaskListState::__construct($userId)
CTaskListState::getRawState()
CTaskListState::setRawState($newState)
CTaskListState::saveState()
CTaskListState::resetState()
CTaskListState::isSectionExists($sectionId)
CTaskListState::setSection($sectionId)
CTaskListState::getSection()
CTaskListState::setUserRole($roleId)
CTaskListState::getUserRole()
CTaskListState::setViewMode($viewId)
CTaskListState::getViewMode()
CTaskListState::switchOnSubmode($submodeId)
CTaskListState::switchOffSubmode($submodeId)
CTaskListState::isSubmode($submodeId)
CTaskListState::isCategoryExists($categoryId)
CTaskListState::setTaskCategory($categoryId)
CTaskListState::getTaskCategory()
CTaskListState::setViewParameter($code, $value, $view = false)
CTaskListState::getViewParameters($view = false)
CTaskListState::setState(array $state = array())
CTaskListState::getState()
CTaskListState::getSubmodes()
CTaskListState::switchSubmode($submodeId, $switchOn = false)
CTaskListState::replaceTocKeysToStrings($input)
CTaskListState::getAllowedTaskCategories()
CTaskListState::getKnownSubmodes()
CTaskListState::getAllowedViewModes()
CTaskListState::getKnownRoles()
CTaskListState::getKnownSections()
CTaskListState::resolveConstantCodename($constant)
CTaskListState::getSubmodeName($submodeId)
CTaskListState::resolveSubmodeName($submodeId)
CTaskListState::getRoleName($submodeId)
CTaskListState::resolveRoleName($roleId, $alternate = false)
CTaskListState::getViewName($submodeId)
CTaskListState::resolveViewName($viewId, $shortName = false)
CTaskListState::getTaskCategoryName($categoryId)
CTaskListState::resolveTaskCategoryName($categoryId)
CTaskListState::encodeState($state)
CTaskListState::decodeState($state)
CTaskListState::__clone()
CTaskListState::__wakeup()
CTaskCountersProcessor::enumCountersIds()
CTaskCountersProcessor::enumProblemCountersIds()
CTaskCountersProcessor::getInstance()
CTaskCountersProcessor::__construct()
CTaskCountersProcessor::agent($offset = 0)
CTaskCountersProcessor::ensureAgentExists()
CTaskCountersProcessor::countExpiredAndExpiredSoonTasks($offset = 0)
CTaskCountersProcessor::onBeforeTaskAdd(&$arFields, $effectiveUserId)
CTaskCountersProcessor::onAfterTaskAdd($arFields)
CTaskCountersProcessor::onBeforeTaskDelete($taskId, $arFields)
CTaskCountersProcessor::onAfterTaskDelete($arFields)
CTaskCountersProcessor::onBeforeTaskViewedFirstTime($taskId, $userId, $onTaskAdd)
CTaskCountersProcessor::onAfterTaskViewedFirstTime($taskId, $userId, $onTaskAdd)
CTaskCountersProcessor::onBeforeTaskUpdate($taskId, $arTask, &$arFields)
CTaskCountersProcessor::onAfterTaskUpdate($arPrevFields, $arNewFields)
CTaskCountersProcessor::isCompletedStatus($status)
CTaskCountersProcessor::isNewStatus($status)
CTaskCountersProcessor::isDeadlineExpired($deadline)
CTaskCountersProcessor::isDeadlinePresent($deadline)
CTaskCountersProcessor::isDeadlineExpiredSoon($deadline)
CTaskCountersProcessor::getAdminId()
CTaskCountersProcessor::recountQuery(array $userIds)
CTaskCountersProcessor::recountExpiredQuery($op)
CTaskCountersProcessor::recountMembersQuery()
CTaskCountersProcessor::setCounter($type, array $data, array $userIDs)
CTaskCountersProcessor::getCounter($userId, $type)
CTaskCountersProcessor::reset()
CTaskCountersProcessor::processRecalculateMyTasks(array $userIds)
CTaskCountersProcessor::getEdgeDateTime()
CTaskCountersProcessor::getNowDateTime()
CTaskCountersProcessor::getExpiredSoonEdgeDateTime()
CTaskCountersProcessor::processRecalculateMyTasksExpired(array $userIds)
CTaskCountersProcessor::processRecalculateMyTasksExpiredSoon(array $userIds)
CTaskCountersProcessor::processRecalculateMyTasksNew($userId)
CTaskCountersProcessor::debug($userId, $filter, $category, $query, $userIds = array())
CTaskCountersProcessor::processRecalculateMyTasksWithoutDeadline(array $userIds)
CTaskCountersProcessor::processRecalculateAccomplices(array $userIds)
CTaskCountersProcessor::processRecalculateAccomplicesExpired(array $userIds)
CTaskCountersProcessor::processRecalculateAccomplicesExpiredSoon(array $userIds)
CTaskCountersProcessor::processRecalculateAccomplicesNew($userId)
CTaskCountersProcessor::processRecalculateOriginators(array $userIds)
CTaskCountersProcessor::processRecalculateOriginatorsExpired(array $userIds)
CTaskCountersProcessor::processRecalculateOriginatorsWithoutDeadline(array $userIds)
CTaskCountersProcessor::processRecalculateAuditors(array $userIds)
CTaskCountersProcessor::processRecalculateAuditorsExpired(array $userIds)
CTaskCountersProcessor::processRecalculateOriginatorsWaitCtrl(array $userIds)
CTaskCountersProcessor::processRecalculateTotal(array $userIds)
CTaskTimerManager::onAfterTMEntryUpdate(/** @noinspection PhpUnusedParameterInspection */ $id, $arFields)
CTaskTimerManager::onBeforeTaskUpdate(/** @noinspection PhpUnusedParameterInspection */$id, $arFields, $arTask)
CTaskTimerManager::onBeforeTaskDelete($id, $arTask)
CTaskTimerManager::stopTimerForUsers($id, $users)
CTaskTimerManager::getLastTimer($bResetStaticCache = true)
CTaskTimerManager::getRunningTask($bResetStaticCache = true)
CTaskTimerManager::start($taskId)
CTaskTimerManager::stop($taskId = 0)
CTaskTimerManager::getInstance($userId)
CTaskTimerManager::__construct($userId)
CTaskTimerManager::__wakeup()
CTaskTimerManager::__sleep()
CTaskTimerManager::__clone()
CTaskDependence::CheckFields(&$arFields)
CTaskDependence::Add($arFields)
CTaskDependence::Delete($TASK_ID, $DEPENDS_ON_ID)
CTaskDependence::GetFilter($arFilter)
CTaskDependence::GetList($arOrder, $arFilter)
CTaskDependence::DeleteByDependsOnID($DEPENDS_ON)
CTaskDependence::DeleteByTaskID($TASK_ID)
CTaskCommentItem::add(CTaskItemInterface $oTaskItem, $arFields)
CTaskCommentItem::update($arFields)
CTaskCommentItem::delete()
CTaskCommentItem::isActionAllowed($actionId)
CTaskCommentItem::fetchListFromDb($taskData, $arOrder = array(), $arFilter = array())
CTaskCommentItem::fetchDataFromDb($taskId, $itemId)
CTaskCommentItem::runRestMethod(N/A)
CTaskCommentItem::onEventFilter($arParams, $arHandler)
CTaskCommentItem::getManifest()
CTaskCountersNotifier::onAfterTimeManagerDayStart($arData)
CTaskCountersNotifier::getTasksListLink($userId)
CTasksTools::getOccurAsUserId()
CTasksTools::setOccurAsUserId($userId = 'get key')
CTasksTools::getMessagePlural($n, $msgId, $arReplace = false)
CTasksTools::getPluralForm($n, $returnFalseForUnknown = false)
CTasksTools::getTimeZoneOffset($userId = false)
CTasksTools::stripZeroTime($dateTimeStr)
CTasksTools::isIntegerValued($i)
CTasksTools::genUuid($brackets = true)
CTasksTools::__call($name, $arguments)
CTasksTools::__callStatic($name, $arguments)
CTasksTools::IsIphoneOrIpad()
CTasksTools::FormatDatetimeBeauty($in, $arParams = array()
CTasksTools::SanitizeHtmlDescriptionIfNeed($rawHtml)
CTasksTools::HasUserReadAccessToGroup($userId, $groupId)
CTasksTools::IsIntranetUser($userId)
CTasksTools::FixForumCommentURL($arData)
CTasksTools::isAdmin($userId = null)
CTasksTools::isPortalB24Admin($userId = null)
CTasksTools::isAnyAdmin($userId = null)
CTasksTools::GetCommanderInChief()
CTasksTools::ListTasksForumsAsArray()
CTasksTools::GetForumIdForIntranet()
CTasksTools::GetForumIdForExtranet()
CTasksTools::TryToDetermineForumIdForIntranet()
CTasksTools::TryToDetermineForumIdForExtranet()
CTasksTools::GetForumIdByXMLID($XML_ID)
CTasksTools::GetOptionPathTaskUserEntry($siteId, $defaultValue)
CTasksTools::GetOptionPathTaskGroupEntry($siteId, $defaultValue)
CTasksTools::GetOptionPathTaskXXXEntry($nameComponent, $siteId, $defaultValue)
CTasksTools::getRandFunction()
CTasksTools::getPopupOptions()
CTasksTools::savePopupOptions($value)
CTaskRestService::onRestServiceBuildDescription()
CTaskRestService::tasks_extended_meta_occurInLogsAs($args)
CTaskRestService::tasks_extended_meta_setAnyStatus($args)
CTaskRestService::onEventFilter($arParams, $arHandler)
CTaskRestService::__callStatic($transitMethodName, $args)
CTaskRestService::getNavData($start, $bORM = false)
CTaskRestService::_init()
CTaskRestService::_emitError($arMessages = array())
CTaskRestService::getAllowedAggregateCombos(array $functions, array $columns)
CTaskRestService::_parseReturnValue($className, $methodName, $returnValue, $params)
CTaskRestService::_filterArrayByAllowedKeys($arData, $arAllowedKeys, $arDateFields = array())
CTaskRestService::_parseRestParams($className, $methodName, $inArgs)
CTaskTemplates::GetErrors()
CTaskTemplates::CheckFields(&$arFields, $ID = false, $arParams = array())
CTaskTemplates::removeAgents($templateId)
CTaskTemplates::Add($arFields, $arParams = array())
CTaskTemplates::Update($ID, $arFields, $arParams = array())
CTaskTemplates::Delete($ID, array $parameters = array())
CTaskTemplates::GetList($arOrder, $arFilter, $arNavParams = array(), $arParams = array(), $arSelect = array())
CTaskTemplates::getAccessSql($arParams)
CTaskTemplates::GetCount($includeSubtemplates = false)
CTaskTemplates::GetFilter($arFilter, $arParams)
CTaskTemplates::GetByID($ID, $arParams = array())
CTaskTemplates::parseReplicationParams(array $params = array())
CTaskTemplates::parseTypeSelector($type)
CTaskFilterCtrl::__construct($userId, $bGroupMode = false)
CTaskFilterCtrl::__clone()
CTaskFilterCtrl::__wakeup()
CTaskFilterCtrl::getInstance($userId, $bGroupMode = false)
CTaskFilterCtrl::fetchFilterPresets()
CTaskFilterCtrl::listFilterPresets($bTreeMode = false)
CTaskFilterCtrl::listFilterSpecialPresets()
CTaskFilterCtrl::convertPresetsListToTree($arPresets)
CTaskFilterCtrl::convertPresetsListToTreeHelper($arPresets, $curRoot)
CTaskFilterCtrl::getSelectedFilterPresetId()
CTaskFilterCtrl::switchFilterPreset($presetId)
CTaskFilterCtrl::getSelectedFilterPresetCondition()
CTaskFilterCtrl::checkExistsPresetById($presetId)
CTaskFilterCtrl::getFilterPresetConditionById($presetId)
CTaskFilterCtrl::getSelectedFilterPresetName()
CTaskFilterCtrl::createPreset($arPresetData)
CTaskFilterCtrl::replacePreset($presetId, $arPresetData)
CTaskFilterCtrl::addOrReplacePreset($arPresetData, $presetId = null)
CTaskFilterCtrl::removePreset($presetId)
CTaskFilterCtrl::reloadPresetsCache()
CTaskFilterCtrl::getManifest()
CTaskFilterCtrl::importFilterDataFromJs(N/A)
CTaskFilterCtrl::exportFilterDataForJs($presetId)
CTaskFilterCtrl::convertItemForImport($arItem)
CTaskFilterCtrl::convertItemForExport($arItem)
CTaskFilterCtrl::convertTimestampToDateString($operation, $value)
CTaskFilterCtrl::convertDateStringToTimestamp($operation, $value)
CTaskFilterCtrl::removeArrayKeyRecursively($ar, $dropKey)
CTaskCountersProcessorInstaller::runSetup()
CTaskCountersProcessorInstaller::setup(N/A)
CTaskCountersProcessorInstaller::isInstallComplete()
CTaskCountersProcessorInstaller::dropStageToCompleted()
CTaskCountersProcessorInstaller::getStage()
CTaskCountersProcessorInstaller::checkProcessIsNotActive()
CTaskCountersProcessorInstaller::setStage($stageId)
CTaskCountersProcessorInstaller::reset()
CTaskCountersProcessorInstaller::recountCounters_MY_NEW($userId)
CTaskCountersProcessorInstaller::recountCounters_ACCOMPLICE_NEW($userId)
CTaskCountersProcessorInstaller::recountCounters_ORIGINATORS_WAIT_CTRL($userId)
CTaskCountersProcessorInstaller::recountCounters_MY_WITHOUT_DEADLINES($userId)
CTaskCountersProcessorInstaller::recountCounters_ORIGINATORS_WITHOUT_DEADLINES($userId)
CTaskMembers::CheckFields(&$arFields, /** @noinspection PhpUnusedParameterInspection */ $ID = false)
CTaskMembers::Add($arFields)
CTaskMembers::GetFilter($arFilter)
CTaskMembers::GetList($arOrder, $arFilter)
CTaskMembers::DeleteByUserID($USER_ID)
CTaskMembers::DeleteByTaskID($TASK_ID, $TYPE = null)
CTaskMembers::updateForTask($taskId, array $userIds, $type)
CTaskMembers::DeleteAllByTaskID($TASK_ID)
CTaskLogItem::fetchListFromDb($taskData, $arOrder = array('ID' => 'ASC'), $arFilter = array())
CTaskLogItem::fetchDataFromDb($taskId, $itemId)
CTaskLogItem::runRestMethod(N/A)
CTaskLogItem::getManifest()
CTaskSubItemAbstract::__construct($oTaskItem, $itemId)
CTaskSubItemAbstract::constructWithPreloadedData($oTaskItem, $itemId, $data)
CTaskSubItemAbstract::getId()
CTaskSubItemAbstract::getExecutiveUserId()
CTaskSubItemAbstract::getData($bEscape = true)
CTaskSubItemAbstract::fetchList(CTaskItemInterface $oTaskItem, $arOrder = array(), $arFilter = array())
CTaskSubItemAbstract::resetCache()
CTaskSubItemAbstract::fetchListFromDb($taskId, $arOrder)
CTaskSubItemAbstract::fetchDataFromDb($taskId, $itemId)
CTaskListCtrl::getInstance($userId)
CTaskListCtrl::useState(CTaskListState $oState)
CTaskListCtrl::useAdvancedFilterObject(CTaskFilterCtrlInterface $oFilter)
CTaskListCtrl::setFilterByGroupId($groupId)
CTaskListCtrl::getCommonFilter()
CTaskListCtrl::getFilterFor($userId, $userRoleId, $taskCategoryId)
CTaskListCtrl::__getFilterFor($userRoleId, $taskCategoryId)
CTaskListCtrl::getFilter()
CTaskListCtrl::getMainCounter()
CTaskListCtrl::getMainCounterForUser($userId)
CTaskListCtrl::getUserRoleCounterForUser($userId, $userRole)
CTaskListCtrl::getUserRoleCounter($userRole)
CTaskListCtrl::__getUserRoleCounter($userRole, $userId)
CTaskListCtrl::resolveCounterIdByRoleAndCategory($userRoleId, $taskCategoryId = 'TOTAL')
CTaskListCtrl::getCounter($userRoleId, $taskCategoryId)
CTaskListCtrl::getCounterForUser($userRoleId, $taskCategoryId, $userId)
CTaskListCtrl::__construct($userId)
CTasksWebService::__getFieldsDefinition()
CTasksWebService::__makeDateTime($ts = null, $stripTime = false)
CTasksWebService::__makeTS($datetime = null)
CTasksWebService::__makeUser($USER_ID)
CTasksWebService::__getRow($arRes, $listName, &$last_change)
CTasksWebService::__getUser($user_str)
CTasksWebService::__InTaskInitPerms($taskType, $ownerId)
CTasksWebService::__InTaskCheckActiveFeature($taskType, $ownerId)
CTasksWebService::__Init()
CTasksWebService::GetList($listName)
CTasksWebService::GetAttachmentCollection($listName, $listItemID)
CTasksWebService::AddAttachment($listName, $listItemID, $fileName, $attachment)
CTasksWebService::DeleteAttachment($listName, $listItemID, $url)
CTasksWebService::GetListItemChanges($listName, $viewFields = '', $since = '', $contains = '')
CTasksWebService::GetListItemChangesSinceToken($listName, $viewFields = '', $query = '', $rowLimit = 0, $changeToken = '')
CTasksWebService::UpdateListItems($listName, $updates)
CTasksWebService::GetWebServiceDesc()
CTaskNotifications::sendAddMessage($arFields, $arParams = array())
CTaskNotifications::sendUpdateMessage($arFields, $arTask, $bSpawnedByAgent = false, array $parameters = array())
CTaskNotifications::SendDeleteMessage($arFields)
CTaskNotifications::SendStatusMessage($arTask, $status, $arFields = array())
CTaskNotifications::sendMessageEx($taskId, $fromUser, array $toUsers, array $messages = array(), array $parameters = array())
CTaskNotifications::SendMessageToSocNet($arFields, $bSpawnedByAgent, $arChanges = null, $arTask = null, array $parameters = array())
CTaskNotifications::isCrmTask(array $task)
CTaskNotifications::getSonetLogFilter($taskId, $crm)
CTaskNotifications::setSonetLogRights(array $params, array $fields, array $task)
CTaskNotifications::throttleRelease()
CTaskNotifications::addToNotificationBuffer(array $message)
CTaskNotifications::flushNotificationBuffer($doGrouping = true)
CTaskNotifications::fireMessageEvent(array &$message)
CTaskNotifications::OnGetRatingContentOwner($params)
CTaskNotifications::OnGetMessageRatingVote(&$params, &$forEmail)
CTaskNotifications::OnAnswerNotify($module, $tag, $text, $arNotify)
CTaskNotifications::addAnswer($taskId, $text)
CTaskNotifications::formatTimeHHMM($in, $bDataInSeconds = false)
CTaskNotifications::formatTask4Log($arTask, $message = '', $message_24_1 = '', $message_24_2 = '', $changes_24 = '', $nameTemplate = '')
CTaskNotifications::formatTask4SocialNetwork($arFields, $arParams)
CTaskNotifications::formatTaskName($taskId, $title, $groupId = 0, $bUrl = false)
CTaskNotifications::formatImNotificationTag($userId, array $taskIds, $entityCode, array $entityIds = array())
CTaskNotifications::parseImNotificationTag($tag)
CTaskNotifications::makePushMessage($messageCode, $userId, array $taskData)
CTaskNotifications::getGenderMessage($userId, $messageCode)
CTaskNotifications::cropMessage($template, array $replaces = array(), $length = false)
CTaskNotifications::placeUserName($message, $userId)
CTaskNotifications::placeLinkAnchor($message, $url, $mode = 'NONE')
CTaskNotifications::clearNotificationText($text)
CTaskNotifications::addParameters($url, $parameters = array())
CTaskNotifications::getNotificationPathMultiple(array $arUser, array $taskIds, $bUseServerName = true)
CTaskNotifications::getNotificationPath($arUser, $taskID, $bUseServerName = true, $arSites = array())
CTaskNotifications::prepareRightsCodesForViewInGroupLiveFeed($logID, $groupId)
CTaskNotifications::getEffectiveUserId(array $arFields = array(), array $arTask = array(), $bSpawnedByAgent = false, array $parameters = array())
CTaskNotifications::getOccurAsUserId(array $arFields = array(), array $arTask = array(), $bSpawnedByAgent = false, array $parameters = array())
CTaskNotifications::getUserTimeZoneOffset($userId = 'current')
CTaskNotifications::checkUserIsIntranet($userId)
CTaskNotifications::getSocNetGroupSite($id)
CTaskNotifications::getSocNetGroup($id)
CTaskNotifications::checkUserCanViewGroup($userId, $groupId)
CTaskNotifications::checkUserCanViewGroupExtended($userId, $groupId)
CTaskNotifications::getUsers(array $ids = array())
CTaskNotifications::getUser($id)
CTaskNotifications::getTaskBaseByTaskId($taskId)
CTaskNotifications::enableInstantNotifications()
CTaskNotifications::disableInstantNotifications()
CTaskNotifications::enableStaticCache()
CTaskNotifications::disableStaticCache()
CTaskNotifications::clearStaticCache()
CTaskNotifications::disableAutoDeliver()
CTaskNotifications::enableAutoDeliver($flushNow = true)
CTaskNotifications::SendMessage(N/A)
CTaskNotifications::__GetUsers($arFields)
CTaskNotifications::__Users2String($arUserIDs, $arUsers, $nameTemplate = "")
CTaskNotifications::__UserIDs2Rights($arUserIDs)
CTaskNotifications::__Fields2Names($arFields)
CTaskNotifications::GetRecipientsIDs($arFields, $bExcludeCurrent = true, $bExcludeAdditionalRecipients = false, $currentUserId = false)
CTaskNotifications::notifyByMail(array $message, array $site)
CTaskNotifications::enableSonetLogNotifyAuthor()
CTaskNotifications::disableSonetLogNotifyAuthor()
CTasksNotifySchema::__construct()
CTasksNotifySchema::OnGetNotifySchema()
CTasksPullSchema::OnGetDependentModule()
CTaskElapsedItem::add(CTaskItemInterface $oTaskItem, $arFields)
CTaskElapsedItem::delete()
CTaskElapsedItem::update($arFields)
CTaskElapsedItem::isActionAllowed($actionId)
CTaskElapsedItem::fetchListFromDb($taskData, $arOrder = array('ID' => 'ASC'), $arFilter = array())
CTaskElapsedItem::fetchDataFromDb($taskId, $itemId)
CTaskElapsedItem::getList(array $order = array(), array $filter = array(), array $select = array(), array $params = array())
CTaskElapsedItem::__resetSystemWideTasksCacheByTag($arData)
CTaskElapsedItem::resetSystemWideTasksCacheByTag()
CTaskElapsedItem::runRestMethod(N/A)
CTaskElapsedItem::getPublicFieldMap()
CTaskElapsedItem::getManifest()
CTaskIntranetTools::getImmediateEmployees($userId, $arAllowedDepartments = null)
CTaskIntranetTools::getDepartmentsUsers($arDepartmentsIds, $arFields = array('ID'))
CTasksReportHelper::prepareUFInfo()
CTasksReportHelper::setPathToUser($path)
CTasksReportHelper::getEntityName()
CTasksReportHelper::getOwnerId()
CTasksReportHelper::getColumnList()
CTasksReportHelper::setRuntimeFields(\Bitrix\Main\Entity\Base $entity, $sqlTimeInterval)
CTasksReportHelper::getCustomSelectFields($select, $fList)
CTasksReportHelper::getCustomColumnTypes()
CTasksReportHelper::getDefaultColumns()
CTasksReportHelper::getCalcVariations()
CTasksReportHelper::getCompareVariations()
CTasksReportHelper::buildSelectTreePopupElelemnt($humanTitle, $fullHumanTitle, $fieldDefinition, $fieldType, $ufInfo = array())
CTasksReportHelper::beforeViewDataQuery(&$select, &$filter, &$group, &$order, &$limit, &$options, &$runtime = null)
CTasksReportHelper::rewriteTagsFilter(&$filter, &$runtime)
CTasksReportHelper::formatResults(&$rows, &$columnInfo, $total, &$customChartData = null)
CTasksReportHelper::formatResultValue($k, &$v, &$row, &$cInfo, $total, &$customChartValue = null)
CTasksReportHelper::formatResultsTotal(&$total, &$columnInfo, &$customChartTotal = null)
CTasksReportHelper::getPeriodFilter($date_from, $date_to)
CTasksReportHelper::getDefaultElemHref($elem, $fList)
CTasksReportHelper::getDefaultReports()
CTasksReportHelper::getFirstVersion()
CTasksReportHelper::appendDateTimeUserFieldsAsShort(\Bitrix\Main\Entity\Base $entity)
CTasksReportHelper::appendTextUserFieldsAsTrimmed(\Bitrix\Main\Entity\Base $entity)
CTasksReportHelper::getFDMsMultipleTrimmed()
CTasksReportHelper::getFDMsMultipleTrimmedDateTime()
CTasksReportHelper::fdmMultipleTrimmed($value, $query, $dataRow, $columnAlias)
CTasksReportHelper::fdmMultipleTrimmedDateTime($value, $query, $dataRow, $columnAlias)
CTasksReportHelper::getCurrentVersion()
CTaskColumnList::get(array $parameters = array())
CTaskColumnContext::get()
CTaskColumnManager::__construct($oColumnPresetManager)
CTaskColumnManager::hideColumns($arColumnsId)
CTaskColumnManager::showColumns($arColumnsId)
CTaskColumnManager::moveColumnAfter($movedColumnId, $moveAfterId = 0)
CTaskColumnManager::setColumns($arNewColumns)
CTaskColumnManager::getCurrentPresetColumns()
CTaskColumnPresetManager::__construct($userId, $contextId)
CTaskColumnPresetManager::getInstance($userId, $contextId)
CTaskColumnPresetManager::getUserId()
CTaskColumnPresetManager::getContextId()
CTaskColumnPresetManager::getPresets()
CTaskColumnPresetManager::createPreset($columns = array(), $name = '')
CTaskColumnPresetManager::renamePreset($presetId, $name)
CTaskColumnPresetManager::setColumns($presetId, $columns)
CTaskColumnPresetManager::checkColumns($columns)
CTaskColumnPresetManager::getSelectedPresetId()
CTaskColumnPresetManager::selectPresetId($presetId)
CTaskItem::pinInStage($taskId, $taskData = array())
CTaskItem::getLastOperationResultData($operation = false)
CTaskItem::__construct($taskId, $executiveUserId)
CTaskItem::getInstance($taskId, $executiveUserId)
CTaskItem::getInstanceFromPool($taskId, $executiveUserId)
CTaskItem::cacheInstanceInPool($taskId, $executiveUserId, $oTaskItemInstance)
CTaskItem::add($arNewTaskData, $executiveUserId, array $parameters = array())
CTaskItem::duplicate($overrideTaskData = array()
CTaskItem::duplicateChildTasks($cloneTaskInstance)
CTaskItem::duplicateChildTasksLambda($parentTaskInstance, &$queue)
CTaskItem::addByTemplate($templateId, $executiveUserId, $overrideTaskData = array()
CTaskItem::addChildTasksByTemplate(N/A)
CTaskItem::getChildTemplateData($templateId)
CTaskItem::__wakeup()
CTaskItem::__sleep()
CTaskItem::__clone()
CTaskItem::getId()
CTaskItem::getExecutiveUserId()
CTaskItem::getTaskData($returnEscapedData = true)
CTaskItem::checkCanRead(array $parameters = array())
CTaskItem::checkCanReadThrowException()
CTaskItem::getData($returnEscapedData = true, array $parameters = array())
CTaskItem::getDescription($format = self::DESCR_FORMAT_HTML)
CTaskItem::getTags()
CTaskItem::getAllowedTaskActions()
CTaskItem::getAllowedTaskActionsAsStrings()
CTaskItem::getAllowedActions($bReturnAsStrings = false)
CTaskItem::getAllowedActionsArray($executiveUserId, array $arTaskData, $bReturnAsStrings = false)
CTaskItem::getAllowedActionsArrayInternal($executiveUserId, array $arTaskData, $bmUserRoles)
CTaskItem::getAllowedActionsMap()
CTaskItem::getStatusMap()
CTaskItem::getAllowedActionsAsStrings($arAllowedActions = false)
CTaskItem::isActionAllowed($actionId)
CTaskItem::isActionAllowedForUser($actionId, $userId = 0)
CTaskItem::delete()
CTaskItem::delegate($newResponsibleId)
CTaskItem::decline($reason = '')
CTaskItem::startExecution()
CTaskItem::pauseExecution()
CTaskItem::defer()
CTaskItem::complete()
CTaskItem::update($arNewTaskData, array $parameters = array())
CTaskItem::stopWatch($userId = 0)
CTaskItem::startWatch($userId = 0, $bSkipNotification = false)
CTaskItem::accept()
CTaskItem::renew()
CTaskItem::approve()
CTaskItem::disapprove()
CTaskItem::addToFavorite($parameters = array('AFFECT_CHILDREN' => true))
CTaskItem::deleteFromFavorite($parameters = array('AFFECT_CHILDREN' => true))
CTaskItem::toggleFavorite()
CTaskItem::getFiles()
CTaskItem::removeAttachedFile($fileId)
CTaskItem::isUserRole($roleId)
CTaskItem::fetchList($userId, $arOrder, $arFilter, $arParams = array(), $arSelect = array())
CTaskItem::fetchListArray($userId, $arOrder, $arFilter, $arParams = array(), $arSelect = array(), array $arGroup = array())
CTaskItem::constructWithPreloadedData($userId, $arTaskData)
CTaskItem::markCacheAsDirty($clearStaticCache = true)
CTaskItem::proceedAction($actionId, $arActionArguments = null)
CTaskItem::enableUpdateBatchMode()
CTaskItem::disableUpdateBatchMode()
CTaskItem::moveSubTasksToGroup($groupId)
CTaskItem::getSubUsers($userId)
CTaskItem::getUserRolesArray($userId, array $arTask)
CTaskItem::getUserRoles()
CTaskItem::throwExceptionNotAccessible()
CTaskItem::throwExceptionVerbose($errorDescription = array(), $additionalFlags = 0)
CTaskItem::getBaseAllowedActions()
CTaskItem::getDependsOn()
CTaskItem::addProjectDependence($parentId, $linkType = DependenceTable::LINK_TYPE_FINISH_START)
CTaskItem::checkIsSubtaskOf($taskId)
CTaskItem::updateProjectDependence($parentId, $linkType = DependenceTable::LINK_TYPE_FINISH_START)
CTaskItem::deleteProjectDependence($parentId)
CTaskItem::postProcessRestRequest($methodName, $result, $parameters = array())
CTaskItem::runRestMethod($executiveUserId, $methodName, $args, $navigation)
CTaskItem::getAttachmentIds()
CTaskItem::addFile(array $fileParameters)
CTaskItem::deleteFile($attachmentId)
CTaskItem::getEntityUserFields()
CTaskItem::getManifest()
CTaskItem::getMinimalSelect($legacy = true)
CTaskItem::getMinimalSelectLegacy()
CTaskItem::getMinimalSelectORM()
CTaskItem::setCalendar(Calendar $calendar)
CTaskItem::initializeCalendar()
CTaskItem::setStartDatePlan(DateTime $date)
CTaskItem::setEndDatePlan(DateTime $date)
CTaskItem::getStartDatePlan($getCreatedDateOnNull = false)
CTaskItem::getEndDatePlan()
CTaskItem::getStartDatePlanGmt($getCreatedDateOnNull = false)
CTaskItem::getEndDatePlanGmt()
CTaskItem::setStartDatePlanUserTimeGmt($timeString)
CTaskItem::setEndDatePlanUserTimeGmt($timeString)
CTaskItem::setMatchWorkTime($flag)
CTaskItem::getMatchWorkTime()
CTaskItem::getDurationType()
CTaskItem::calculateDuration()
CTaskItem::ensureDataLoaded()
CTaskItem::getStartDateOrCreatedDate($flag = true)
CTaskItem::offsetExists($offset)
CTaskItem::offsetGet($offset)
CTaskItem::offsetSet($offset , $value)
CTaskItem::offsetUnset($offset)
CTaskItem::addDependOn($parentId, $linkType = DependenceTable::LINK_TYPE_FINISH_START)
CTaskItem::deleteDependOn($parentId)
CTaskComments::onCommentTopicAdd($entityType, $entityId, $arPost, &$arTopic)
CTaskComments::onAfterCommentTopicAdd($entityType, $entityId, $topicId)
CTaskComments::onAfterCommentAdd($entityType, $entityId, $arData)
CTaskComments::onAfterCommentUpdate($entityType, $entityId, $arData)
CTaskComments::fireOnAfterCommentAddEvent($commentId, $taskId, $commentText, $arFilesIds, $urlPreviewId)
CTaskComments::sendAddMessage($messageData, $taskData, $fromUser, $toUsers, array $eventData = array())
CTaskComments::cropMessage($message)
CTaskComments::getOccurAsUserId($messageAuthorId)
CTaskComments::add($taskId, $commentAuthorId, $commentText, $arFields = array())
CTaskComments::update($taskId, $commentId, $commentEditorId, $arFields)
CTaskComments::Remove($taskId, $commentId, $userId, $arParams)
CTaskComments::CanUpdateComment($taskId, $commentId, $userId, $arParams)
CTaskComments::CanRemoveComment($taskId, $commentId, $userId, $arParams)
CTaskComments::CheckUpdateRemoveCandidate($taskId, $commentId, $userId, $arParams)
CTaskComments::onAfterTaskAdd($taskId, $arFields)
CTaskComments::onAfterTaskUpdate($taskId, $arTask, $arFields)
CTaskComments::getCommentsFiles($forumTopicId)
CTaskComments::addFilesRights($taskId, $arFilesIds)
CTaskComments::getTaskMembersByTaskId($taskId, $excludeUser = 0)
CTaskComments::getTaskMembersByFields($arFields)
CTaskComments::__deprecated_Add(N/A)
CTaskComments::runRestMethod(N/A)
CTaskComments::getManifest()
CTaskPlannerMaintance::OnPlannerInit($params)
CTaskPlannerMaintance::OnPlannerAction($action, $params)
CTaskPlannerMaintance::getTimemanCloseDayData($arParams)
CTaskPlannerMaintance::plannerActions($arActions, $site_id = SITE_ID)
CTaskPlannerMaintance::getTasks($arIDs = array(), $bOpened = false)
CTaskPlannerMaintance::getTasksCount($arTasks)
CTaskPlannerMaintance::getCurrentTasksList()
CTaskPlannerMaintance::setCurrentTasksList($list)
CTaskPlannerMaintance::OnAfterTMDayStart()
CTaskPlannerMaintance::runRestMethod($executiveUserId, $methodName, $args, $navigation)
CTaskPlannerMaintance::getManifest()
CTaskFiles::checkFilesAccessibilityByUser($arFilesIds, $userId)
CTaskFiles::isUserfieldFileAccessibleByUser($taskId, $fileId, $userId)
CTaskFiles::isFileAccessibleByUser($fileId, $userId)
CTaskFiles::saveFileTemporary($userId, $fileName, $fileSize, $fileTmpName, $fileType)
CTaskFiles::markFileTemporary($userId, $fileId)
CTaskFiles::removeTemporaryFile($userId, $fileId)
CTaskFiles::isTemporaryFileRegistered($userId, $fileId)
CTaskFiles::getRegisteredTemporaryFilesList($userId)
CTaskFiles::CheckFields(&$arFields, /** @noinspection PhpUnusedParameterInspection */ $ID = false)
CTaskFiles::CheckFieldsMultiple($taskId, $arFilesIds)
CTaskFiles::AddMultiple($taskId, $arFilesIds, $arParams = array())
CTaskFiles::removeTemporaryStatusForFiles($arFilesIds, $userId)
CTaskFiles::Add($arFields, $arParams = array())
CTaskFiles::Delete($TASK_ID, $FILE_ID)
CTaskFiles::GetFilter($arFilter)
CTaskFiles::GetList($arOrder, $arFilter)
CTaskFiles::DeleteByFileID($FILE_ID)
CTaskFiles::DeleteByTaskID($TASK_ID, $SAVE_FILES = array())
CTaskFiles::getFilesAttachedInAccessibleTemplates($userId)
CTaskFiles::getFilesAttachedInAccessibleTasks($userId, $arFilesIds)
CTaskFiles::unregisterTemporaryFiles($arFilesIds)
CTaskFiles::registerTemporaryFileInDb($userId, $fileId)
CTaskFiles::removeExpiredTemporaryFiles()
CTaskTimerCore::start($userId, $taskId)
CTaskTimerCore::stop($userId, $taskId = 0)
CTaskTimerCore::get($userId, $taskId = 0)
CTaskTimerCore::getByTaskId($taskId)
CTaskReport::GetList($arOrder=array(), $arFilter=array(), $arNavParams = array())
CTaskReport::GetDepartementStats($arFilter=array())
CTaskReport::GetCompanyStats($arFilter=array())
CTaskReport::GetEmployeesCount()
CTaskReport::GetPeriodCondition($arPeriod, $field, $extraCond = "1=1")
CTasksRarelyTools::onWebdavUninstall()
CTasksRarelyTools::onForumUninstall()
CTasksRarelyTools::onIntranetUninstall()
CTasksRarelyTools::onBeforeUserTypeAdd($arFields)
CTasksRarelyTools::onBeforeUserTypeUpdate()
CTasksRarelyTools::onBeforeUserTypeDelete($arFields)
CTasksRarelyTools::isMandatoryUserFieldExists()
CTaskSync::SyncTaskItems($type, $userId, $arUserTaskItems)
CTaskSync::SyncModifyTaskItem($arModifyEventArray)
CTaskSync::AddItem($arFields)
CTaskSync::checkExchangeAvailable()
CTaskSync::UpdateItem($arFields, $arTask)
CTaskSync::DeleteItem($arTask)
CTaskReminders::__construct($arParams = array())
CTaskReminders::getErrors()
CTaskReminders::CheckFields(N/A)
CTaskReminders::Add($arFields)
CTaskReminders::GetFilter($arFilter)
CTaskReminders::GetList($arOrder, $arFilter)
CTaskReminders::DeleteByDate($REMIND_DATE)
CTaskReminders::DeleteByTaskID($TASK_ID)
CTaskReminders::DeleteByUserID($USER_ID)
CTaskReminders::Delete($arFilter)
CTaskReminders::SendAgent()
CTaskReminders::__SendJabberReminder($USER_ID, $arTask)
CTaskReminders::__SendEmailReminder($USER_EMAIL, $arTask)
CTaskElapsedTime::CheckFields(/** @noinspection PhpUnusedParameterInspection */ &$arFields, /** @noinspection PhpUnusedParameterInspection */ $ID = false)
CTaskElapsedTime::Add($arFields, $arParams = array())
CTaskElapsedTime::Update($ID, $arFields, $arParams = array())
CTaskElapsedTime::Delete($ID, $arParams = array())
CTaskElapsedTime::GetFilter($arFilter)
CTaskElapsedTime::GetList($arOrder, $arFilter, $arParams = array())
CTaskElapsedTime::GetByID($ID)
CTaskElapsedTime::CanCurrentUserAdd($task)
CTaskAssert::assert($assertion)
CTaskAssert::logWarning($logMessage)
CTaskAssert::logError($logMessage)
CTaskAssert::logFatal($logMessage)
CTaskAssert::log($logMessage, $errLogLevel = self::ELL_TRACE, $showBacktrace = false)
CTaskAssert::setLogFileName($fullPathToLogFile)
CTaskAssert::disableLogging()
CTaskAssert::enableLogging($enableLogLevels = null)
CTaskAssert::isLaxIntegers()
CTaskAssert::assertLaxIntegers()
CTaskAssert::_isLaxIntegers($args)
CTasks::GetErrors()
CTasks::getLastOperationResultData()
CTasks::getPreviousData()
CTasks::CheckFields(&$arFields, $ID = false, $effectiveUserId = null)
CTasks::Add($arFields, $arParams = array())
CTasks::processDurationPlanFields(&$arFields, $type)
CTasks::Update($ID, $arFields, $arParams = array('CORRECT_DATE_PLAN_DEPENDENT_TASKS' => true, 'CORRECT_DATE_PLAN' => true, 'THROTTLE_MESSAGES' => false))
CTasks::datesChanged($was, $now)
CTasks::followDatesSetTrue($fields)
CTasks::checkCacheAutoClearEnabled()
CTasks::disableCacheAutoClear()
CTasks::enableCacheAutoClear($clearNow = true)
CTasks::addCacheIdToClear($cacheId)
CTasks::clearCache()
CTasks::Delete($ID, $arParams = array())
CTasks::terminateZombie($ID)
CTasks::GetSqlByFilter($arFilter, $userID, $sAliasPrefix, $bGetZombie, $bMembersTableJoined = false)
CTasks::getSqlForTimestamps($key, $val, $userID, $sAliasPrefix, $bGetZombie)
CTasks::GetFilteredKeys($arFilter)
CTasks::isSubFilterKey($key)
CTasks::GetFilter($arFilter, $sAliasPrefix = "", $arParams = false)
CTasks::placeFieldSql($field, $behaviour, &$fields)
CTasks::getPermissionFilterConditions($arParams, $behaviour = array('ALIAS' => '', 'USE_PLACEHOLDERS' => false))
CTasks::MkOperationFilter($key)
CTasks::FilterCreate($fname, $vals, $type, &$bFullJoin, $cOperationType=false, $bSkipEmpty = true)
CTasks::GetByID($ID, $bCheckPermissions = true, $arParams = array())
CTasks::GetSubordinateDeps($userID = null)
CTasks::GetAllowedGroups($arParams = array())
CTasks::GetDepartmentManagers($arDepartments, $skipUserId=false, $arSelectFields = array('ID'))
CTasks::GetDepartmentManagersIDs($arDepartments, $IBlockID)
CTasks::IsSubordinate($employeeID1, $employeeID2)
CTasks::getSelectSqlByFilter(array $filter = array(), $alias = '', array $filterParams = array())
CTasks::GetList($arOrder=array(), $arFilter=array(), $arSelect = array(), $arParams = array(), array $arGroup = array())
CTasks::makePossibleForwardedMemberFilter($filter)
CTasks::makePossibleForwardedFilter($filter)
CTasks::needAccessRestriction(array $arFilter, $arParams)
CTasks::GetRootSubquery($arFilter=array(), $bGetZombie = false, $aliasPrefix = '')
CTasks::GetCount($arFilter=array(), $arParams = array(), $arGroupBy = array())
CTasks::appendJoinRights($sql, $arParams)
CTasks::tryOptimizeFilter(array $arFilter)
CTasks::getUsersViewedTask($taskId)
CTasks::GetCountInt($arFilter=array(), $arParams = array())
CTasks::GetChildrenCount($arFilter, $arParentIDs)
CTasks::GetOriginatorsByFilter($arFilter, $loggedInUserId)
CTasks::GetResponsiblesByFilter($arFilter, $loggedInUserId)
CTasks::GetFieldGrouppedByFilter($column, $arFilter, $loggedInUserId)
CTasks::GetSubordinateSql($sAliasPrefix="", $arParams = array(), $behaviour = array())
CTasks::GetDeparmentSql($arDepsIDs, $sAliasPrefix="", $arParams = array(), $behaviour = array())
CTasks::AddAccomplices($ID, $arAccompleces = array())
CTasks::AddAuditors($ID, $arAuditors = array())
CTasks::AddFiles($ID, $arFiles = array(), $arParams = array())
CTasks::detectTags(array &$fields)
CTasks::AddTags($ID, $USER_ID, $arTags = array(), $effectiveUserId = null)
CTasks::AddPrevious($ID, $arPrevious = array())
CTasks::Index($arTask, $tags)
CTasks::OnSearchReindex($NS=array(), $oCallback=NULL, $callback_method="")
CTasks::UpdateForumTopicIndex($topic_id, $entity_type, $entity_id, $feature, $operation, $path, $arPermissions, $siteID)
CTasks::__GetSearchPermissions($arTask)
CTasks::RepeatTaskByTemplateId($templateId, $flipFlop = 1, array &$debugHere = array())
CTasks::RepeatTask($TASK_ID, /** @noinspection PhpUnusedParameterInspection */ $time="")
CTasks::getNextTime($arParams, $template = false, $agentTime = false)
CTasks::CanGivenUserDelete($userId, $taskCreatedBy, $taskGroupId, /** @noinspection PhpUnusedParameterInspection */ $site_id = SITE_ID)
CTasks::CanCurrentUserDelete($task, $site_id = SITE_ID)
CTasks::CanGivenUserEdit($userId, $taskCreatedBy, $taskGroupId, /** @noinspection PhpUnusedParameterInspection */ $site_id = SITE_ID)
CTasks::CanCurrentUserEdit($task, $site_id = SITE_ID)
CTasks::UpdateViewed($TASK_ID, $USER_ID)
CTasks::__updateViewed($TASK_ID, $USER_ID, $onTaskAdd = false)
CTasks::GetUpdatesCount($arViewed)
CTasks::GetFilesCount($arTasksIDs)
CTasks::CanCurrentUserViewTopic($topicID)
CTasks::getParentOfTask($taskId)
CTasks::GetUserDepartments($USER_ID)
CTasks::onBeforeSocNetGroupDelete($inGroupId)
CTasks::OnBeforeUserDelete($inUserID)
CTasks::convertDurationToSeconds($value, $type)
CTasks::convertDurationFromSeconds($value, $type)
CTasks::OnUserDelete($USER_ID)
CTasks::EmitPullWithTagPrefix($arRecipients, $tagPrefix, $cmd, $arParams)
CTasks::EmitPullWithTag($arRecipients, $tag, $cmd, $arParams)
CTasks::GetGroupsWithTasksForUser($userId)
CTasks::GetAllowedActions($arTask, $userId = null)
CTasks::convertBbcode2Html($arStringsInBbcode)
CTasks::getTaskSubTree($taskId)
CTasks::getSubTaskIdsForTask($taskId)
CTasks::runRestMethod($executiveUserId, $methodName, $args, $navigation)
CTasks::getPublicFieldMap()
CTasks::getManifest()
CTasks::getSortingOrderBy($asc = true)
CTasks::getOrderSql($by, $order, $default_order, $nullable = true)
CTasks::getOrderSql_mysql($by, $order, $default_order, $nullable = true)
CTasks::getOrderSql_mssql($by, $order, $default_order, $nullable = true)
CTasks::getOrderSql_oracle($by, $order, $default_order, $nullable = true)
CTasks::parseOrder($by, $order, $default_order, $nullable = true)
CTaskLog::getTrackedFields()
CTaskLog::CheckFields(N/A)
CTaskLog::Add($arFields)
CTaskLog::GetFilter($arFilter)
CTaskLog::GetList($arOrder, $arFilter)
CTaskLog::GetChanges($currentFields, $newFields)
CTaskLog::UnifyFields(&$value, $key)
CTaskLog::DeleteByTaskId($in_taskId)
CTaskTags::CheckFields(&$arFields, /** @noinspection PhpUnusedParameterInspection */ $ID = false, $effectiveUserId = null)
CTaskTags::Add($arFields, $effectiveUserId = null)
CTaskTags::GetFilter($arFilter)
CTaskTags::getTagsNamesByUserId($userId)
CTaskTags::GetList($arOrder, $arFilter)
CTaskTags::DeleteByName($NAME)
CTaskTags::DeleteByTaskID($TASK_ID)
CTaskTags::DeleteByUserID($USER_ID)
CTaskTags::Rename($OLD_NAME, $NEW_NAME, $USER_ID)
CTaskTags::Delete($arFilter)
CTaskCheckListItem::add(CTaskItemInterface $oTaskItem, $arFields)
CTaskCheckListItem::isActionAllowed($actionId)
CTaskCheckListItem::fetchListFromDb($taskData, $arOrder = array('SORT_INDEX' => 'asc', 'ID' => 'asc'))
CTaskCheckListItem::getTitle()
CTaskCheckListItem::getTaskId()
CTaskCheckListItem::getTaskIdByItemId($itemId)
CTaskCheckListItem::isComplete()
CTaskCheckListItem::complete()
CTaskCheckListItem::renew()
CTaskCheckListItem::update($arFields)
CTaskCheckListItem::delete()
CTaskCheckListItem::setSortIndex($sortIndex)
CTaskCheckListItem::moveAfterItem($itemId)
CTaskCheckListItem::moveItem($selectedItemId, $insertAfterItemId)
CTaskCheckListItem::deleteByTaskId($taskId)
CTaskCheckListItem::fetchDataFromDb($taskId, $itemId)
CTaskCheckListItem::getByTaskId($taskId)
CTaskCheckListItem::normalizeFieldsDataForAdd($arFields)
CTaskCheckListItem::normalizeFieldsDataForUpdate($arFields)
CTaskCheckListItem::checkFieldsForSort($arOrder)
CTaskCheckListItem::checkFieldsForAdd($arFields)
CTaskCheckListItem::checkFieldsForUpdate($arFields)
CTaskCheckListItem::checkFields($arFields, $checkForAdd)
CTaskCheckListItem::runRestMethod(N/A)
CTaskCheckListItem::getPublicFieldMap()
CTaskCheckListItem::getManifest()
UI::toLowerCaseFirst($str)
UI::getPluralForm($n)
UI::convertActionPathToBarNotation($path, array $map = array())
UI::getAvatar($fileId, $width = 50, $height = 50)
UI::getAvatarFile($fileId, array $parameters = array('WIDTH' => 50, 'HEIGHT' => 50))
UI::formatTimezoneOffsetUTC($offset)
UI::formatTimeAmount($time, $format = 'HH:MI:SS')
UI::parseTimeAmount($time, $format = 'HH:MI:SS')
UI::getDateTimeFormat()
UI::getDateTimeFormatShort()
UI::formatDateTime($stamp, $format = false)
UI::formatDateTimeSiteL2S($time)
UI::formatDateTimeFromDB($value)
UI::parseDateTime($dayTime)
UI::checkDateTime($dayTime)
UI::getHintState()
UI::sanitizeString($string, array $allowedTags = array())
UI::convertBBCodeToHtml($value, array $parameters = array())
UI::convertBBCodeToHtmlSimple($value)
UI::convertHtmlToBBCode($value)
UI::convertHtmlToBBCodeHack(&$text, &$TextParser)
UI::convertHtmlToSafeHtml($value)
UI::toJSON($data)
UI::toJSObject($data)
UI::processObjects($data)
UI::translateCalendarSettings(array $settings)
Dispatcher::__construct()
Dispatcher::globalDisable()
Dispatcher::globalEnable()
Dispatcher::isGloballyEnabled()
Dispatcher::addRuntimeActions($actions)
Dispatcher::restRegister($rest)
Dispatcher::restGateway()
Dispatcher::run($plan)
Dispatcher::getOperationsByPlan($plan, $result)
Dispatcher::checkPlan($plan, $result)
Dispatcher::wrapOpCall($operation)
Dispatcher::execute(array $batch)
Dispatcher::parseBatchDeprecated(array $batch)
Dispatcher::getErrors()
Dispatcher::getErrorCodeByTasksException($e)
Dispatcher::proxyExceptionMessage($e)
Dispatcher::getDescription()
Dispatcher::getDescriptionFormatted()
Dispatcher::isA($instance)
Dispatcher::getMethodInfo($class, $method)
Dispatcher::getClasses()
Dispatcher::walkDirectory($dir, &$index, $rootDir)
Dispatcher::addReasons(Dispatcher\Operation $operation, array $reasons, $reasonPrefix = '')
Dispatcher::getErrorCollection()
Processor::getInstance($userId = 0)
Processor::__construct($userId)
Processor::getUserId()
Processor::isDebugEnabled()
Processor::processEntity($id, $data = array(), array $settings = array())
Processor::reset()
Processor::addImpact($impact)
Processor::getImpactById($taskId)
Processor::hasImpact($taskId)
Processor::getChanges()
ForumCommentsIndex::execute(array &$result)
LivefeedIndexTask::execute(array &$result)
TasksFulltextIndexer::execute(array &$result)
TasksFilterConverter::execute(array &$result)
Filter::process($userId)
Collection::add($codeOrInstance, $message = '', $type = false, $additionalData = null)
Collection::addWarning($code, $message = '', $additionalData = null)
Collection::load($source)
Collection::find($conditions = array(), $limit = -1)
Collection::transform(array $rules = array())
Collection::prefixCode($prefix)
Collection::checkNoFatals()
Collection::checkHasFatals()
Collection::checkHasErrorOfType($type)
Collection::getMessages()
Collection::getArray()
Collection::getArrayMeta()
Collection::makeFromArray(array $errors)
Collection::first()
Collection::getClass()
Collection::isA($object)
Collection::getAll($flat = false, $filter = null)
Collection::addForeignErrors($other, array $parameters = array('CHANGE_TYPE_TO' => false))
Collection::checkHasErrors()
Collection::getFatals()
Collection::getWarnings()
Collection::getOfType($type)
Collection::filter($filter = array())
Error::__construct($message, $code = 0, $type = false, $data = null)
Error::toArray()
Error::toArrayMeta()
Error::makeFromArray(array $error)
Error::setCode($code)
Error::setType($type)
Error::getType()
Error::getData()
Error::setData($data)
Error::setMessage($message)
Error::isFatal()
Error::matchFilter($filter = array())
Task::createOverdueChats()
Task::getOverdueTasks()
Task::getDayStartDateTime()
Entity::cloneRuntimeFields(array $parameters = array())
DateTimeField::__construct($name, $parameters = array())
DateTimeField::getDataType()
DateTimeField::assureValueObject($value)
UserField::getEntityCode()
UserField::getSysScheme()
UserField::getScheme($entityId = 0, $userId = 0, $languageId = LANGUAGE_ID)
UserField::getDefaultValue($code, $userId = false)
UserField::getTypes()
UserField::checkFieldExists($code)
UserField::checkContainsUFKeys($fields)
UserField::isUFKey($key)
UserField::isValueEmpty($value)
UserField::isFieldExist($name)
UserField::getField($id)
UserField::getControllerClassByEntityCode($code)
UserField::cloneValues($data, $dstUFController, $userId = 0, array $parameters = array() /*todo: configure object later */)
UserField::cancelCloneValues($data, $userId = 0)
UserField::checkValues($data, $entityId = 0, $userId = 0)
UserField::updateValues($data, $entityId = 0, $userId = 0)
UserField::addField(array $fields)
UserField::updateField($id, array $fields)
UserField::deleteField($id)
UserField::clearCache()
UserField::onAfterUserTypeAdd(array $field)
UserField::OnAfterUserTypeUpdate(array $field, $id)
UserField::OnAfterUserTypeDelete(array $field, $id)
UserField::getFreeFieldName()
UserField::onUserTypeSchemeChange(array $field, $id)
UserField::add($fields)
UserField::update($id, $fields)
UserField::getUserFields($entityId = 0, $userId = 0, $languageId = false)
UserField::getApplicationErrors(Result $result)
UserField::getCacheTagName()
UserField::getClass()
Dictionary::__construct(array $values = null)
Dictionary::getIterator()
Dictionary::get($name)
Dictionary::set(array $values)
Dictionary::clear()
Dictionary::offsetExists($offset)
Dictionary::offsetGet($offset)
Dictionary::offsetSet($offset, $value)
Dictionary::offsetUnset($offset)
Dictionary::count()
Dictionary::toArray()
Dictionary::isEmpty()
Dictionary::containsKey($key)
Dictionary::getKeys()
Dictionary::onChange()
Dictionary::getClass()
Dictionary::isA($object)
DateTime::getCurrentTimeString()
DateTime::getMonthGmt($zeroBase = false)
DateTime::getDayGmt()
DateTime::getWeekDayGmt()
DateTime::getYearGmt()
DateTime::getHourGmt()
DateTime::getMinuteGmt()
DateTime::getSecondGmt()
DateTime::createFromObjectOrString($value)
DateTime::createFromTimeStruct(array $dateTime, $monthZeroBase = false)
DateTime::createFromTimeStructGmt(array $dateTime, $monthZeroBase = false)
DateTime::getTimeStampByStruct(array $dateTime, $monthZeroBase)
DateTime::getTimeStruct($monthZeroBase = false)
DateTime::getTimeStructGmt($monthZeroBase = false)
DateTime::createFromTimestampGmt($unix)
DateTime::createFromUserTime($timeString)
DateTime::createFromUserTimeGmt($timeString)
DateTime::createFromInstance(\Bitrix\Main\Type\DateTime $date)
DateTime::convertToGmt()
DateTime::convertToLocalTime()
DateTime::checkGT(DateTime $date, $strict = true)
DateTime::checkLT(DateTime $date, $strict = true)
DateTime::isEqualTo(DateTime $date)
DateTime::isNotEqualTo(DateTime $date)
DateTime::stripTime()
DateTime::stripSeconds()
DateTime::addDay($offset)
DateTime::addHour($offset)
DateTime::addMinute($offset)
DateTime::addSecond($offset)
DateTime::toStringGmt()
DateTime::getInfoGmt()
DateTime::createFrom($time, $offset = null)
DateTime::getDefaultTimeZone()
DateTime::disableTimeZone()
DateTime::enableTimeZone()
ArrayOption::__construct($optionName = '', $rules = array(), $type = null)
ArrayOption::getFilterOptionName()
ArrayOption::getRules()
ArrayOption::setOptionName($name)
ArrayOption::set(array $value)
ArrayOption::get()
ArrayOption::remove()
ArrayOption::check($value, $initial = false)
ArrayOption::removeForAllUsers()
ArrayOption::fetchOptionValue()
ArrayOption::checkOptionValueExists()
ArrayOption::getOptionName()
Structure::__construct($data = array(), $rules = array())
Structure::set($data, $point = '')
Structure::get($point = '')
Structure::toArray()
Structure::exportFlat($point = '', $delimiter = '.')
Structure::makeDictionary($data, &$dict, $delimiter = '.', $namePath = array(), $depth = 0)
Structure::check($value, $initial = false)
Structure::getRules()
Structure::setRules($rules)
Structure::&deReference($name, &$ctx)
Structure::isA($object)
Structure::getClass()
StructureChecker::__construct(array $standard)
StructureChecker::check($structure, $initial = false)
StructureChecker::walk($structure, array $standard, array $params = array(), $depth = 1)
StructureChecker::evaluateValue($value)
FromTemplate::getSourceClass()
FromTemplate::getConverterClass()
FromTemplate::produceSub($source, $destination, array $parameters = array(), $userId = 0)
FromTemplate::makeSourceInstance($id, $userId)
FromTemplate::repeatTask($templateId, array $parameters = array())
FromTemplate::getNextTime(array $templateData, $agentTime = false, $nowTime = false)
FromTemplate::getWeeklyDate($startDate, $arParams)
FromTemplate::reInstallAgent($templateId, array $templateData)
FromTemplate::unInstallAgent($id)
FromTemplate::isMultitaskSource($source, array $parameters = array())
FromTemplate::getSubItemData($id)
FromTemplate::sendToSysLog($templateId, $taskId, $message, Util\Error\Collection $errors = null, $forceTypeError = false)
FromTemplate::incrementReplicationCount($templateId)
FromTemplate::getEffectiveUser()
FromTemplate::stripTime($nextTime)
FromTemplate::printDebugTime($l, $t)
FromTemplate::getCreationOrder(array $subEntitiesData, $srcId)
FromTemplate::liftLogAgent()
FromTask::getSourceClass()
FromTask::getConverterClass()
FromTask::produceSub($source, $destination, array $parameters = array(), $userId = 0)
FromTask::getSubItemData($id, Result $result, $userId = 0)
Result::setSubInstanceResult(Collection $subInstanceResults)
Result::getSubInstanceResult()
Task::getSourceClass()
Task::getConverterClass()
Task::setConverter($converter)
Task::getConverter()
Task::setConfig($field, $value)
Task::getConfig($field)
Task::produce($source, $userId = 0, array $parameters = array())
Task::produceSub($source, $destination, array $parameters = array(), $userId = 0)
Task::getStaticDataMixin()
Task::isMultitaskSource($source, array $parameters)
Task::getSourceInstance($source, $userId = 0)
Task::getDestinationInstance($destination, $userId = 0)
Task::makeSourceInstance($id, $userId)
Task::saveItemFromSource($source, $dataMixin, $userId = 0)
Restriction::checkCanCreateDependence($userId = 0)
Restriction::canManageTask($userId = 0)
Process::__construct($options = array())
Process::getSessionKey()
Process::getStages()
Process::getMinimumTimeLimit()
Process::restore()
Process::reset()
Process::execute()
Process::getStageIndexByCode($stageCode)
Process::getStageCodeByIndex($stageIndex)
Process::nextStage() // todo: rename to moveStageForward()
Process::nextStep() // todo: rename to moveStepForward()
Process::isStage($code)
Process::setStage($stage)
Process::onBeforePerformIteration()
Process::onAfterPerformIteration()
Process::getStage()
Process::getPreviousStage()
Process::getStep()
Process::getStageDescription($stage)
Process::getStagePercent($stage)
Process::getCurrentPercentRange()
Process::getPercent()
Process::calcSubPercent($range)
Process::checkQuota()
Process::setTimeLimit($timeLimit)
Process::getMemoryPeak()
Process::saveStartTime()
Process::saveMemoryPeak()
Process::getHitTime()
Process::getProcessTime()
Process::getProcessTimeString()
Process::getHitTimeString()
Process::getTimeString($time = 0)
Process::getTimeStampString()
Process::getMemoryPeakString()
Process::getData()
ExecutionResult::getPercent()
ExecutionResult::setPercent($percent)
Site::getUserNameFormat($siteId = '')
Site::getServerName($siteId = '')
Site::get($id = '')
Site::getPair()
Site::getSiteStruct()
Calendar::getInstance()
Calendar::__construct(array $settings = array())
Calendar::getClosestWorkTime(DateTime $oldDate, $isForward = true)
Calendar::calculateDuration(DateTime $startDate, DateTime $endDate)
Calendar::calculateStartDate($endDate, $duration)
Calendar::calculateEndDate($startDate, $duration)
Calendar::processEachDay(DateTime $startDate = null, DateTime $endDate = null, $isForward = false, $callback = false)
Calendar::getWorkHours(DateTime $date)
Calendar::isWorkTime(DateTime $date)
Calendar::isHoliday(DateTime $date)
Calendar::isWeekend(DateTime $date)
Calendar::getStartOfCurrentDayGmt()
Calendar::getEndOfCurrentDayGmt()
Calendar::setSettings(array $settings)
Calendar::getSettingsCached()
Calendar::getDefaultSettings()
Calendar::getSettings()
Scheduler::__construct($userId, $task, array $taskData = array(), Calendar $calendar = null)
Scheduler::defineDates()
Scheduler::sync()
Scheduler::reSchedule(array $newData)
Scheduler::reScheduleTask(array $newData)
Scheduler::reScheduleRelatedTasks()
Scheduler::makeTaskReturnStruct(\CTaskItem $task, $dataDelta = false)
Scheduler::castToDateTimeGmt($date)
Scheduler::initializeTaskFromObject(\CTaskItem $task)
Scheduler::initializeTaskFromData(array $taskData = array())
Scheduler::checkAccessThrowException(\CTaskItem $task)
Scheduler::exportTaskPool()
Scheduler::updateRelated($fromTaskId)
Scheduler::convertDurationToUnits($duration = 0, $preferredUnits = \CTasks::TIME_UNIT_TYPE_HOUR)
Scheduler::getMinDate(array $relation)
Scheduler::calculateLags()
Scheduler::updateLag(&$relation)
Scheduler::getTaskRelationHash()
Scheduler::makeRelationTree($fromTaskId, array $relations, array $taskData)
Scheduler::correctWorkTime($taskId, DateTime $startDate, Datetime $endDate, $duration)
Scheduler::matchWorkingTime($taskId, DateTime $startDate = null, Datetime $endDate = null, $duration = null)
Filter::__construct($conditions)
Filter::match($item)
Filter::isA($object)
Filter::parseConditions($conditions)
DisposableAction::reInitializeCounterAgent()
DisposableAction::needConvertTemplateFiles()
DisposableAction::reCreateUserFields()
DisposableAction::restoreReplicationAgents()
Result::__construct()
Result::setData($data)
Result::getData()
Result::getErrors()
Result::isSuccess()
Result::isErrorsEmpty()
Result::addException($e, $message = '', $settings = array())
Result::addError($code, $message, $type = Error::TYPE_FATAL)
Result::addWarning($code, $message)
Result::getErrorCount()
Result::loadErrors(Error\Collection $errors)
Result::adoptErrors($source, $transform = array())
Result::dump($showData = false)
Result::dumpData()
Result::isA($obj)
User::get()
User::getId()
User::isAuthorized()
User::isActive($userId)
User::getAdminId()
User::getOccurAsId()
User::setOccurAsId($userId = 0)
User::isAdmin($userId = 0)
User::isSuper($userId = 0)
User::getData(array $ids, $siteId = '')
User::getArtificialExternalAuthIds()
User::extractPublicData($user)
User::getPublicDataKeys()
User::formatName($data, $siteId = false, $format = null)
User::getTimeZoneOffsetCurrentUser()
User::getTimeZoneOffset($userId = 0, $utc = false)
User::setOption($name, $value, $userId = 0)
User::unSetOption($name, $userId = 0)
User::unSetOptionForAll($name)
User::getOption($name, $userId = 0, $default = '')
User::getTime($userId = 0)
User::checkAccessOperationInLevel($operationId, $levelId)
User::getAccessLevel($entityName, $levelName)
User::mapAccessOperationNames($entityName, array $names)
User::getAccessOperationsForEntity($entityName)
User::getAccessLevelsForEntity($entityName)
User::getOffset($userId)
User::getOccurAsIdKey()
User::isExternalUser($userID)
User::isAbsence(array $userIds)
UI::getClass($dataType)
UI::showEdit(array $field, array $parameters = array(), $component = null)
UI::showView($field, array $parameters = array())
UI::isSuitable(array $field)
UI::showUI($componentName, array $field, array $parameters = array(), $parentComponentInstance = null)
Enumeration::cloneValue($value, array &$entityData, array $fromField, array $toField, $userId = false)
Enumeration::getEnum($id)
DateTime::getFormatName()
DateTime::getFormatValue()
DateTime::getDefaultValueSingle(array $field)
Date::getFormatName()
Date::getFormatValue()
Restriction::canUse($entityCode, $userId = 0)
Restriction::canManage($entityCode, $userId = 0)
Restriction::canCreateMandatory($entityCode, $userId = 0)
Restriction::hadUserFieldsBefore($entityCode)
Template::getEntityCode()
User::getEntityCode()
Type::getClass($dataType)
Type::cloneValue($value, array &$entityData, array $fromField, array $toField, $userId = 0, array $parameters = array())
Type::cancelCloneValue($value, array $fromField, array $toField, $userId = false)
Type::getDefaultValueSingle(array $field)
Type::translateValueByMultiple($value, array $fromField, array $toField)
Task::getEntityCode()
Task::getSysScheme()
Assert::expectInteger($arg, $argName = '', $customMsg = '')
Assert::expectIntegerPositive($arg, $argName = '', $customMsg = '')
Assert::expectIntegerNonNegative($arg, $argName = '', $customMsg = '')
Assert::expectStringNotNull($arg, $argName = '', $customMsg = '')
Assert::expectArray($arg, $argName = '', $customMsg = '')
Assert::expectArrayNotEmpty($arg, $argName = '', $customMsg = '')
Assert::expectArrayOfUniqueIntegerNotNull($arg, $argName = '', $customMsg = '')
Assert::expectArrayOfUniqueStringNotNull($arg, $argName = '', $customMsg = '')
Assert::expectEnumerationMember($arg, $enum = array(), $argName = '', $customMsg = '')
Assert::formMessage($msgCode, $argName = '', $customMsg = '')
Type::isIterable($arg)
Type::checkYNKey(array &$data, $paramName)
Type::checkBooleanKey(array &$data, $paramName, $default = null)
Type::checkEnumKey(array &$data, $paramName, array $enum, $default = null)
Type::checkArrayOfUPIntegerKey(&$data, $paramName)
Type::castToArrayOfUniquePositiveInteger($arg)
Type::serializeArray($data, $returnFalse = false)
Type::unSerializeArray($data)
Type::normalizeArray($data)
Type::normalizeArrayOfUInteger($data)
Type::checkDateTimeString($arg)
AgentManager::notificationThrottleRelease()
AgentManager::sendReminder()
AgentManager::rotateSystemLog()
AgentManager::createOverdueChats()
AgentManager::checkAgentIsAlive($name, $interval)
AgentManager::__callStatic($name, $arguments)
Collection::isSuccess()
Collection::getErrors()
Collection::addError($code, $message, $type = Error::TYPE_FATAL, $data = null)
Collection::addException($e, $message = '', $settings = array())
Collection::findOne($conditions = array())
Collection::sort($conditions = array())
Collection::push($data)
Collection::unShift($data)
Collection::update(array $conditions, $data, $limit = -1)
Collection::updateOne(array $conditions, $data)
Collection::delete($conditions, $limit = -1)
Collection::deleteOne(array $conditions)
Collection::last()
Collection::nth($num)
Collection::export($exporter = null)
Integration::isInstalled()
Integration::includeModule()
Integration::checkModuleInstalled()
Manager::getIsMultiple()
Manager::getCode($prefix = false)
Manager::getTask($userId, $taskId)
Manager::ensureHaveErrorCollection(&$parameters)
Manager::filterData(array $data, array $fieldMap, Collection $errors)
Manager::makeDeltaSets(array $items, array $currentItemsData)
Manager::detectItemChanged(array $itemThen, array $itemNow)
Manager::ensureCanUpdate(array $toUpdateItems, array $currentItems, Collection $errors, $itemName = '')
Manager::ensureCanDelete(array $toDeleteItems, array $currentItems, Collection $errors, $itemName = '')
Manager::getItemsInoperable(array $toActionItems, array $currentItems, array $actions)
Manager::checkCanDoOnItem(array $itemCan, $op)
Manager::checkCanReadTaskThrowException($userId, $taskId)
Manager::checkSetPassed(array $set, $mode)
Manager::indexItemSets(array $set)
Manager::extractPrimaryIndex(array $data)
Manager::checkIsSubEntityKey($key)
Manager::mergeData($primary = array(), $secondary = array())
Manager::normalizeData($data)
Manager::extractPrimaryIndexes($data)
Manager::getLegalSubEntities()
Manager::stripSubEntityData(array $data)
Calendar::findWorkTimeTest()
Calendar::printDebugTime($l, $t)
RunTimeOperation::__construct($operation, array $parameters = array())
RunTimeOperation::call()
RunTimeOperation::getOperation()
RunTimeOperation::getErrors()
RunTimeOperation::parse()
RunTimeOperation::addParseError($message)
PublicCallable::__construct()
PublicCallable::getErrorCollection()
PublicCallable::getForbiddenMethods()
PublicCallable::checkTaskId($id)
PublicCallable::checkId($id, $itemName = 'Item')
ToDo::__construct($action, $arguments, $parameters = array())
ToDo::setResult($result)
ToDo::setAction($action)
ToDo::getAction()
ToDo::getCode()
ToDo::setCode($code)
ToDo::getArguments()
ToDo::setArguments($arguments)
ToDo::getResult()
ToDo::isProcessed()
ToDo::isSuccess()
ToDo::export()
ToDo::offsetExists($offset)
ToDo::offsetGet($offset)
ToDo::offsetSet($offset, $value)
ToDo::offsetUnset($offset)
ToDo::getClass()
ToDo::isA($object)
Operation::__construct($operation, array $parameters = array())
Operation::parse()
Operation::call()
Operation::prepareArguments()
Operation::getMethodSignature()
Operation::checkClass()
Operation::parseQueryPath($path)
Operation::addParseError($message)
Operation::getSupplementaryErrorInfo()
Operation::getOperation()
Operation::getErrors()
Operation::getErrorCollection()
RestrictedAction::canExecute()
ExecutionResult::isSuccess()
PublicAction::__construct()
PublicAction::getErrors()
PublicAction::canExecute()
PublicAction::getErrorCollection()
PublicAction::isVersionGT()
PublicAction::getForbiddenMethods()
PublicAction::checkTaskId($id)
PublicAction::checkId($id, $itemName = 'Item')
PublicAction::getComponentHTML($name, $template = '', array $callParameters = array(), array $parameters = array())
Group::get($id)
Dependence::add($taskIdFrom, $taskIdTo, $linkType)
Dependence::delete($taskIdFrom, $taskIdTo)
Reminder::getListByTask($taskId, array $order = array())
Reminder::getListByCurrentUser()
Reminder::add(array $data, array $parameters = array())
Reminder::deleteByCurrentUser()
Favorite::add($taskId)
Favorite::delete($taskId)
ElapsedTime::getListByTask($taskId, array $order = array(), array $filter = array())
ElapsedTime::add($userId, array $data, array $parameters = array('PUBLIC_MODE' => false))
ElapsedTime::update($userId, $itemId, array $data, array $parameters = array('PUBLIC_MODE' => false))
ElapsedTime::delete($id)
ElapsedTime::getOwnerTaskId($itemId)
ElapsedTime::checkId($id)
CheckList::getListByTask($taskId, array $order = array())
CheckList::add($userId, array $data, array $parameters = array('PUBLIC_MODE' => false))
CheckList::update($userId, $itemId, array $data, array $parameters = array('PUBLIC_MODE' => false))
CheckList::delete($id)
CheckList::complete($id)
CheckList::renew($id)
CheckList::moveAfter($id, $afterId)
CheckList::getOwnerTaskId($itemId)
CheckList::checkId($id)
Task::get($userId, $taskId, array $parameters = array())
Task::getList($userId, array $listParameters = array(), array $parameters = array())
Task::add($userId, array $data, array $parameters = array('PUBLIC_MODE' => false, 'RETURN_ENTITY' => false))
Task::update($userId, $taskId, array $data, array $parameters = array('PUBLIC_MODE' => false, 'RETURN_ENTITY' => false))
Task::delete($id, array $parameters = array())
Task::getAllowedActions($id)
Task::start($id)
Task::pause($id)
Task::complete()
Task::accept($id)
Task::decline($id)
Task::renew($id)
Task::defer($id)
Task::approve($id)
Task::disapprove($id)
Task::startWatch($id)
Task::stopWatch($id)
Task::translateAllowedActionNames($can)
Plan::export($exporter = null)
Plan::getOperationByCode($code)
Plan::push($data)
Plan::addToDo($operation, $arguments = array(), $parameters = array())
Plan::offsetSet($offset, $value)
Plan::import($todoList)
Plan::exportResult()
Plan::replaceThis($part)
Plan::ensureHasCode($op)
Intranet::absence(array $userIds)
TimeManager::start($taskId, $stopPrevious = false)
TimeManager::stop($taskId)
SocialNetwork::getDestinationData($context = 'TASKS')
SocialNetwork::setDestinationLast($items = array(), $context = 'TASKS')
SocialNetwork::getValidDestinationDataContexts()
ListControls::add($data, $parameters = array())
ListControls::unserializeArray($key, $data)
ListControls::getTaskPosition($taskId, array $getListParameters)
ListControls::getJson($task, $arPaths, $nameTemplate)
ListControls::toggleGroupByTasks()
ListControls::toggleGroupByGroups()
Task::edit($taskId = 0, array $parameters = array())
Template::get($userId, $itemId, array $parameters = array())
Template::find(array $parameters = array())
Template::add($userId, array $data, array $parameters = array('PUBLIC_MODE' => false))
Template::update($userId, $itemId, array $data, array $parameters = array('PUBLIC_MODE' => false))
Template::delete($id)
Template::startReplication($id)
Template::stopReplication($id)
Template::toggleReplication($id, $way)
Template::prepareMembers(array &$data)
Template::placeMemberIds(array &$data, $fieldName, array $toInvite)
Template::getInvitationsFrom(array $data, $fieldName, &$toInvite)
Timer::start($taskId, $stopPrevious = false)
Timer::stop($taskId)
Stages::isAdmin()
Stages::checkSonetInstalled()
Stages::canReadGroupTask($groupId)
Stages::canEditGroupStages($groupId)
Stages::canSortTask($entityId, $entityType, $checkMode = false)
Stages::modify($fields, $isAdmin = false)
Stages::add($fields, $isAdmin = false)
Stages::update($id, $fields, $isAdmin = false)
Stages::delete($id, $isAdmin = false)
Stages::get($entityId, $numeric = false, $isAdmin = false)
Stages::canMoveTask($entityId, $entityType)
Stages::moveTask($id, $stageId, $before = 0, $after = 0)
Notification::throttleRelease()
Sorting::move($data)
Task::find(array $parameters = array())
Task::setdeadline($id, $newDeadline, array $parameters = array())
Task::substractDeadline($id, $num, $type, array $parameters = array())
Task::adjustDeadline($id, $num, $type, array $parameters = array())
Task::addtofavorite($id, array $parameters = array())
Task::removefromfavorite($id, array $parameters = array())
Task::delegate($id, $userId)
Task::checkCanRead($id)
Task::enterAuditor($id)
Task::leaveAuditor($id)
Task::addAuditor($id, $auditorId)
Task::addAccomplice($id, $accompliceId)
Task::setGroup($id, $groupId)
Task::setResponsible($id, $responsibleId)
Task::setOriginator($id, $originatorId)
Exception::getDefaultMessage()
BadQueryException::getDefaultMessage()
Item::getDataSourceClass()
Item::getUserFieldControllerClass()
Item::getAccessControllerClass()
Item::getCollectionClass()
Item::getLegacyEventMap()
Item::__construct($source = 0, $userId = 0)
Item::getData($select = array(), array $parameters = array())
Item::decodeSelectExpression($select)
Item::isWidlCard($expression)
Item::isRegularExpression($expression)
Item::setData(array $data, array $parameters = array())
Item::clearData()
Item::setFieldModified($field)
Item::setFieldUnModified($field)
Item::getModifiedFields()
Item::getCachedFields()
Item::getChangedFields()
Item::isFieldModified($field)
Item::clearModifiedFields()
Item::offsetSet($offset, $value)
Item::offsetGet($offset)
Item::offsetSetConfigurable($offset, $value, array $parameters = array())
Item::offsetGetDirect($offset)
Item::offsetSetDirect($offset, $value)
Item::offsetGetPristine($offset)
Item::containsKey($key)
Item::getCachedOffsetCodes()
Item::fetchBaseData($fetchBase = true, $fetchUFs = false)
Item::fetchDataAndCache($fetchBase = true, $fetchUFs = false)
Item::setDataFromDataBase($data)
Item::&getContextData()
Item::&getContextFlags()
Item::getId()
Item::setId($id)
Item::isAttached()
Item::getTransitionState()
Item::getUserId()
Item::setUserId($userId)
Item::getAccessController()
Item::getAccessControllerDefault()
Item::setAccessController($instance)
Item::getContext()
Item::setContext($ctx)
Item::getUserFieldController()
Item::setUserFieldController($ufc)
Item::makeInstanceFromSource($data, $userId = 0)
Item::getInstance($id, $userId = 0)
Item::save($settings = array())
Item::fixGlobalUser($userId)
Item::restoreGlobalUser($fixed)
Item::delete($parameters = null)
Item::find(array $parameters = array(), $settings = null)
Item::findOne(array $parameters, $settings = null)
Item::getCollectionInstance(array $values = null)
Item::generateMap(array $parameters = array())
Item::prepareData($result)
Item::checkData($result)
Item::modifyTabletDataBeforeSave($data)
Item::doPreActions($state)
Item::doPostActions($state)
Item::executeHooksBefore($state)
Item::executeHooksAfter($state)
Item::export($select = array(), $exporter = null)
Item::getArray()
Item::transform($converter)
Item::transformWith($converter)
Item::abortTransformation($converter)
Item::getUserFieldScheme($getValue = false, array $settings = array())
Item::__call($name, array $arguments)
Item::getBatchState()
Item::enterBatchState()
Item::leaveBatchState()
Item::processEnterBatchMode(State\Trigger $state)
Item::processLeaveBatchMode(State\Trigger $state)
Item::&getCache()
Item::setDataContext($ctxName)
Item::setDefaultDataContext()
Item::setImmutable()
Item::isImmutable()
Item::callCanMethod($name, $arguments)
Item::checkConverter($converter)
Item::setTabletLoaded()
Item::isTabletLoaded()
Item::setUFLoaded()
UserField::getTargetEntityId()
UserField::getClassName()
UserField::getAvailableMethods()
UserField::runRestMethod($executiveUserId, $methodName, array $args)
UserField::getFieldList($parameters = array())
UserField::postProcessValues($values, $parameters = array())
Disk::getFileData($fileNodeId, $parameters = array())
ElapsedTimeTable::getList(array $parameters = array(), $behaviour = array())
ElapsedTimeTable::parseOutSimpleAggregations(array $list, array &$runtime)
User::isNetworkId($id)
User::create(array $data, Collection $errors = null)
Bitrix24::getSettingsURL()
Bitrix24::checkToolAvailable($toolName)
Bitrix24::checkFeatureEnabled($featureName)
Bitrix24::isLicensePaid()
Bitrix24::isLicenseShareware()
Timeman::canUse()
UserField::getMainSysUFCode()
UserField::getSysUFScheme()
UserField::getLangs()
Extranet::isExtranetSite($siteId = '')
Extranet::isConfigured()
Task::index($task)
IM::notifyAdd($message)
Department::getSubordinateIds($userId = 0, $recursive = false)
Department::getSubIds($id, $direct = true, $flat = false)
Department::getData(array $departmentIds)
Department::getCompanyStructure()
Department::getIBlockSections(array $select = array())
Department::replaceIBSField(array $sections)
User::getDepartmentUFCode()
User::isDirector($userId = 0)
User::getSubordinateSubDepartments($userId = 0, $allowedDepartments = null)
User::getSubordinate($userId = 0, $allowedDepartments = null, $includeSubDepartments = false)
User::getByDepartments($arDepartmentsIds, $arFields = array('ID'))
User::searchImmediateEmployeesInSubDepartments($departmentId)
User::getDepartmentsUsersIds($arDepartmentsIds)
Subordinate::getSubordinateFilter($parameters)
Department::get(array $parameters = array())
Department::getSub(array $parameters = array())
UserDepartment::getSubordinateFilter(array $parameters = array())
UserDepartment::getUserPrimaryDepartmentField(array $parameters = array())
Disk::uploadFile(array $file, $userId = 0)
Disk::addFile($file, $userId = 0)
Disk::getAttachmentIdByLegacyFileId($fileId, $entityType)
Disk::cloneFileAttachment(array $attachments = array(), $userId = 0)
Disk::cloneFileAttachmentHash(array $attachments = array(), $userId = 0)
Disk::deleteUnattachedFiles(array $files, $userId = 0)
Disk::getAttachmentData(array $valueList)
Disk::onBuildConnectorList()
Group::clearCaches()
Group::can($id, $actionCode, $userId = 0)
Group::getIdsByAllowedAction($actionCode = 'view_all', $ownGroups = true, $userId = 0)
Group::getData(array $groupIds)
Group::updateLastActivity($id)
Group::extractPublicData(array $group)
ContentViewHandler::getContentTypeIdList()
ContentViewHandler::onContentViewed(\Bitrix\Main\Event $event)
Log::getEventIdList()
Log::onIndexGetContent(Event $event)
Task::getActionPath($groupId = 0, $userId = 0, $siteId = '')
Task::formatFeedEntry($arFields, $arParams)
UserToGroup::getFilterByGroup(array $groups)
Task::getCommentForumId()
Task::onSonetLogFavorites(array $params)
Task::toggleFavorites(array $params)
Task::getSonetLogByTaskId($taskId)
Task::addContextToURL($url, $taskId)
Comment::makeUrlHash($commentId)
Comment::getUrlParameters($commentId)
Comment::makeUrl($url, $commentId)
Comment::getOccurAsId($authorId)
Comment::getUrlHashPrefix()
Comment::getForumId()
Comment::add($taskId, array $data)
Comment::update($id, array $data, $taskId = false)
Comment::delete($id, $taskId = false)
Comment::onAfterAdd($entityType, $taskId, $arData)
Comment::onAfterUpdate($entityType, $taskID, $arData)
Comment::getTaskMembersByTaskId($taskId, $excludeUser = 0)
Comment::fireEvent($action, $taskId, $fields, $arFilesIds = array(), $urlPreviewId = '')
Comment::addLogItem(array $fields)
Comment::processMentions(array $fields)
Comment::sendNotification($messageData, $taskData, $fromUser, $toUsers, array $eventData = array())
Comment::cropMessage($message)
Comment::getUserId()
Comment::addWebDavFileRights($taskId, $arFilesIds)
Comment::getFileCount($topicId, $forumId = 0)
Topic::onBeforeAdd($entityType, $entityId, $arPost, &$arTopic)
Topic::onAfterAdd($entityType, $entityId, $topicId)
Topic::getFileCount($topicId, $forumId = 0)
Topic::delete($id)
Forum::getParser(array $parameters = array())
User::getExternalCode()
User::isEmail($data)
Task::onReplyReceived(Event $event)
Task::onForwardReceived(Event $event)
Task::getDefaultPublicPath($taskId)
Task::getReplyTo($userId, $taskId, $postUrl, $siteId, $backUrl = '')
Task::getBackUrl($userId, $taskId, $postUrl, $siteId, $backUrl = '')
Task::getLinks($userId, $taskId, $postUrl, $siteId, $backUrl = '')
TaskTable::getMap()
TaskTable::getChildrenTasksData($taskId, $parameters = array())
TaskTable::getRuntimeMixins(array $mixins = array())
TaskTable::getRuntimeFieldMixinsFavorite($parameters)
TaskTable::getRuntimeFieldMixinsInFavorite($parameters)
TaskTable::getRuntimeFieldMixinsLegacyFilter($parameters)
TaskTable::getRuntimeFieldMixinsCheckRights($parameters)
TaskTable::getDbTruncTextFunction($dbtype, $param)
TaskTable::getRuntimeFieldMixins($mixinCodes, $parameters = array())
Runtime::applyChatNotExist()
Task::postMessage($chatId, $message, $task = null)
Task::openChat($task)
User::getAccessible()
User::clear()
User::isExtranet($user = 0)
UI::initLicensePopup($group = 'tasks')
UI::getLicenseUrl()
Attachment::getById($id, $parameters = array())
Attachment::add($ownerId, array $fileParameters, array $parameters)
Attachment::delete($ownerId, $id, array $parameters = array())
Attachment::uploadFile($name, $content, array $parameters = array())
Attachment::getIdByFileId($fileId, $ownerId, $entityId, $fieldName)
Attachment::getValue($ownerId, $entityId, $fieldName)
Attachment::checkFieldExists($entityId, $fieldName)
Attachment::checkFieldExistsThrowException($entityId, $fieldName)
Attachment::includeDisk()
Template::getTitle()
Template::loadTaskData($userId)
Template::addComment($authorId, array $data)
Task::canRead($userId)
Task::canUpdate($item, $userId = 0)
Task::getDataToShow()
Task::getTitle()
Task::getDestinations()
Task::loadTaskData($userId)
Task::addComment($authorId, array $data)
Task::getFilesCount($id)
Task::getCover($id, $width=0, $height=0)
Type::removeRawAttachments($message, $attachmentData)
Type::translateRawAttachments($message, $map, $attachmentData)
Task::getSysUFCode()
SocialNetwork::enable()
SocialNetwork::disable()
SocialNetwork::isEnabled()
SocialNetwork::getUserEntityPrefix()
SocialNetwork::getGroupEntityPrefix()
SocialNetwork::getDepartmentEntityPrefix()
SocialNetwork::getLogDestination($context = 'TASKS', array $parameters = array())
SocialNetwork::setLogDestinationLast(array $items = array(), $context = 'TASKS')
SocialNetwork::getParser(array $parameters = array())
SocialNetwork::formatDateTimeToGMT($time, $userId)
SocialNetwork::reformatLastItems(&$result, $from, $to, $items)
Pull::emitMultiple(array $recipients, $tag, $cmd, $params)
Mail::getSubjectPrefix()
Mail::formatThreadId($tag, $siteId = '')
Mail::getDefaultEmailFrom($siteId = '')
Mail::stopMailEventCompiler()
Mail::processAttachments($message, array $attachments, $userId)
Mail::translateRawAttachments($message, $attachmentRelations)
TemplateHelper::__construct($name, $template, array $parameters = array())
TemplateHelper::registerExtension(array $relations = array())
TemplateHelper::initializeExtension(array $data = array())
TemplateHelper::pickId()
TemplateHelper::getId()
TemplateHelper::getScopeId()
TemplateHelper::getComponent()
TemplateHelper::displayFatals()
TemplateHelper::displayWarnings()
TemplateHelper::checkHasFatals()
TemplateHelper::findParameterValue($parameter)
TemplateHelper::fillTemplate($template, $data)
TemplateHelper::getErrors()
TemplateHelper::addBodyClass($className = '')
TemplateHelper::setTitle($title)
TemplateHelper::setNavChain(array $chain)
TemplateHelper::addMethod($name, $cb)
TemplateHelper::getRunTimeActions()
TemplateHelper::__call($name, $arguments)
TemplateHelper::getExtensionId()
Task::buildPreview(array $params)
Task::checkUserReadAccess(array $params)
Task::getImAttach(array $params)
Task::getUser()
Editor::getHTML(array $parameters)
Editor::getEditorParameters(array $parameters)
Editor::getEditorProperties(array $parameters)
Editor::getEditorButtonsHTML(array $parameters)
Editor::getEditorButtons(array $parameters)
Filter::getGrid()
Filter::getGridId()
Filter::getMetaStatus($code)
Filter::getCounters()
Filter::getFilter()
Filter::getPresets()
Filter::fillFilter(array $filter = array())
Kanban::getAvailableFields()
Filter::prepareFilter($filter)
Filter::processFilter($filter, $depth = 0)
Filter::normalizeFilter($filter)
Filter::prepareMetaField($key, $val)
Filter::prepareDateField($key, $val)
Filter::prepareNegativeStatusField($statuses)
Task::getAvailableFields()
Task::getGridOptions()
Task::getFilterId()
Task::setFilterId($filterId)
Task::getPresets()
Task::processFilter($processGridFilter = true)
Task::processSpecialPresetsFilter()
Task::processGridFilter(&$stateFilter = array())
Task::getFilters()
Task::getDefaultFilterFields()
Task::getVisibleColumns()
Task::getDefaultVisibleColumns()
Task::getFilterRaw()
Task::getAllowedTaskCategories()
Task::getListStateInstance()
Task::getUserId()
Task::setUserId($userId)
Task::getFilterData()
Task::getFilterOptions()
Task::processStateFilter()
Task::getListCtrlInstance()
Task::getFilterCtrlInstance()
Task::getGroupId()
Task::setGroupId($groupId)
Task::listStateInit()
Template::makeActionUrl($path, $templateId = 0, $actionId = 'edit')
Template::makeReplicationPeriodString($arParams)
CheckList::checkIsSeparatorValue($value)
Tag::formatTagString($tags)
Column::getFieldsForSorting()
Column::getFieldsForSortingRaw()
Task::makeCopyUrl($url, $taskId)
Task::makeCreateSubtaskUrl($url, $taskId)
Task::makeFireEventUrl($url, $taskId, $eventType, array $eventOptions = array())
Task::cleanFireEventUrl($url)
Task::makeActionUrl($path, $taskId = 0, $actionId = 'edit', $userId = false)
Task::getUserInfo($userId, $needFullName = true)
Bind::start()
TaskAttachmentHandler::updateUserField($taskId, $diskAttachId)
TaskAttachmentHandler::getUserField($taskId)
TaskAttachmentHandler::onExecuteDescriptionFix(\Bitrix\Main\Event $event)
TaskHandler::__construct()
TaskHandler::initDataManagerEvents()
TaskHandler::onTaskAdd($id, &$data)
TaskHandler::onBeforeTaskUpdate($id, &$data, &$copy)
TaskHandler::onTaskUpdate($id, &$data, &$copy)
TaskHandler::onTaskDelete($id)
TaskHandler::onBeforeTaskZombieDelete($id)
TaskHandler::onTaskZombieDelete($id)
TaskHandler::afterWriteMissing(array $record)
TaskHandler::beforeLogFormat(array &$record)
TaskHandler::beforeInsertTrigger(array &$newRecord)
TaskHandler::beforeUpdateTrigger(array $oldRecord, array &$newRecord)
TaskHandler::afterInsertTrigger(array $newRecord)
TaskHandler::afterUpdateTrigger(array $oldRecord, array $newRecord)
TaskHandler::updateAction(array $oldRecord, array $newRecord)
TaskHandler::deleteAction(array $oldRecord)
TaskChecklistItemHandler::initDataManagerEvents()
TaskChecklistItemHandler::onCheckListItemMoveItem($selectedItemId, $insertAfterItemId)
TaskChecklistItemHandler::onExecuteCheckListItemMoveItem(\Bitrix\Main\Event $event)
TaskLogHandler::__construct()
TaskLogHandler::beforeLogInsert(array $record)
TaskLogHandler::fromValueTranslation($record)
TaskLogHandler::toValueTranslation($record)
TaskLogHandler::beforeLogFormat(array &$record)
TaskLogHandler::beforeInsertTrigger(array &$newRecord)
TaskLogHandler::usersFromLocalToRemote($userList)
TaskLogHandler::usersFromRemoteToLocal($userList)
TaskTagHandler::initDataManagerUpdate()
TaskTagHandler::afterUpdateEventHandler(\Bitrix\Main\Entity\Event $event)
DependenceTable::getTableName()
DependenceTable::getIDColumnName()
DependenceTable::getPARENTIDColumnName()
DependenceTable::allowMultipleParents()
DependenceTable::getLinkCountForUser($userId = 0)
DependenceTable::createLink($id, $parentId, $behaviour = array())
DependenceTable::applyCreateRestrictions(&$id, &$parentId)
DependenceTable::checkLinkExists($id, $parentId, array $parameters = array('BIDIRECTIONAL' => false))
DependenceTable::applyDeleteRestrictions(&$id, &$parentId)
DependenceTable::getListByLegacyTaskFilter(array $filter = array(), array $parameters = array())
DependenceTable::getSubTreeSql($id)
DependenceTable::getRelationHash($id, array $parameters = array())
DependenceTable::getMap()
DependenceTable::validateType()
DependenceTable::moveLink($id, $parentId, $behaviour = array('CREATE_PARENT_NODE_ON_NOTFOUND' => true))
DependenceTable::link($id, $parentId)
DependenceTable::unlink($id)
ProjectsTable::getTableName()
ProjectsTable::getMap()
ProjectsTable::set($id, $fields)
ProjectsTable::onSocNetGroupDelete($groupId)
Trigger::setEnterCallback($cb)
Trigger::setLeaveCallback($cb)
Trigger::enter(array $values = array(), $mode = 1, $parameters = null)
Trigger::leave()
Trigger::fireLeaveCallback()
Trigger::accumulateArray($name, array $items = array())
Trigger::getArray($name)
Converter::getTargetItemClass()
Converter::getSubEntityConverterClassMap()
Converter::setConfig($field, $value)
Converter::getConfig($field)
Converter::convert($instance)
Converter::abortConversion($instance)
Converter::getContext()
Converter::setContext($ctx)
Converter::transformData(array $data, $srcInstance, $dstInstance, $result)
Converter::convertUserFieldData($srcInstance, $dstInstance, $result)
Converter::getConverterForSubEntity($name)
Converter::getClass()
Converter::isA($object)
Template::addDataBaseAccessCheck($query, array $parameters = array())
Template::canRead($item, $userId = 0)
Template::canUpdate($item, $userId = 0)
Template::canDelete($item, $userId = 0)
Template::grantAccessLevel($templateId, $groupCode, $level, array $parameters = array())
Template::revokeAccessLevel($templateId, $userId, $level)
Template::revokeAll($templateId, array $parameters = array())
Template::askEightBall($item, $userId, $operation)
Task::addDataBaseAccessCheck($query, array $parameters = array())
Task::canCreate($item, $userId = 0)
Task::canUpdatePlanDates($item, $userId = 0)
Task::isRoleCreatorOrDirectorOfCreator($item, $userId)
Task::getSubordinate($userId)
Access::disable()
Access::enable()
Access::isEnabled()
Access::canCreate($item, $userId = 0)
Access::canRead($item, $userId = 0)
Access::canUpdate($item, $userId = 0)
Access::canDelete($item, $userId = 0)
Access::canFetchData($item, $userId = 0)
Access::addDataBaseAccessCheck($query, array $parameters = array())
Access::__call($name, array $arguments)
Canonical::__construct(array $parameters = array())
Canonical::export($item, $select = array())
Canonical::exportTypeValue($v, $item)
Access::allow($action)
Access::deny($action)
Access::setImmutable()
Access::isImmutable()
Access::spawn()
Access::getClass()
Template::getItemClass()
Template::getConverterClass()
Template::produceSubItemsFrom($source, $destination, array $parameters = array(), $userId = 0)
Template::getSubEntitiesData($id)
Template::doPostActions($state)
Template::produceReplicas(Result $result, $source, $destination, $data, $tree, array $parameters = array(), $userId = 0)
Template::createItemFromData($data, $dataMixin, $userId)
Template::getCreationOrder(array $subEntitiesData, $srcId)
Result::getSubInstanceResults()
Task::getItemClass()
State::__construct(array $values = null)
State::enter(array $values = array(), $mode = 1, $parameters = null)
State::leave()
State::isInProgress()
State::isModeCreate()
State::isModeUpdate()
State::isModeDelete()
State::getMode()
State::getResult()
State::getEnterTime()
State::getParameters()
State::getEnterTimeObject()
State::getEnterTimeFormatted()
State::getEnterTimeAsDateTime()
State::containsKey($key)
State::setValue($key, $value)
SubItem::getParentConnectorField()
SubItem::getParentClass()
SubItem::getParent()
SubItem::setParent($instance)
SubItem::setParentId($id)
SubItem::getParentId()
SubItem::getUserId()
SubItem::prepareData($result)
SubItem::findByParent($parentId, array $parameters = array(), $settings = null)
SubItem::deleteByParent($parentId, array $parameters = array(), $settings = null)
SubItem::getBindCondition($parentId)
SubItem::callCanMethod($name, $arguments)
Member::getParentConnectorField()
Member::getDataSourceClass()
Member::getCollectionClass()
Template::getDataSourceClass()
Template::getAccessControllerClass()
Template::getUserFieldControllerClass()
Template::generateMap(array $parameters = array())
Template::prepareData($result)
Template::checkData($result)
Template::modifyTabletDataBeforeSave($data)
Template::doPreActions($state)
Template::transformToTemplate()
Template::transformToTask()
Template::checkDataBaseItem($result)
Template::checkDataMultitasking()
Template::checkDataTypeNewUser($result)
Template::checkFieldCombinations($result)
Template::setNoMultitaskingAllowed($result, $message = '')
Template::setNoBaseTemplateAllowed($result, $message = '')
Template::setNoReplicationAllowed($result, $message = '')
Template::setNoTParamType1Allowed($result, $message = '')
Template::getActualFieldValue($name)
Member::getItemClass()
Member::updateValuePart($valuePart, $valueType, $item)
Member::getUserIds()
CheckList::getItemClass()
CheckList::getSortColumnName()
CheckList::getCheckedColumnName()
CheckList::sealSortIndex()
CheckList::moveItemAfter($id, $afterId)
CheckList::setSortByValueOrder()
Tag::getItemClass()
Tag::updateValue($value, $item)
Tag::joinNames($separator = ',')
Log::getParentConnectorField()
Log::getDataSourceClass()
ProjectDependence::getParentConnectorField()
ProjectDependence::getDataSourceClass()
ProjectDependence::getBindCondition($parentId)
CheckList::getParentConnectorField()
CheckList::getDataSourceClass()
CheckList::getCollectionClass()
CheckList::getFieldTitleHTML()
CheckList::findByParent($parentId, array $parameters = array(), $settings = null)
CheckList::prepareData($result)
CheckList::isCompleted()
Parameter::getParentConnectorField()
Parameter::getDataSourceClass()
Parameter::getParentClass()
Access::getParentConnectorField()
Access::getDataSourceClass()
Access::getCollectionClass()
Access::getParentClass()
Access::getGroupPrefix()
Access::getGroupId()
Access::onChange()
Access::parseGroupCode()
Access::getItemClass()
Access::grantAccessLevel($groupCode, $level)
Access::revokeAll()
Access::revokeAccessLevel($groupCode, $level)
CheckList::getParentClass()
CheckList::canToggle()
BaseTemplate::readValueFromDatabase($key, $item)
BaseTemplate::checkValue($value, $key, $item, array $parameters = array())
BaseTemplate::saveValueToDataBase($value, $key, $item)
BaseTemplate::translateValueFromOutside($value, $key, $item)
ReplicateParams::translateValueFromDatabase($value, $key, $item)
ReplicateParams::translateValueToDatabase($value, $key, $item)
ReplicateParams::createValue($value, $key, $item)
ReplicateParams::createValueStructure($value)
Access::hasDefaultValue($key, $item)
Access::getDefaultValue($key, $item)
Access::checkValue($value, $key, $item, array $parameters = array())
Access::getAccessLevelFullId()
Tag::getValue($key, $item, array $parameters = array())
Tag::setValue($value, $key, $item, array $parameters = array())
Responsible::getValue($key, $item, array $parameters = array())
Responsible::setValue($value, $key, $item, array $parameters = array())
Tag::translateValueFromDatabase($value, $key, $item)
Tag::translateValueToDatabase($value, $key, $item)
Tag::translateValueFromOutside($value, $key, $item)
Tag::createValue($value, $key, $item)
Tag::export($exporter = null)
Tag::filterArray($value)
SystemLog::getParentConnectorField()
SystemLog::getDataSourceClass()
SystemLog::externalizeFieldValue($name, $value)
SystemLog::internalizeFieldValue($name, $value)
Tag::getParentConnectorField()
Tag::getDataSourceClass()
Tag::getCollectionClass()
Tag::prepareData($result)
Member::saveValueToDataBase($value, $key, $item)
DependsOn::readValueFromDatabase($key, $item)
DependsOn::saveValueToDataBase($value, $key, $item)
Member::__construct(array $parameters)
Member::getValue($key, $item, array $parameters = array())
Member::setValue($value, $key, $item, array $parameters = array())
MemberOne::__construct(array $parameters)
MemberOne::getValue($key, $item, array $parameters = array())
MemberOne::setValue($value, $key, $item, array $parameters = array())
ProjectDependence::getItemClass()
ProjectDependence::saveValueToDataBase($value, $key, $item)
CheckList::onBeforeSaveToDataBase($value, $key, $item)
Parameter::getItemClass()
Tag::saveValueToDataBase($value, $key, $item)
Replicator::getItemClass()
Replicator::getConverterClass()
Replicator::setConverter($converter)
Replicator::getConverter()
Replicator::produceFrom($sourceId, $userId = 0, array $parameters = array())
Replicator::produceSubItemsFrom($source, $destination, array $parameters = array(), $userId = 0)
Replicator::doPostActions($srcInstance, array $parameters = array())
Context::getUserId()
Context::getSiteId()
Context::getNow()
Context::setUserId($userId)
Context::setNow(DateTime $now)
Context::setImmutable()
Context::isImmutable()
Context::spawn()
Context::getDefault()
Context::getClass()
Context::isA($object)
Result::setInstance($instance)
Result::getInstance()
Scalar::__construct(array $parameters)
Scalar::getName()
Scalar::setName($name)
Scalar::isCamelName($camelName)
Scalar::setDBName($name)
Scalar::getDBName()
Scalar::getTitle()
Scalar::setTitle($title)
Scalar::isDBReadable()
Scalar::setDBReadable($flag)
Scalar::isDBWritable()
Scalar::setDBWritable($flag)
Scalar::setOffsetGetCacheable($flag)
Scalar::isCacheable()
Scalar::isSortable()
Scalar::setSortable($flag)
Scalar::isFilterable()
Scalar::setFilterable($flag)
Scalar::isSourceTablet()
Scalar::isSourceUserField()
Scalar::isSourceCustom()
Scalar::setSource($source)
Scalar::getSource()
Scalar::hasDefaultValue($key, $item)
Scalar::getDefaultValue($key, $item)
Scalar::setDefaultValue($value)
Scalar::getValue($key, $item, array $parameters = array())
Scalar::setValue($value, $key, $item, array $parameters = array())
Scalar::prepareValue($value, $key, $item, array $parameters = array())
Scalar::checkValue($value, $key, $item, array $parameters = array())
Scalar::obtainResultInstance(array $parameters)
Scalar::readValueFromDatabase($key, $item)
Scalar::saveValueToDataBase($value, $key, $item)
Scalar::translateValueFromDatabase($value, $key, $item)
Scalar::updateRelatedFieldValues($value, $key, $item)
Scalar::getMergedValueSafe($value, $key, $item, array $parameters = array())
Scalar::translateValueToDatabase($value, $key, $item)
Scalar::translateValueFromOutside($value, $key, $item)
Scalar::createValue($value, $key, $item)
Scalar::makeValueSafe($value, $key, $item, array $parameters = array())
Scalar::offsetExists($offset)
Scalar::offsetGet($offset)
Scalar::offsetSet($offset, $value)
Scalar::offsetUnset($offset)
Scalar::getClass()
Scalar::isA($object)
Integer::translateValueFromOutside($value, $key, $item)
Map::placeField($field, $key = null)
Map::placeFields(array $fields)
Map::getField($key)
Map::decodeCamelFieldName($field)
Map::getFieldDBNamesBySourceType(array $types)
Map::getFieldDBNamesByNames(array $names)
Map::getTabletFieldNames()
Map::getUserFieldNames()
Map::getFieldsBySource($source)
Map::onChange()
Error::getItemCollectionClass()
Error::translateValueFromDatabase($value, $key, $item)
Error::translateValueToDatabase($value, $key, $item)
Error::translateValueFromOutside($value, $key, $item)
Error::createValue($value, $key, $item)
Scalar::clearArray($value)
Integer::clearArray($value)
Item::getItemClass()
Item::getItemCollectionClass()
Item::hasDefaultValue($key, $item)
Item::getDefaultValue($key, $item)
Item::readValueFromDatabase($key, $item)
Item::onBeforeSaveToDataBase($value, $key, $item)
Item::saveValueToDataBase($value, $key, $item)
Item::createValue($value, $key, $item)
Item::translateValueFromOutside($value, $key, $item)
Item::setValue($value, $key, $item, array $parameters = array())
Item::prepareValue($value, $key, $item, array $parameters = array())
Item::checkValue($value, $key, $item, array $parameters = array())
UFDate::getDefaultValue($key, $item)
UFDate::translateValueToDatabase($value, $key, $item)
UFDate::translateValueFromOutside($value, $key, $item)
UFDate::createValue($value, $key, $item)
Boolean::__construct(array $parameters)
Boolean::setEnumeration($enum)
Boolean::createValue($value, $key, $item)
Date::translateValueFromOutside($value, $key, $item)
Collection::__construct(array $parameters)
Collection::getItemCollectionClass()
Collection::translateValueFromDatabase($value, $key, $item)
Collection::translateValueFromOutside($value, $key, $item)
Collection::getDefaultValue($key, $item)
Collection::createValue($value, $key, $item)
Stub::convert($instance)
ToTaskCheckList::getTargetItemClass()
ToTaskCheckList::transformData(array $data, $srcInstance, $dstInstance, $result)
ToTaskCheckList::checkYN($value)
ToTaskTemplateCheckList::getTargetItemClass()
ToTaskTemplateCheckList::transformData(array $data, $srcInstance, $dstInstance, $result)
ToTask::getTargetItemClass()
ToTask::transformData(array $data, $srcInstance, $dstInstance, $result)
ToTemplate::getTargetItemClass()
ToTemplate::getSubEntityConverterClassMap()
ToTemplate::transformData(array $data, $srcInstance, $dstInstance, $result)
ToTask::getSubEntityConverterClassMap()
ToTask::getDateAfter(DateTime $now, $seconds)
Result::setConverter($converter)
Result::abortConversion()
TriggerState::setEnterCallback($cb)
TriggerState::setLeaveCallback($cb)
TriggerState::enter(array $values = array())
TriggerState::leave()
TriggerState::fireLeaveCallback()
TriggerState::accumulateArray($name, array $items = array())
TriggerState::getArray($name)
Collection::getItemClass()
Collection::onChange()
Collection::getItemById($id)
Collection::getItemIndexById($id)
Collection::containsId($id)
Collection::getIdCache()
Task::getDataSourceClass()
Task::getAccessControllerClass()
Task::getUserFieldControllerClass()
Task::generateMap(array $parameters = array())
Task::prepareData($result)
Task::checkData($result)
Task::doPostActions($state)
Task::executeHooksBefore($state)
Task::executeHooksAfter($state)
Task::fireLegacyEvent($state, $isBefore = true)
Task::processEnterBatchMode(State\Trigger $state)
Task::processLeaveBatchMode(State\Trigger $state)
Task::getShortPreview()
Task::getDuration($start = null, $end = null, array $parameters = array())
Task::touch($time = null)
Task::transformToTemplate()
Task::transformToTask()
Task::sendPullEvents($data, $result)
Task::addLogRecord($logData, $result)
Task::prepareLegacyData($pristine = false, $onlyModified = false)
Task::processSchedulerBefore()
Task::processSchedulerAfter()
SystemLog::generateMap(array $parameters = array())
SystemLog::prepareData($result)
SystemLog::rotate()
SystemLog::deleteByEntity($entityId, $entityType)
Impact::setDataUpdated(array $data)
Impact::getUpdatedData()
Impact::getDataPristine()
Impact::save()
Impact::getBaseMixin()
AutoCloser::processEntity($id, $data = array(), array $settings = array())
AutoCloser::getParentTree($id)
Impact::__construct($data, $userId = 0)
Impact::getId()
Impact::getFieldValueTitle()
Impact::setAsHead()
Impact::isHead()
Impact::setUserId($userId)
Impact::defineUserId($userId)
Impact::dump()
Impact::exportUpdatedData()
Impact::offsetExists($offset)
Impact::offsetGet($offset)
Impact::offsetSet($offset, $value)
Impact::offsetUnset($offset)
Scheduler::processEntity($id, $data = array(), array $settings = array())
Scheduler::defineTaskDates($task)
Scheduler::pushQueue($id, $handler)
Scheduler::reset()
Scheduler::getRelationProcessor($code)
Result::getImpactById($id)
Result::save($conditions = array())
Result::exportData()
RelationManager::getUserId()
RelationManager::setScheduler($instance)
RelationManager::getScheduler()
RelationManager::getCode()
RelationManager::processTask($rootImpact, $result)
RelationManager::isTaskBelong($id)
RelationManager::isDebugEnabled()
Relation::setTask($task)
Relation::getTask()
Relation::setParentTask($task)
Relation::getParentTask()
Relation::getTaskId()
Relation::getParentTaskId()
Impact::getDefaultDuration()
Impact::resetDates()
Impact::getParentId()
Impact::correctWorkTime(DateTime $startDate, Datetime $endDate, $duration)
Impact::getStartDateDelta()
Impact::shiftDates($offset)
Impact::getEndDateDelta()
Impact::matchWorkingTime(DateTime $startDate = null, Datetime $endDate = null, $duration = null)
Impact::getStartDatePlan($getCreatedDateOnNull = false)
Impact::getEndDatePlan()
Impact::getStartDatePlanGmt($getCreatedDateOnNull = false)
Impact::getEndDatePlanGmt()
Impact::setStartDatePlanUserTimeGmt($timeString, $preInit = true)
Impact::setEndDatePlanUserTimeGmt($timeString, $preInit = true)
Impact::getMatchWorkTime()
Impact::calculateDuration()
Impact::getStartDateOrCreatedDate($flag = true)
Impact::castToDateTimeGmt($date)
Impact::dateTimeGmtToLocalString($startDate)
Relation::__construct(array $data)
Relation::getType()
Relation::getLag()
Relation::setProcessed()
Relation::isProcessed()
Relation::getMinDate()
Relation::updateLag()
Relation::dump()
SubTask::getCode()
SubTask::processTask($rootImpact, $result, array $settings = array())
SubTask::updateDateBoundary($parentId, $id, $itemData, $miniMaxes, $isMin)
SubTask::internalUpdateDateBoundary($parentId, $id, $itemData, $miniMaxes, $isMin)
SubTask::isTaskBelong($id, $data = array())
SubTask::shiftSubTree(Impact $rootImpact, Fragment $globalTree)
SubTask::getInitialBoundaries($id, $fragment)
SubTask::internalGetInitialBoundaries($id, $fragment)
SubTask::isBracketTaskData($data)
SubTask::resizeBrackets(Fragment $fragment)
SubTask::isTaskFinite($data)
SubTask::getParentTree($id)
SubTask::getSubTree($id)
SubTask::getTreeParameters()
Project::getCode()
Project::processTask($rootImpact, $result, array $settings = array())
Project::isTaskBelong($id, $data = array())
Project::updateRelatedTasks($id, array $relations)
Project::checkCoherence($id, $tasks, $result)
Project::canModifyTask($task)
Project::dumpRelations($relations)
Runtime::checkParameters(array $parameters = array())
Runtime::getRecordCount(array $parameters = array())
Runtime::apply($query, array $runtimes)
Runtime::cloneFields(array $parameters = array())
ThrottleTable::getTableName()
ThrottleTable::getMap()
ThrottleTable::validateInformAuthor()
ThrottleTable::submitUpdateMessage($taskId, $authorId, array $stateOrig, array $stateLast)
ThrottleTable::getUpdateMessages()
ThrottleTable::cleanUp()
ThrottleTable::getByTaskId($taskId)
Dependence::getDataController()
Dependence::getNodeColumnName()
Dependence::getParentNodeColumnName()
Dependence::getDirectChildCount($ids, array $parameters = array())
Access::getAvailableOperations($ids, array $parameters = array())
Tree::link($id, $parentId)
Tree::unlink($id)
Tree::createLink($id, $parentId, $behaviour = array('LINK_DATA' => array()))
Tree::moveLink($id, $parentId, $behaviour = array('CREATE_PARENT_NODE_ON_NOTFOUND' => true))
Tree::deleteLink($id, $parentId = false, array $behaviour = array('CHILDREN' => 'unlink'))
Tree::deleteSubtree($id)
Tree::applyCreateRestrictions(&$id, &$parentId)
Tree::applyDeleteRestrictions(&$id, &$parentId)
Tree::getPathToNode($id, $parameters = array()) // $behaviour = array('SHOW_LEAF' => true)
Tree::getPathToNodeSql($id)
Tree::getSubTree($id, $parameters = array(), array $behaviour = array('INCLUDE_SELF' => true))
Tree::getSubTreeSql($id)
Tree::getLinkCount()
Tree::checkNodeExists($id)
Tree::checkLinkExists($id, $parentId)
Tree::getIDColumnName()
Tree::getPARENTIDColumnName()
Tree::getDIRECTColumnName()
Tree::getMap()
Tree::dropLinkL($id, $parentId = false, $behaviour = array('CHILDREN' => 'unlink'))
ClosureTree::getDataController()
ClosureTree::getNodeColumnName()
ClosureTree::getParentNodeColumnName()
ClosureTree::getTableName()
ClosureTree::canAttach($id, $parentId = 0)
ClosureTree::attach($id, $parentId = 0, array $settings = array())
ClosureTree::attachNew($id, $parentId, array $settings = array())
ClosureTree::detach($id)
ClosureTree::delete($id, array $settings = array())
ClosureTree::isNodeExist($id)
ClosureTree::isPathExist($parentId, $id, array $settings = array())
ClosureTree::getPath($id, array $parameters = array(), array $settings = array())
ClosureTree::getSubTree($id, array $parameters = array(), array $settings = array())
ClosureTree::getParentTree($id, array $parameters = array(), array $settings = array())
ClosureTree::getCount()
ClosureTree::getRootNode($id, array $parameters = array(), array $settings = array())
ClosureTree::ensureNodeExists($id)
Fragment::getData()
Fragment::getErrors()
Fragment::addError($code, $message, $type = Error::TYPE_FATAL, $data = null)
Fragment::isCorrect()
Fragment::getIds()
Fragment::getSubTree($point = 0)
Fragment::addNode($id, $parentId, $data = array())
Fragment::getNode($id)
Fragment::getNodeData($id)
Fragment::walkDepth($cb)
Fragment::walkDepthStep($id, $parentId, $cb, array $index, Result $result, array &$data, array &$met, $depth = 1)
Fragment::walkWidth($cb, $rootId = 0)
Fragment::getChildrenCount($id)
Fragment::setParentFor($id, $newParentId)
Fragment::includeSubTreeFragment($fragment, $parentId = 0)
Fragment::includeFragment($fragment)
Fragment::excludeSubTreeFragment($id, array $settings = array())
Fragment::onChange()
Fragment::getIndex()
Fragment::getParentIdFor($id)
Exception::__construct($message = false, array $data = array(), array $additional = array())
NodeNotFoundException::getDefaultMessage()
TargetNodeNotFoundException::getDefaultMessage()
ParentNodeNotFoundException::getDefaultMessage()
LinkExistsException::getDefaultMessage()
LinkExistsException::getMessageLang()
LinkNotExistException::getDefaultMessage()
LinkNotExistException::getMessageLang()
Common::parseFilter(array $filter)
Common::makeFilter(array $conditions)
Common::getTruncateTextFunction($columnName)
Common::checkColumnExists($tableName, $columnName)
Common::checkIsType($type)
Common::getDataTypeSql($type, $len = 0)
Common::wrapColumnWithFunction($columnName, $functions = array())
Common::getMaxTransferUnit()
Common::getBatchInsertHeadSql($tableName, $fields = array())
Common::getBatchInsertTailSql()
Common::getBatchInsertSeparatorSql()
Common::getBatchInsertValues($row, $tableName, $fields, $map)
Common::dropAutoIncrementRestrictions($tableName)
Common::restoreAutoIncrementRestrictions($tableName)
Common::incrementSequenceForTable($tableName)
Common::addPrimaryKey($tableName, $columns = array())
Common::addAutoIncrement()
Common::createIndex($tableName, $ixNamePostfix, $columns = array(), $unique = false)
Common::dropTable($tableName)
Common::checkTableExists($tableName)
Common::truncateTable($tableName)
Common::getTemporaryTableSubQuerySql($selectSql, $columnName)
Common::getTemporaryTableNameSql()
Common::checkIndexNameExists($indexName, $tableName)
Common::insertBatch($tableName, array $items)
Common::prepareSql($row, $fields, $map)
Common::checkSequenceExistsForTable($tableName)
Common::getIndexName($tableName, $ixNamePostfix, $columns = array())
Common::escapeArray($columns)
Helper::getTruncateTextFunction($columnName)
Helper::getAutoIncrementSql()
Helper::mergeTables($toTable, $fromTable, $fldMap, $fldCondition)
Helper::checkIndexNameExists($indexName, $tableName)
Helper::dropIndexByName($indexName, $tableName)
Helper::getMaxTransferUnit()
Helper::resetAutoIncrement($tableName, $startIndex = 1)
Helper::dropAutoIncrementRestrictions($tableName)
Helper::restoreAutoIncrementRestrictions($tableName)
Helper::changeAutoIncrementRestrictions($tableName, $way)
Helper::getDataTypeSql($type, $len = 0)
Helper::wrapColumnWithFunction($columnName, $functions = array())
Helper::getBatchInsertHeadSql($fields)
Helper::getBatchInsertTailSql()
Helper::getBatchInsertSeparatorSql()
Helper::getBatchInsertValues($row, $tableName, $fields, $map)
Helper::incrementSequenceForTable($tableName)
Helper::checkSequenceExistsForTable($tableName)
Helper::addAutoIncrement($tableName)
Helper::getTemporaryTableSubQuerySql($selectSql, $columnName)
Mesh::createLink($id, $parentId, $behaviour = array('LINK_DATA' => array()))
Mesh::moveLink($id, $parentId, $behaviour = array('CREATE_PARENT_NODE_ON_NOTFOUND' => true))
Mesh::deleteLink($id, $parentId = false, array $behaviour = array('CHILDREN' => 'unlink'))
Mesh::throwExceptionCantAddEdge($from, $to, $direct, $type = '')
Mesh::checkItemLinked($id)
Mesh::applyDeleteRestrictions(&$id, &$parentId)
Mesh::getParents($id)
Mesh::getChildren($id)
Mesh::insertEdge($from, $to, $direct = true, $increment = 0, array $behaviour = array('INCREMENT_MP_WHEN_EXISTS' => true))
Mesh::markEdgeToRemove($from, $to, $decrement = 0)
Mesh::deleteMarkedEdges()
Mesh::applyCreateRestrictions(&$id, &$parentId)
Mesh::getMPCITYColumnName()
Mesh::getMap()
LazyAccess::generateMap(array $parameters = array())
LazyAccess::getMap()
LazyAccess::resetMapCache()
LazyAccess::fetchFieldValue($k)
LazyAccess::getCachedFields()
LazyAccess::offsetGet($offset)
LazyAccess::getIterator()
LazyAccess::__call($name, array $arguments)
LazyAccess::__get($name)
LazyAccess::__set($name, $value)
DependenceTable::setTableName($tableName)
DependenceTable::getClass()
ViewedTable::getTableName()
ViewedTable::getClass()
ViewedTable::getMap()
ReminderTable::getTableName()
ReminderTable::getClass()
ReminderTable::getMap()
MemberTable::getTableName()
MemberTable::getClass()
MemberTable::getMap()
MemberTable::validateType()
TemplateTable::getUfId()
TemplateTable::getTableName()
TemplateTable::getClass()
TemplateTable::getMap()
TemplateTable::validateTitle()
TemplateTable::validatePriority()
TemplateTable::validateStatus()
TemplateTable::validateXmlId()
TemplateTable::validateSiteId()
FavoriteTable::getTableName()
FavoriteTable::getClass()
FavoriteTable::check($primary)
FavoriteTable::toggle($primary, $behaviour = array())
FavoriteTable::add(array $data)
FavoriteTable::delete($primary, $behaviour = array('AFFECT_CHILDREN' => false))
FavoriteTable::deleteByTaskId($taskId, $behaviour = array('LOW_LEVEL' => false))
FavoriteTable::processPrimary($primary)
FavoriteTable::getMap()
LogTable::getTableName()
LogTable::getClass()
LogTable::getMap()
LogTable::validateField()
ElapsedTimeTable::getTableName()
ElapsedTimeTable::getClass()
ElapsedTimeTable::getMap()
ProjectDependenceTable::getTableName()
ProjectDependenceTable::getIDColumnName()
ProjectDependenceTable::getPARENTIDColumnName()
ProjectDependenceTable::getClass()
ProjectDependenceTable::allowMultipleParents()
ProjectDependenceTable::getLinkCountForUser($userId = 0)
ProjectDependenceTable::createLink($id, $parentId, $behaviour = array())
ProjectDependenceTable::applyCreateRestrictions(&$id, &$parentId)
ProjectDependenceTable::checkLinkExists($id, $parentId, array $parameters = array('BIDIRECTIONAL' => false))
ProjectDependenceTable::applyDeleteRestrictions(&$id, &$parentId)
ProjectDependenceTable::getListByLegacyTaskFilter(array $filter = array(), array $parameters = array())
ProjectDependenceTable::getSubTreeSql($id)
ProjectDependenceTable::getMap()
ProjectDependenceTable::validateType()
ProjectDependenceTable::moveLink($id, $parentId, $behaviour = array('CREATE_PARENT_NODE_ON_NOTFOUND' => true))
ProjectDependenceTable::link($id, $parentId)
ProjectDependenceTable::unlink($id)
CheckListTable::getTableName()
CheckListTable::getClass()
CheckListTable::getMap()
CheckListTable::validateTitle()
ParameterTable::getTableName()
ParameterTable::getClass()
ParameterTable::getMap()
ParameterTable::validateValue()
TimerTable::getTableName()
TimerTable::getClass()
TimerTable::getMap()
AccessTable::getTableName()
AccessTable::getClass()
AccessTable::getMap()
AccessTable::validateGroupCode()
CheckListTable::add(array $data)
CheckListTable::getListByTemplateDependency($templateId, $parameters)
CheckListTable::updateForTemplate($templateId, $items = array())
CheckListTable::moveAfterItem($templateId, $selectedItemId, $insertAfterItemId)
CheckListTable::deleteByTemplateId($templateId)
SystemLogTable::getTableName()
SystemLogTable::getMap()
TagTable::getTableName()
TagTable::getClass()
TagTable::getMap()
TagTable::validateName()
SortingTable::getTableName()
SortingTable::getClass()
SortingTable::getMap()
SortingTable::insertBatch(array $items)
SortingTable::deleteByTaskId($taskId)
SortingTable::setSorting($userId, $groupId, $sourceId, $targetId, $before)
SortingTable::setTargetSorting($userId, $groupId, $sourceId, $targetId)
SortingTable::getTask($taskId, $userId, $groupId)
SortingTable::moveTaskToTarget($userId, $groupId, $sourceId, $targetId, $before)
SortingTable::fixSiblings($sourceTask)
SortingTable::getSortedItems(\CDBResult $result, $userId, $groupId, $prevTaskSort, $prevTaskId, $sourceId, $targetId)
SortingTable::getMaxSort($userId, $groupId)
RelatedTable::getTableName()
RelatedTable::getClass()
RelatedTable::getMap()
Template::getAccessCheck(array $parameters)
Template::getAccessCheckSql(array $parameters)
Template::getOperationCondition(array $parameters)
Favorite::getFlag(array $parameters)
Parameter::getParameter(array $parameters)
Task::getTask(array $parameters)
Task::getLegacyFilter(array $parameters)
Task::getAccessCheck(array $parameters)
Task::getAccessCheckSql(array $parameters)
Task::getAccessibleTaskIdsSql(array $parameters)
Task::getExpirationFlag(array $parameters)
Task::getLegacyRightsChecker(array $parameters)
Task::getMemberConditions($filter, $parameters)
Task::getForwardedFilter($filter, $parameters)
Task::getForwardedFields()
Task::getAllowedGroups(&$parameters)
Task::isDirector(&$parameters)
TaskTable::getUfId()
TaskTable::getTableName()
TaskTable::getClass()
TaskTable::validateTitle()
TaskTable::validateGuid()
TaskTable::validateXmlId()
TaskTable::validateExchangeId()
TaskTable::validateExchangeModified()
TaskTable::validateSiteId()
SystemLogTable::getClass()
SystemLogTable::validateMessage()
Reminder::getIsMultiple()
Reminder::getListByParentEntity($userId, $taskId, array $parameters = array())
Reminder::manageSet($userId, $taskId, array $items = array(), array $parameters = array('PUBLIC_MODE' => false, 'MODE' => self::MODE_ADD))
Member::getLegacyFieldName()
Member::adaptSet(array &$data)
Member::formatSet(array &$data)
Member::extendData(array &$data, array $knownMembers = array())
Member::inviteMembers(array &$data, Collection $errors)
Member::inviteUser($user, Collection $errors)
Member::addNetworkUser($user, Collection $errors)
Template::getList($userId, array $parameters = array())
Template::adaptSet(&$data)
Template::manageTaskReplication($userId, $taskId, array $taskData = array(), array $parameters = array('PUBLIC_MODE' => false, 'MODE' => self::MODE_ADD))
Template::addTemplateByTask($userId, $taskId, $data)
Template::getByParentTask($userId, $taskId)
Template::filterData(array $data, array $fieldMap, Collection $errors)
Template::formatSetResponsible(array $responsibles)
Template::getDeadLine($deadlineAfter)
Template::getTemplate($id)
Accomplice::getLegacyFieldName()
Accomplice::getIsMultiple()
Project::getLegacyFieldName()
Project::adaptSet(array &$data)
Project::formatSet(array &$data)
Project::extendData(array &$data, array $knownTasks = array())
ParentTask::getLegacyFieldName()
ParentTask::adaptSet(array &$data)
ParentTask::formatSet(array &$data)
ParentTask::extendData(array &$data, array $knownTasks = array())
Originator::getLegacyFieldName()
Log::getIsMultiple()
Log::getListByParentEntity($userId, $taskId, array $parameters = array())
RelatedTask::getIsMultiple()
RelatedTask::getLegacyFieldName()
RelatedTask::getListByParentEntity($userId, $taskId, array $parameters = array())
RelatedTask::formatSet(array &$data)
RelatedTask::adaptSet(array &$data)
RelatedTask::extendData(array &$data, array $knownTasks = array())
ElapsedTime::getIsMultiple()
ElapsedTime::getListByParentEntity($userId, $taskId, array $parameters = array())
ElapsedTime::get($userId, $taskId, $itemId, array $parameters = array())
ElapsedTime::getTaskId($itemId)
ProjectDependence::getIsMultiple()
ProjectDependence::getListByParentEntity($userId, $taskId, array $parameters = array())
ProjectDependence::manageSet($userId, $taskId, array $items = array(), array $parameters = array('PUBLIC_MODE' => false, 'MODE' => self::MODE_ADD))
ProjectDependence::extendData(array &$data, array $knownTasks = array())
ProjectDependence::getFieldMap()
ProjectDependence::extractPrimaryIndex(array $data)
CheckList::getIsMultiple()
CheckList::getListByParentEntity($userId, $templateId, array $parameters = array())
CheckList::manageSet($userId, $templateId, array $items = array(), array $parameters = array('PUBLIC_MODE' => false, 'MODE' => self::MODE_ADD))
CheckList::mergeData($primary = array(), $secondary = array())
CheckList::parseSet(&$data)
CheckList::reArrangeBySortIndex(array $items)
CheckList::ensureCanToggle(array $toToggleItems, array $currentItems, Collection $errors)
CheckList::makeToggleSet(array $items, array $currentItemsData)
CheckList::getFullRights()
Parameter::manageSet($userId, $taskId, array $items = array(), array $parameters = array('PUBLIC_MODE' => false, 'MODE' => self::MODE_ADD))
Parameter::mergeData($primary = array(), $secondary = array())
Tag::getIsMultiple()
Tag::getLegacyFieldName()
Tag::getList($userId, $taskId, array $parameters = array())
Tag::formatSet(array &$data)
Tag::adaptSet(array &$data)
Responsible::getLegacyFieldName()
Responsible::getIsMultiple()
Responsible::adaptSet(array &$data)
Auditor::getLegacyFieldName()
Auditor::getIsMultiple()
Task::getFieldMap()
Task::doAdd($userId, array $data, array $parameters)
Task::normalizeData($data)
Task::inviteMembers(&$data, Collection $errors)
Task::adaptSet(&$data)
Task::ensureDatePlanChangeAllowed($userId, array &$data)
Task::setDefaultUFValues($userId, array &$data)
Task::replaceKey(array &$data, $from, $to, $dropFrom = true)
Task::doUpdate($userId, $taskId, array $data, array $parameters)
Task::convertFromItem($item)
Task::makeItem($data, $userId = 0)
Task::getBasicData($userId, $taskId, array $parameters)
Task::getFullRights($userId)
Task::injectDayPlanFields($userId, array $parameters, array &$data, array &$can)
Task::prepareNav($limit = false, $offset = false, $public = false)
Task::extendData(&$data, array $references = array())
Task::mergeData($primary = array(), $secondary = array())
Task::prepareSearchIndex(array $arTask, array $arFields = array())
Task::getLegalSubEntities()
TaskStageTable::getTableName()
TaskStageTable::getMap()
TaskStageTable::setStageByFilter($id, array $filter)
TaskStageTable::clearStage($id)
TaskStageTable::clearTask($id)
StagesTable::getTableName()
StagesTable::getMap()
StagesTable::checkWorkMode($mode)
StagesTable::setWorkMode($mode)
StagesTable::getWorkMode()
StagesTable::delete($key, $entityId = 0)
StagesTable::getStages($entityId = 0, $disableCreate = false)
StagesTable::updateByCode($id, $fields)
StagesTable::getStageIdByCode($id, $entityId = 0)
StagesTable::getDefaultStageId($id = 0)
StagesTable::getStagesCount(array $filter = array(), $userId = false)
StagesTable::copyView($fromEntityId, $toEntityId, $entityType = self::WORK_MODE_GROUP)
StagesTable::disablePinForUser($userIds)
StagesTable::disableLinkForUser($userIds)
StagesTable::pinInStage($taskId, $users = array(), $refreshGroup = false)
StagesTable::pinInTheStage($taskId, $stageId)
StagesTable::onSocNetGroupDelete($groupId)
StagesTable::onUserDelete($userId)
StagesTable::onDelete(Entity\Event $event)
Util::trim($arg)
Util::escape($arg)
Util::hashCode($str)
Util::secureBackUrl($url)
Util::replaceUrlParameters($url, array $paramsToAdd = array(), array $paramsToDelete = array(), array $options = array())
Util::getParser(array $parameters = array())
Util::generateUUID($brackets = true)
Util::getServerTimeZoneOffset()
Util::log($info)
Util::setOption($name, $value)
Util::getOption($name)
Util::unSetOption($name)
Util::printDebug($data)
Exception::dumpAuxError()
Exception::getErrors()
Exception::prepareMessage($message)
Exception::getMessageOrigin()
Exception::getMessageLang()
Exception::getMessageFriendly()
Exception::getSymbolicCode()
ActionException::__construct($message = false, array $data = array(), array $additional = array())
AccessDeniedException::getDefaultMessage()
ActionNotAllowedException::getDefaultMessage()
ActionFailedException::getDefaultMessage()
ActionRestrictedException::getDefaultMessage()
tasks::tasks()
tasks::InstallDB($arParams = array())
tasks::UnInstallDB($arParams = array())
tasks::InstallUserFields($moduleId = 'all')
tasks::installDiskUserFields()
tasks::createFileField($entity, array &$errors)
tasks::deleteFileField($entity)
tasks::InstallEvents()
tasks::UnInstallEvents()
tasks::InstallFiles($arParams = array())
tasks::UnInstallFiles()
tasks::getModuleTasks()
tasks::DoInstall()
tasks::DoUninstall()