tasks

Module Events tasks

EventsCalled
OnAfterCommentComment :: fireEvent
OnAfterCommentAddCTaskComments :: fireOnAfterCommentAddEvent
OnBaseAllowedActionsMapInitCTaskItem :: getBaseAllowedActions
OnBeforeTaskAddCTasks :: Add
OnBeforeTaskDeleteCTasks :: Delete
OnBeforeTaskElapsedTimeAddCTaskElapsedTime :: Add
OnBeforeTaskElapsedTimeDeleteCTaskElapsedTime :: Delete
OnBeforeTaskElapsedTimeUpdateCTaskElapsedTime :: Update
OnBeforeTaskNotificationSendCTaskNotifications :: fireMessageEvent
OnBeforeTaskTemplateDeleteCTaskTemplates :: Delete
OnBeforeTaskUpdate
OnBeforeTaskZombieDeleteCTasks :: terminateZombie
OnTaskAddCTasks :: Add
OnTaskDeleteCTasks :: Delete
OnTaskElapsedTimeAddCTaskElapsedTime :: Add
OnTaskElapsedTimeDeleteCTaskElapsedTime :: Delete
OnTaskElapsedTimeUpdateCTaskElapsedTime :: Update
OnTaskReminderAddCTaskReminders :: Add
OnTaskTemplateDeleteCTaskTemplates :: Delete
OnTaskToggleFavoriteCTaskItem :: proceedAction
OnTaskUpdate
OnTaskZombieDeleteCTasks :: terminateZombie

Constant module tasks

ConstantChecked
BX_COMP_MANAGED_CACHESocialNetwork :: getLogDestination
FORMAT_DATEUI :: formatDateTime
FORMAT_DATETIMEUI :: getDateTimeFormat
LANGUAGE_IDCTasksTools :: getPluralForm
SITE_SERVER_NAMEtasksServerName

List of module methods tasks

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