| Метод |
| FixedArray::__construct($size) |
| FixedArray::fromArray($items) |
| FixedArray::getSize() |
| FixedArray::setSize($size) |
| FixedArray::toArray() |
| FixedArray::__wakeup() |
| FixedArray::getSplFixedArray() |
| FixedArray::reverse() |
| FixedArray::push($data) |
| FixedArray::getCountOfPushedElements() |
| FixedArray::current() |
| FixedArray::next() |
| FixedArray::key() |
| FixedArray::valid() |
| FixedArray::rewind() |
| FixedArray::offsetExists($offset) |
| FixedArray::offsetGet($offset) |
| FixedArray::offsetSet($offset, $value) |
| FixedArray::offsetUnset($offset) |
| FixedArray::count() |
| CustomHeap::__construct($comparator) |
| CustomHeap::compare($element1, $element2) |
| CustomHeap::toArray() |
| ReverseIterator::__construct(FixedArray $fixedArray) |
| ReverseIterator::current() |
| ReverseIterator::key() |
| ReverseIterator::next() |
| ReverseIterator::rewind() |
| ReverseIterator::valid() |
| DeletedLogManager::__construct() |
| DeletedLogManager::registerShutdownFunction() |
| DeletedLogManager::getLogTable() |
| DeletedLogManager::isMigrated() |
| DeletedLogManager::getEntries(array $parameters) |
| DeletedLogManager::finalize() |
| DeletedLogManager::mark(BaseObject $object, $deletedBy) |
| DeletedLogManager::markAfterMove(BaseObject $object, array $subscribersLostAccess, $updatedBy) |
| DeletedLogManager::insertLogData() |
| DeletedLogManager::cleanCache() |
| DeletedLogManager::notifyUsers() |
| Healer::className() |
| Healer::restartSetupSession() |
| Healer::markBadSetupSession() |
| SetupSession::getTableClassName() |
| SetupSession::register($objectId, $createdBy = null) |
| SetupSession::forkAndRestart() |
| SetupSession::bindParent(SetupSession $session) |
| SetupSession::closeDuplicates($objectId) |
| SetupSession::setAsDuplicate() |
| SetupSession::finish() |
| SetupSession::delete() |
| SetupSession::getObjectId() |
| SetupSession::getStatus() |
| SetupSession::getParentId() |
| SetupSession::isFinished() |
| SetupSession::isForked() |
| SetupSession::getCreateTime() |
| SetupSession::getCreatedBy() |
| SetupSession::setObject(BaseObject $object) |
| SetupSession::getMapAttributes() |
| SetupSession::getMapReferenceAttributes() |
| TmpSimpleRight::getTableName() |
| TmpSimpleRight::insertBatchBySessionId(array $items, $sessionId) |
| TmpSimpleRight::fillDescendants($objectId, $sessionId) |
| TmpSimpleRight::moveToOriginalSimpleRights($sessionId) |
| TmpSimpleRight::deleteBySessionId($sessionId) |
| RightSetupSessionTable::getTableName() |
| RightSetupSessionTable::getMap() |
| RightSetupSessionTable::markAsBad() |
| ObjectTable::add(array $data) |
| ObjectTable::getTableName() |
| ObjectTable::getMap() |
| ObjectTable::getListOfTypeValues() |
| ObjectTable::getListOfDeletedTypes() |
| ObjectTable::validateName() |
| ObjectTable::validateCode() |
| ObjectTable::validateXmlId() |
| ObjectTable::validateExternalHash() |
| ObjectTable::validateEtag() |
| ObjectTable::validateContentProvider() |
| ObjectTable::checkFields(Result $result, $primary, array $data) |
| ObjectTable::onAfterAdd(Entity\Event $event) |
| ObjectTable::onBeforeUpdate(Entity\Event $event) |
| ObjectTable::delete($primary) |
| ObjectTable::move($primary, $newParentId) |
| ObjectTable::updateSyncTime($objectId, DateTime $dateTime) |
| ObjectTable::updateAttributesByFilter(array $attributes, array $filter) |
| ObjectTable::getDescendants($objectId, $parameters = array()) |
| ObjectTable::getAncestors($objectId, $parameters = array()) |
| ObjectTable::getChildren($objectId, $parameters = array()) |
| ObjectTable::getParents($objectId, $parameters = array()) |
| DeletedLogTable::getTableName() |
| DeletedLogTable::getMap() |
| DeletedLogTable::insertBatch(array $items) |
| DeletedLogTable::deleteOldEntries() |
| BaseComponent::__construct($component = null) |
| BaseComponent::restartBuffer() |
| BaseComponent::sendResponse($response) |
| BaseComponent::sendJsonResponse($response) |
| BaseComponent::sendJsonErrorResponse() |
| BaseComponent::sendJsonSuccessResponse(array $response = array()) |
| BaseComponent::sendJsonAccessDeniedResponse($message = '') |
| BaseComponent::showAccessDenied() |
| BaseComponent::end($terminate = true) |
| BaseComponent::encodeUrn($urn) |
| BaseComponent::hasErrors() |
| BaseComponent::getErrors() |
| BaseComponent::getErrorByCode($code) |
| BaseComponent::getComponentId() |
| BaseComponent::wrapAsSidepanelContent() |
| BaseComponent::isWrappedAsSidepanelContent() |
| BaseComponent::executeComponent() |
| BaseComponent::getUrlManager() |
| BaseComponent::setProcessToDefaultAction() |
| BaseComponent::resolveAction() |
| BaseComponent::normalizeListOfAction(array $listOfActions) |
| BaseComponent::normalizeActionDescription($action, $description) |
| BaseComponent::listActions() |
| BaseComponent::checkRequiredModules() |
| BaseComponent::prepareParams() |
| BaseComponent::runAction() |
| BaseComponent::getAction() |
| BaseComponent::getActionDescription() |
| BaseComponent::setAction($action, array $description) |
| BaseComponent::checkRequiredInputParams(array $inputParams, array $required) |
| BaseComponent::checkRequiredPostParams(array $required) |
| BaseComponent::checkRequiredGetParams(array $required) |
| BaseComponent::checkRequiredFilesParams(array $required) |
| BaseComponent::processBeforeAction($actionName) |
| BaseComponent::runProcessingExceptionComponent(Exception $e) |
| BaseComponent::isAjaxRequest() |
| BaseComponent::checkAction() |
| BaseComponent::getApplication() |
| BaseComponent::getUser() |
| StorageTable::getTableName() |
| StorageTable::getMap() |
| StorageTable::validateCode() |
| StorageTable::validateXmlId() |
| StorageTable::validateName() |
| StorageTable::validateModule() |
| StorageTable::validateEntityType() |
| StorageTable::validateEntityId() |
| StorageTable::validateSiteId() |
| DiskComponent::checkRequiredModules() |
| DiskComponent::prepareParams() |
| DiskComponent::loadCurrentUserModel() |
| DiskComponent::initializeStorage() |
| DiskComponent::processBeforeAction($actionName) |
| EditSessionTable::getTableName() |
| EditSessionTable::getMap() |
| EditSessionTable::validateService() |
| EditSessionTable::validateServiceFileId() |
| RecentlyUsedTable::getTableName() |
| RecentlyUsedTable::getMap() |
| RecentlyUsedTable::deleteBatch(array $filter) |
| RecentlyUsedTable::insertBatch(array $items) |
| RecentlyUsedTable::deleteOldObjects($userId) |
| VolumeTable::getTableName() |
| VolumeTable::getMap() |
| VolumeTable::onStorageDelete($storageId, $deletedBy = \Bitrix\Disk\SystemUser::SYSTEM_USER_ID) |
| VolumeTable::onUserDelete($userId) |
| VolumeTable::deleteBatch(array $filter) |
| VolumeTable::purify() |
| VolumeTable::dropTemporally() |
| VolumeTable::createTemporally() |
| VolumeTable::checkTemporally() |
| VolumeTable::clearTemporally() |
| RightTable::getTableName() |
| RightTable::getMap() |
| RightTable::validateAccessCode() |
| RightTable::validateDomain() |
| RightTable::insertBatch(array $items) |
| RightTable::deleteBatch(array $filter) |
| Event::send($sender = null) |
| ErrorCollection::addOne(Error $error) |
| ErrorCollection::addFromResult(Result $result) |
| ErrorCollection::addFromEntity(IErrorable $entity) |
| ErrorCollection::hasErrors() |
| ErrorCollection::getErrorsByCode($code) |
| Error::getData() |
| CloudImportTable::getTableName() |
| CloudImportTable::getMap() |
| CloudImportTable::validateService() |
| CloudImportTable::validateContentUrl() |
| CloudImportTable::validateMimeType() |
| CloudImportTable::validateEtag() |
| Model::__construct(array $attributes = array()) |
| Model::init() |
| Model::setAttributes(array $attributes, array &$aliases = null) |
| Model::setSubEntityToModel($entityName, array $modelMapAttributes, $className, $subEntity, $aliasesData) |
| Model::getId() |
| Model::getPrimary() |
| Model::getMapAttributes() |
| Model::getMapReferenceAttributes() |
| Model::buildFromRow(array $row, array $with = null) |
| Model::buildFromArray(array $attributes, array &$aliases = null) |
| Model::className() |
| Model::add(array $data, ErrorCollection $errorCollection) |
| Model::getTableClassName() |
| Model::buildFromResult(Result $result) |
| Model::setAttributesFromResult(Result $result) |
| Model::getById($id, array $with = array()) |
| Model::loadById($id, array $with = array()) |
| Model::load(array $filter, array $with = array()) |
| Model::getModelList(array $parameters) |
| Model::getList(array $parameters) |
| Model::prepareGetListParameters(array $parameters) |
| Model::buildOrmSelectForReference(array $with) |
| Model::getReferenceConf($refName) |
| Model::getAliasForRef($ref, $prevConcreteRefModelAlias = '', $prevConcreteRefOrmAlias = '') |
| Model::getExtra() |
| Model::setExtraAttributes(array $attributes) |
| Model::checkRequiredInputParams(array $inputParams, array $required) |
| Model::toArray(array $with = array()) |
| Model::getErrors() |
| Model::getErrorsByCode($code) |
| Model::getErrorByCode($code) |
| Model::update(array $data) |
| Model::deleteInternal() |
| Model::isLoadedAttribute($name) |
| Model::setAsLoadedAttribute($name) |
| Model::offsetExists($offset) |
| Model::offsetGet($offset) |
| Model::offsetSet($offset, $value) |
| Model::offsetUnset($offset) |
| Model::isValidValueForField($fieldName, $value, ErrorCollection $errorCollection = null) |
| Query::getWhere() |
| Model::__call($name, $arguments) |
| Model::setReferenceValue($referenceName, $value) |
| FieldManager::__construct() |
| FieldManager::__clone() |
| FieldManager::getMapFieldsByModel(Internals\Model $model) |
| FieldManager::getReferenceFieldsByModel(Internals\Model $model) |
| FieldManager::getReferenceFields($modelClassName) |
| FieldManager::getReferenceFieldByName($modelClassName, $name) |
| FieldManager::resolveClassName($model) |
| FieldManager::normalizeReferenceFields(array $fields) |
| FieldManager::camel2snake($str) |
| FieldManager::snake2camel($str) |
| FieldManager::getInstance() |
| FieldManager::getErrors() |
| FieldManager::getErrorsByCode($code) |
| FieldManager::getErrorByCode($code) |
| ModelSynchronizer::__construct() |
| ModelSynchronizer::__clone() |
| ModelSynchronizer::getInstance() |
| ModelSynchronizer::generateEventName(BaseObject $link) |
| ModelSynchronizer::subscribeOnRealObject(BaseObject $link) |
| ModelSynchronizer::unsubscribe(BaseObject $link) |
| ModelSynchronizer::trigger(BaseObject $baseObject, array $attributes) |
| ModelSynchronizer::className() |
| ObjectPathTable::getTableName() |
| ObjectPathTable::getMap() |
| ObjectPathTable::addAsRoot($objectId) |
| ObjectPathTable::appendTo($objectId, $appendToNodeId) |
| ObjectPathTable::moveTo($objectId, $toNodeId) |
| ObjectPathTable::getDescendants($objectId, $orderDepthLevel = SORT_ASC) |
| ObjectPathTable::getChildren($objectId) |
| ObjectPathTable::getAncestors($objectId, $orderDepthLevel = SORT_ASC) |
| ObjectPathTable::deleteByObject($objectId) |
| ObjectPathTable::isLeaf($objectId) |
| ObjectPathTable::recalculate() |
| ObjectPathTable::recalculateByStorage($storageId) |
| ModelBuilder::__construct(Traversable $iterator, $classNameModel) |
| ModelBuilder::current() |
| ObjectTtlTable::getTableName() |
| ObjectTtlTable::getMap() |
| FolderTable::getMap() |
| FolderTable::checkFields(Result $result, $primary, array $data) |
| FolderTable::add(array $data) |
| FolderTable::validateTypeLogic($value) |
| FolderTable::validateType() |
| Controller::__construct() |
| Controller::init() |
| Controller::end() |
| Controller::exec() |
| Controller::triggerOnBeforeAction($action) |
| Controller::collectDebugInfo() |
| Controller::logDebugInfo() |
| Controller::getUser() |
| Controller::sendJsonResponse($response, $params = null) |
| Controller::sendJsonErrorResponse(array $response = array()) |
| Controller::sendJsonAccessDeniedResponse($message = '') |
| Controller::sendJsonInvalidSignResponse($message = '') |
| Controller::sendJsonSuccessResponse(array $response = array()) |
| Controller::restartBuffer() |
| Controller::sendResponse($response) |
| Controller::getErrors() |
| Controller::getErrorsByCode($code) |
| Controller::getErrorByCode($code) |
| Controller::resolveAction() |
| Controller::sanitizeActionName($actionName) |
| Controller::normalizeListOfAction(array $listOfActions) |
| Controller::normalizeActionDescription($action, $description) |
| Controller::checkAction() |
| Controller::listActions() |
| Controller::getAction() |
| Controller::getActionDescription() |
| Controller::setAction($action, array $description) |
| Controller::setActionName($action) |
| Controller::checkRequiredModules() |
| Controller::prepareParams() |
| Controller::processBeforeAction($actionName) |
| Controller::runAction() |
| Controller::runProcessingException(\Exception $e) |
| Controller::runProcessingIfUserNotAuthorized() |
| Controller::redirectToAuth($backUrl = null) |
| Controller::runProcessingIfInvalidCsrfToken() |
| Controller::getApplication() |
| Controller::checkRequiredInputParams(array $inputParams, array $required) |
| Controller::checkRequiredPostParams(array $required) |
| Controller::checkRequiredGetParams(array $required) |
| Controller::checkRequiredFilesParams(array $required) |
| Controller::isAjaxRequest() |
| Controller::resizeImage($fileData, $objectId) |
| AttachedObjectTable::getTableName() |
| AttachedObjectTable::getMap() |
| AttachedObjectTable::validateModule() |
| AttachedObjectTable::validateEntityType() |
| AttachedObjectTable::updateBatch(array $fields, array $filter) |
| DataManager::className() |
| DataManager::query() |
| DataManager::mergeData(array $insert, array $update) |
| DataManager::deleteByFilter(array $filter) |
| DataManager::insertBatch(array $items) |
| DataManager::deleteBatch(array $filter) |
| DataManager::updateBatch(array $fields, array $filter) |
| ObjectSaveIndexTable::getMap() |
| ObjectLockTable::getTableName() |
| ObjectLockTable::getMap() |
| ObjectLockTable::getListOfTypeValues() |
| ObjectLockTable::validateToken() |
| ExternalLinkTable::getTableName() |
| ExternalLinkTable::getMap() |
| ExternalLinkTable::validateHash() |
| ExternalLinkTable::validatePassword() |
| ExternalLinkTable::validateSalt() |
| ExternalLinkTable::getListOfTypeValues() |
| DeletedLogV2Table::getTableName() |
| DeletedLogV2Table::getMap() |
| DeletedLogV2Table::insertBatch(array $items) |
| DeletedLogV2Table::upsertBatch(array $items) |
| DeletedLogV2Table::deleteOldEntries() |
| FileTable::getMap() |
| FileTable::validateName() |
| FileTable::add(array $data) |
| FileTable::validateTypeLogic($value) |
| FileTable::validateType() |
| FileTable::checkFields(Result $result, $primary, array $data) |
| FileTable::changeStorageId($primary, $newStorageId) |
| TmpFileTable::getTableName() |
| TmpFileTable::getMap() |
| TmpFileTable::validateToken() |
| TmpFileTable::validateFilename() |
| TmpFileTable::validateContentType() |
| TmpFileTable::validatePath() |
| SqlHelper::insertBatch($tableName, array $items) |
| SqlHelper::upsertBatch($tableName, array $items, array $updateFields) |
| ShowSessionTable::getTableName() |
| ShowSessionTable::getMap() |
| ShowSessionTable::validateService() |
| ShowSessionTable::validateServiceFileId() |
| ShowSessionTable::validateEtag() |
| SimpleRightTable::getTableName() |
| SimpleRightTable::getMap() |
| SimpleRightTable::validateAccessCode() |
| SimpleRightTable::insertBatch(array $items) |
| SimpleRightTable::deleteBatch(array $filter) |
| SimpleRightTable::fillDescendants($objectId) |
| SimpleRightTable::deleteSimpleFromSelfAndChildren($objectId, $objectType) |
| Cleaner::className() |
| Cleaner::deleteShowSession($type = self::DELETE_TYPE_PORTION, $limit = 10) |
| Cleaner::deleteUnnecessaryFiles($type = self::DELETE_TYPE_PORTION, $limit = 10) |
| Cleaner::deleteByTtl($type = self::DELETE_TYPE_PORTION, $limit = 10) |
| Cleaner::deleteRightSetupSession() |
| Cleaner::emptyOldDeletedLogEntries() |
| Cleaner::restoreMissingRootFolder() |
| Cleaner::deleteUnregisteredVersionFiles($limit = 100, $fromDate = '', $timeLimit = 20) |
| FolderListOptions::__construct(Disk\Storage $storage) |
| FolderListOptions::getGridId() |
| FolderListOptions::extractStorageId($gridId) |
| FolderListOptions::getPossibleColumnForSorting() |
| FolderListOptions::getDefaultSorting() |
| FolderListOptions::getSortingColumns() |
| FolderListOptions::getVisibleColumns() |
| FolderListOptions::getDefaultColumns() |
| FolderListOptions::getOrderForOrm() |
| FolderListOptions::getGridOptionsSorting() |
| FolderListOptions::getViewMode() |
| FolderListOptions::getViewSize() |
| FolderListOptions::getSortMode() |
| FolderListOptions::isMixSortMode() |
| FolderListOptions::getGridSpecificOptions() |
| FolderListOptions::storeViewMode($mode) |
| FolderListOptions::storeSortMode($mode) |
| FolderListOptions::storeViewSize($size) |
| FolderListOptions::getPageSize() |
| FolderListOptions::getNavigation() |
| FolderListOptions::getGridOptions() |
| TrashCanOptions::getGridId() |
| TrashCanOptions::getDefaultSorting() |
| TrashCanOptions::getDefaultColumns() |
| TrashCanOptions::getPossibleColumnForSorting() |
| TrashCanOptions::isMixSortMode() |
| SharingTable::checkFields(Result $result, $primary, array $data) |
| SharingTable::getTableName() |
| SharingTable::getMap() |
| SharingTable::getListOfStatusValues() |
| SharingTable::getListOfTypeValues() |
| SharingTable::updateBatch(array $fields, array $filter) |
| VolumeDeletedLogTable::getTableName() |
| VolumeDeletedLogTable::getMap() |
| DeletedLogMover::getStatus() |
| DeletedLogMover::pauseExecution() |
| DeletedLogMover::stopExecution() |
| DeletedLogMover::continueExecution() |
| DeletedLogMover::continueExecutionWithoutAgent($portion = self::PORTION) |
| DeletedLogMover::setPortionSize($portionSize) |
| DeletedLogMover::execute(array &$result) |
| DeletedLogMover::loadCurrentStatus() |
| HumanReadableError::onAfterAction(Event $event) |
| CheckArchiveSignature::__construct(N/A) |
| CheckArchiveSignature::onBeforeAction(Event $event) |
| CheckImageSignature::__construct(N/A) |
| CheckImageSignature::onBeforeAction(Event $event) |
| CheckImageSignature::getFileIdFromActionArguments() |
| CheckReadPermission::__construct() |
| CheckReadPermission::onBeforeAction(Event $event) |
| CheckReadPermission::checkObject(BaseObject $object) |
| CheckReadPermission::addReadError() |
| Controller::processAfterAction(Engine\Action $action, $result) |
| Binder::registerDefaultAutoWirings() |
| VersionTable::getTableName() |
| VersionTable::getMap() |
| VersionTable::validateName() |
| Diag::__construct() |
| Diag::getInstance() |
| Diag::setSqlBehavior($sqlBehavior) |
| Diag::setMemoryBehavior($memoryBehavior) |
| Diag::setEnableTimeTracker($enableTimeTracker) |
| Diag::setEnableErrorHandler($enableErrorHandler) |
| Diag::setFilePathPatternToCatchError($filePathPatternToCatchError) |
| Diag::setShowOnDisplay($showOnDisplay) |
| Diag::setExclusiveUserId($exclusiveUserId) |
| Diag::collectDebugInfo($uniqueId, $label = null) |
| Diag::getDebugInfoSql() |
| Diag::logDebugInfo($uniqueId, $label = null) |
| Diag::log($data) |
| Diag::reformatBackTrace(array $backtrace) |
| Diag::getLinkToEditor($filepath, $line = 0) |
| Diag::formatSize($size, $precision = 2) |
| Diag::getUser() |
| Diag::registerShutdownFunction() |
| CableValidator::__construct($validateCallback, $errorPhrase = null) |
| CableValidator::validate($value, $primary, array $row, Entity\Field $field) |
| FileLink::setAttributes(array $attributes, array &$aliases = null) |
| FileLink::canChangeRights(SecurityContext $securityContext) |
| FileLink::canRead(SecurityContext $securityContext) |
| FileLink::canShare(SecurityContext $securityContext) |
| FileLink::canUpdate(SecurityContext $securityContext) |
| FileLink::canStartBizProc(SecurityContext $securityContext) |
| FileLink::canLock(SecurityContext $securityContext) |
| FileLink::canUnlock(SecurityContext $securityContext) |
| FileLink::add(array $data, ErrorCollection $errorCollection) |
| FileLink::getErrors() |
| FileLink::getErrorsByCode($code) |
| FileLink::getErrorByCode($code) |
| FileLink::getRealObject() |
| FileLink::getFileId() |
| FileLink::getViewId() |
| FileLink::getPreviewId() |
| FileLink::getFile() |
| FileLink::copyTo(Folder $targetFolder, $updatedBy, $generateUniqueName = false) |
| FileLink::updateContent(array $file, $updatedBy) |
| FileLink::addVersion(array $file, $createdBy, $disableJoin = false) |
| FileLink::getVersion($versionId) |
| FileLink::getVersions(array $parameters = array()) |
| FileLink::restoreFromVersion(Version $version, $createdBy) |
| FileLink::markDeleted($deletedBy) |
| FileLink::delete($deletedBy) |
| FileLink::deleteWithoutSharing($deletedBy) |
| FileLink::deleteProcess($deletedBy, $withDeletingSharing = true) |
| FileLink::restore($restoredBy) |
| FileLink::onModelSynchronize(array $attributes) |
| FileLink::__destruct() |
| FullTextBuilder::__construct() |
| FullTextBuilder::create() |
| FullTextBuilder::addText($token) |
| FullTextBuilder::addUser($user) |
| FullTextBuilder::getSearchValue() |
| FullTextBuilder::prepareToken($token) |
| ContentManager::__construct() |
| ContentManager::getObjectContent(BaseObject $object, array $options = null) |
| ContentManager::getFolderContent(Folder $folder) |
| ContentManager::getFileContent(File $file, array $options = null) |
| ContentManager::getFileContentFromIndex(File $file) |
| BaseObjectIndex::getStatus() |
| BaseObjectIndex::pauseExecution() |
| BaseObjectIndex::stopExecution() |
| BaseObjectIndex::continueExecution() |
| BaseObjectIndex::continueExecutionWithoutAgent($portion = self::PORTION) |
| BaseObjectIndex::setPortionSize($portionSize) |
| BaseObjectIndex::className() |
| BaseObjectIndex::execute(array &$result) |
| BaseObjectIndex::loadCurrentStatus() |
| IndexManager::__construct() |
| IndexManager::disableUsingSearchModule() |
| IndexManager::saveFullText(BaseObject $object, $content) |
| IndexManager::indexFile(File $file, array $additionalData = array()) |
| IndexManager::indexFolder(Folder $folder) |
| IndexManager::changeName(BaseObject $object) |
| IndexManager::dropIndex(BaseObject $object) |
| IndexManager::recalculateRights(BaseObject $object) |
| IndexManager::onSearchGetUrl($fields) |
| IndexManager::getStoredIndex(BaseObject $object) |
| IndexManager::onSearchReindex($nextStepData = array(), $searchObject = null, $method = "") |
| IndexManager::resolveSiteId(Storage $storage) |
| IndexManager::getExtranetSiteId() |
| IndexManager::getDefaultSiteId() |
| IndexManager::processIndexContent($content) |
| IndexManager::getObjectContent(BaseObject $object, array $options = null) |
| IndexManager::getFolderContent(Folder $folder) |
| IndexManager::getFileContent(File $file, array $options = null) |
| IndexManager::getSimpleRights(BaseObject $object) |
| IndexManager::getItemId(BaseObject $object) |
| IndexManager::getObjectIdFromItemId($itemId) |
| IndexManager::getDetailUrl(BaseObject $object) |
| Storage::getTableClassName() |
| Storage::canAdd(SecurityContext $securityContext) |
| Storage::canRead(SecurityContext $securityContext) |
| Storage::canChangeSettings(SecurityContext $securityContext) |
| Storage::canChangeRights(SecurityContext $securityContext) |
| Storage::canCreateWorkflow(SecurityContext $securityContext) |
| Storage::getCode() |
| Storage::getXmlId() |
| Storage::getEntityId() |
| Storage::getEntityType() |
| Storage::getEntityMiscData() |
| Storage::getUnserializedMiscData() |
| Storage::getSerializedMiscData($entityMiscData) |
| Storage::getValueMiscData($name) |
| Storage::setValueInMiscData($name, $value) |
| Storage::enableBizProc() |
| Storage::disableBizProc() |
| Storage::isEnabledBizProc() |
| Storage::enableTransformation() |
| Storage::disableTransformation() |
| Storage::isEnabledTransformation() |
| Storage::enableShowExtendedRights() |
| Storage::disableShowExtendedRights() |
| Storage::getSizeLimit() |
| Storage::isEnabledSizeLimitRestriction() |
| Storage::setSizeLimit($bytes) |
| Storage::getSize() |
| Storage::isPossibleToUpload($fileSize) |
| Storage::isEnabledShowExtendedRights() |
| Storage::changeBaseUrl($baseUrl) |
| Storage::getModuleId() |
| Storage::getName() |
| Storage::getRootObjectId() |
| Storage::getRootObject() |
| Storage::getSiteId() |
| Storage::getUseInternalRights() |
| Storage::isUseInternalRights() |
| Storage::getFakeSecurityContext() |
| Storage::getSecurityContext($user) |
| Storage::getCurrentUserSecurityContext() |
| Storage::getFolderForCreatedFiles() |
| Storage::getFolderForSavedFiles() |
| Storage::getFolderForUploadedFiles() |
| Storage::getFolderForRecordedFiles() |
| Storage::getSpecificFolderByCode($code) |
| Storage::getProxyType() |
| Storage::rebuildProxyType() |
| Storage::initializeProxyType() |
| Storage::getChildren($id, array $filter = array(), array $order = array()) |
| Storage::getChild(array $filter, array $with = array()) |
| Storage::getDescendants(SecurityContext $securityContext, array $parameters = array(), $orderDepthLevel = SORT_ASC) |
| Storage::uploadFile($id, $fileContent, array $data, array $rights = array(), $generateUniqueName = false) |
| Storage::addBlankFile(array $data, array $rights = array(), $generateUniqueName = false) |
| Storage::addFile(array $data, array $rights = array(), $generateUniqueName = false) |
| Storage::addFileLink(File $sourceFile, array $data, array $rights = array(), $generateUniqueName = false) |
| Storage::addFolder($id, array $data, array $rights = array()) |
| Storage::addFolderLink(Folder $sourceFolder, array $data, array $rights = array(), $generateUniqueName = false) |
| Storage::add(array $data, ErrorCollection $errorCollection) |
| Storage::rename($id, $newName) |
| Storage::delete($deletedBy) |
| Storage::clearByTagCommonStorages() |
| Storage::loadById($id, array $with = array()) |
| Storage::isLoaded($id) |
| Storage::buildFromArray(array $attributes, array &$aliases = null) |
| Storage::buildFromResult(Result $result) |
| Storage::getReadableList(SecurityContext $securityContext, array $parameters = array()) |
| Storage::getMapAttributes() |
| Storage::getMapReferenceAttributes() |
| Storage::prepareGetListParameters(array $parameters) |
| EmptyUser::init() |
| EmptyUser::create() |
| EmptyUser::isIntranetUser() |
| EmptyUser::isExtranetUser() |
| EmptyUser::getLastName() |
| EmptyUser::getLogin() |
| EmptyUser::getName() |
| EmptyUser::getSecondName() |
| EmptyUser::getShortName() |
| GoogleResumableUpload::__construct(GoogleHandler $documentHandler, FileData $fileData) |
| GoogleResumableUpload::getLocationForResumableUpload() |
| GoogleResumableUpload::getNextStartRange(HttpClient $httpClient = null) |
| GoogleResumableUpload::setBearer(HttpClient $httpClient) |
| GoogleResumableUpload::fillFileDataByResponse(FileData $fileData, $response) |
| OneDriveResumableUpload::__construct(OneDriveHandler $documentHandler, FileData $fileData) |
| OneDriveResumableUpload::setUploadPath($uploadPath) |
| OneDriveResumableUpload::getPostFieldsForUpload(FileData $fileData) |
| OneDriveResumableUpload::getLocationForResumableUpload() |
| OneDriveResumableUpload::getNextStartRange(HttpClient $httpClient = null) |
| OneDriveResumableUpload::setBearer(HttpClient $httpClient) |
| OneDriveResumableUpload::fillFileDataByResponse(FileData $fileData, $response) |
| ResumableUpload::__construct(DocumentHandler $documentHandler, FileData $fileData) |
| ResumableUpload::upload() |
| ResumableUpload::getErrors() |
| ResumableUpload::getErrorsByCode($code) |
| ResumableUpload::getErrorByCode($code) |
| ResumableUpload::getLastStatus() |
| ResumableUpload::getLastResponse() |
| ResumableUpload::getFileData() |
| ResumableUpload::checkRequiredInputParams(array $inputParams, array $required) |
| ResumableUpload::convertToUtf8($data) |
| Office365ResumableUpload::getPostFieldsForUpload(FileData $fileData) |
| FileData::__construct() |
| FileData::getId() |
| FileData::setId($id) |
| FileData::getLinkInService() |
| FileData::setLinkInService($linkInService) |
| FileData::getMimeType() |
| FileData::setMimeType($mimeType) |
| FileData::getName() |
| FileData::setName($name) |
| FileData::isNeededToConvert() |
| FileData::setNeedConvert($needConvert) |
| FileData::getSize() |
| FileData::setSize($size) |
| FileData::getSrc($getFromFileIfPossible = true) |
| FileData::setSrc($src) |
| FileData::getErrors() |
| FileData::getErrorsByCode($code) |
| FileData::getErrorByCode($code) |
| FileData::getFile() |
| FileData::setFile($file) |
| FileData::getVersion() |
| FileData::setVersion($version) |
| FileData::getMetaData() |
| FileData::setMetaData($metaData) |
| FileData::toArray() |
| FileData::getAttachedObject() |
| FileData::setAttachedObject($attachedObject) |
| UploadFileManager::__construct() |
| UploadFileManager::getEntry() |
| UploadFileManager::setEntry($entry) |
| UploadFileManager::isBadGoogleChunk($startRange, $endRange, array $fileData) |
| UploadFileManager::isInvalidChunkSize($startRange, $endRange, array $fileData) |
| Entry::getTableClassName() |
| Entry::getId() |
| Entry::getObjectId() |
| Entry::getObject() |
| Entry::getVersionId() |
| Entry::getVersion() |
| Entry::getTmpFileId() |
| Entry::getTmpFile() |
| Entry::getDownloadedContentSize() |
| Entry::getContentSize() |
| Entry::getMimeType() |
| Entry::getContentUrl() |
| Entry::getUserId() |
| Entry::getUser() |
| Entry::getService() |
| Entry::getServiceObjectId() |
| Entry::getEtag() |
| Entry::getCreateTime() |
| Entry::isDownloaded() |
| Entry::increaseDownloadedContentSize($size) |
| Entry::setContentSize($size) |
| Entry::linkTmpFile(TmpFile $tmpFile) |
| Entry::linkObject(BaseObject $object) |
| Entry::linkVersion(Version $version) |
| Entry::getMapAttributes() |
| Entry::getMapReferenceAttributes() |
| TmpFile::prepareDataToInsertFromFileArray(array $fileData, array $data, ErrorCollection $errorCollection) |
| ImportManager::__construct(Document\DocumentHandler $documentHandler) |
| ImportManager::getDocumentHandler() |
| ImportManager::buildByAttachedObject(AttachedObject $attachedObject) |
| ImportManager::startImport($fileId) |
| ImportManager::forkImport(Entry $cloudImport) |
| ImportManager::hasNewVersion(Entry $cloudImport) |
| ImportManager::uploadChunk(Entry $entry) |
| ImportManager::uploadEmptyFileFromGoogle(Entry $entry, Document\FileData $fileData) |
| ImportManager::saveFile(Entry $entry, Folder $folder) |
| ImportManager::recoverExtensionInName($fileName, $mimeType) |
| ImportManager::uploadVersion(Entry $entry) |
| ImportManager::getErrors() |
| ImportManager::getErrorsByCode($code) |
| ImportManager::getErrorByCode($code) |
| ImportManager::checkRequiredInputParams(array $inputParams, array $required) |
| YandexDiskHandler::getCode() |
| YandexDiskHandler::getName() |
| YandexDiskHandler::getStorageName() |
| YandexDiskHandler::checkAccessibleTokenService() |
| YandexDiskHandler::getUrlForAuthorizeInTokenService($mode = 'modal') |
| YandexDiskHandler::queryAccessToken() |
| YandexDiskHandler::createBlankFile(FileData $fileData) |
| YandexDiskHandler::createFile(FileData $fileData) |
| YandexDiskHandler::downloadFile(FileData $fileData) |
| YandexDiskHandler::getFileMetadata(FileData $fileData) |
| YandexDiskHandler::getDownloadUrl(FileData $fileData) |
| YandexDiskHandler::downloadPartFile(FileData $fileData, $startRange, $chunkSize) |
| YandexDiskHandler::deleteFile(FileData $fileData) |
| YandexDiskHandler::getDataForViewFile(FileData $fileData) |
| YandexDiskHandler::listFolder($path, $folderId) |
| YandexDiskHandler::getEncodedId($path) |
| YandexDiskHandler::getDecodedId($path) |
| YandexDiskHandler::getForApiDecodedId($path) |
| YandexDiskHandler::normalizeMetadata($metaData) |
| GoogleHandler::getCode() |
| GoogleHandler::getName() |
| GoogleHandler::getStorageName() |
| GoogleHandler::checkAccessibleTokenService() |
| GoogleHandler::getUrlForAuthorizeInTokenService($mode = 'modal') |
| GoogleHandler::getScopes() |
| GoogleHandler::queryAccessToken() |
| GoogleHandler::createBlankFile(FileData $fileData) |
| GoogleHandler::createFile(FileData $fileData) |
| GoogleHandler::createByResumableUpload(FileData $fileData, &$lastStatus, &$fileMetadata) |
| GoogleHandler::insertPermission(FileData $fileData, $role = self::PERMISSION_ROLE_WRITER, $type = self::PERMISSION_TYPE_ANYONE) |
| GoogleHandler::downloadFile(FileData $fileData) |
| GoogleHandler::repackDocument(FileData $fileData) |
| GoogleHandler::getDownloadUrl(FileData $fileData, $fileMetaData = array()) |
| GoogleHandler::downloadPartFile(FileData $fileData, $startRange, $chunkSize) |
| GoogleHandler::deleteFile(FileData $fileData) |
| GoogleHandler::shareFileToEdit(FileData $fileData) |
| GoogleHandler::getDataForViewFile(FileData $fileData) |
| GoogleHandler::wasChangedAfterCreation(array $currentMetadata, array $oldMetadata = array()) |
| GoogleHandler::listFolder($path, $folderId) |
| GoogleHandler::checkHttpResponse(HttpClient $http) |
| GoogleHandler::getFileMetadataInternal(FileData $fileData) |
| GoogleHandler::patchFile(FileData $fileData, array $fields) |
| GoogleHandler::getEmbedFileLink(FileData $fileData) |
| GoogleHandler::getFileSizeInternal($downloadUrl) |
| GoogleHandler::getFileMetadata(FileData $fileData) |
| GoogleHandler::getInternalMimeTypeByExtension($ext) |
| GoogleHandler::getExportMimeByInternalMimeType($internalMimeType) |
| GoogleHandler::isGoogleDocument($mimeType) |
| GoogleHandler::normalizeMetadata($metaData) |
| DropboxHandler::getCode() |
| DropboxHandler::getName() |
| DropboxHandler::getStorageName() |
| DropboxHandler::checkAccessibleTokenService() |
| DropboxHandler::getUrlForAuthorizeInTokenService($mode = 'modal') |
| DropboxHandler::queryAccessToken() |
| DropboxHandler::createBlankFile(FileData $fileData) |
| DropboxHandler::createFile(FileData $fileData) |
| DropboxHandler::downloadFile(FileData $fileData) |
| DropboxHandler::getFileMetadata(FileData $fileData) |
| DropboxHandler::downloadPartFile(FileData $fileData, $startRange, $chunkSize) |
| DropboxHandler::deleteFile(FileData $fileData) |
| DropboxHandler::getDataForViewFile(FileData $fileData) |
| DropboxHandler::listFolder($path, $folderId) |
| DropboxHandler::normalizeMetadata($metaData) |
| BitrixHandler::getCode() |
| BitrixHandler::getName() |
| BitrixHandler::checkAccessibleTokenService() |
| BitrixHandler::getUrlForAuthorizeInTokenService($mode = 'modal') |
| BitrixHandler::queryAccessToken() |
| BitrixHandler::hasAccessToken() |
| BitrixHandler::createBlankFile(FileData $fileData) |
| BitrixHandler::createFile(FileData $fileData) |
| BitrixHandler::downloadFile(FileData $fileData) |
| BitrixHandler::getFileMetadata(FileData $fileData) |
| BitrixHandler::downloadPartFile(FileData $fileData, $startRange, $chunkSize) |
| BitrixHandler::deleteFile(FileData $fileData) |
| BitrixHandler::getDataForViewFile(FileData $fileData) |
| BitrixHandler::listFolder($path, $folderId) |
| GoogleViewerHandler::getCode() |
| GoogleViewerHandler::getName() |
| GoogleViewerHandler::checkAccessibleTokenService() |
| GoogleViewerHandler::getUrlForAuthorizeInTokenService($mode = 'modal') |
| GoogleViewerHandler::queryAccessToken() |
| GoogleViewerHandler::hasAccessToken() |
| GoogleViewerHandler::createBlankFile(FileData $fileData) |
| GoogleViewerHandler::createFile(FileData $fileData) |
| GoogleViewerHandler::downloadFile(FileData $fileData) |
| GoogleViewerHandler::getFileMetadata(FileData $fileData) |
| GoogleViewerHandler::downloadPartFile(FileData $fileData, $startRange, $chunkSize) |
| GoogleViewerHandler::deleteFile(FileData $fileData) |
| GoogleViewerHandler::getDataForViewFile(FileData $fileData) |
| GoogleViewerHandler::listFolder($path, $folderId) |
| GoogleViewerHandler::checkViewFile(FileData $fileData) |
| OneDriveHandler::getCode() |
| OneDriveHandler::getName() |
| OneDriveHandler::getStorageName() |
| OneDriveHandler::checkAccessibleTokenService() |
| OneDriveHandler::getUrlForAuthorizeInTokenService($mode = 'modal') |
| OneDriveHandler::queryAccessToken() |
| OneDriveHandler::getOAuthService() |
| OneDriveHandler::getScopes() |
| OneDriveHandler::createBlankFile(FileData $fileData) |
| OneDriveHandler::createFile(FileData $fileData) |
| OneDriveHandler::createFileInternal(FileData $fileData) |
| OneDriveHandler::instantiateResumableUpload(FileData $fileData) |
| OneDriveHandler::createByResumableUpload(FileData $fileData) |
| OneDriveHandler::getUploadPath(FileData $fileData) |
| OneDriveHandler::createFileBySimpleUpload(FileData $fileData) |
| OneDriveHandler::getFileNameToQuery(FileData $fileData) |
| OneDriveHandler::getApiUrlRoot() |
| OneDriveHandler::getSharedLink(FileData $fileData, $type = self::SHARED_LINK_TYPE_VIEW) |
| OneDriveHandler::downloadFile(FileData $fileData) |
| OneDriveHandler::downloadFileContent(FileData $fileData, $startRange = null, $chunkSize = null) |
| OneDriveHandler::getFileMetadata(FileData $fileData) |
| OneDriveHandler::downloadPartFile(FileData $fileData, $startRange, $chunkSize) |
| OneDriveHandler::deleteFile(FileData $fileData) |
| OneDriveHandler::getDataForViewFile(FileData $fileData) |
| OneDriveHandler::wasChangedAfterCreation(array $currentMetadata, array $oldMetadata = array()) |
| OneDriveHandler::listFolder($path, $folderId) |
| OneDriveHandler::getSharedEmbedLink(FileData $fileData) |
| OneDriveHandler::normalizeMetadata($metaData) |
| OneDriveHandler::checkHttpResponse(HttpClient $http) |
| DocumentHandlersManager::__construct($user) |
| DocumentHandlersManager::getDefaultServiceForCurrentUser() |
| DocumentHandlersManager::getHandlerByCode($code) |
| DocumentHandlersManager::getHandlers() |
| DocumentHandlersManager::shouldHideGoogle(DocumentHandler $handler) |
| DocumentHandlersManager::getHandlersForImport() |
| DocumentHandlersManager::getHandlersForView() |
| DocumentHandlersManager::getDefaultHandlerForView() |
| DocumentHandlersManager::isReady(DocumentHandler $documentHandler) |
| DocumentHandlersManager::buildDocumentHandlerList() |
| DocumentHandlersManager::getErrors() |
| DocumentHandlersManager::getErrorsByCode($code) |
| DocumentHandlersManager::getErrorByCode($code) |
| LocalDocumentController::isLocalService($serviceName) |
| LocalDocumentController::getCode() |
| LocalDocumentController::getName() |
| LocalDocumentController::listActions() |
| LocalDocumentController::isActionWithExistsFile() |
| LocalDocumentController::prepareParams() |
| LocalDocumentController::processBeforeAction($actionName) |
| LocalDocumentController::checkReadPermissions() |
| LocalDocumentController::checkUpdatePermissions() |
| LocalDocumentController::isSpecificVersion() |
| LocalDocumentController::initializeData() |
| LocalDocumentController::initializeFile($fileId) |
| LocalDocumentController::initializeVersion($versionId) |
| LocalDocumentController::processActionDownload() |
| LocalDocumentController::processActionCommit() |
| LocalDocumentController::processActionPublishBlank($type) |
| BlankFileData::__construct($type) |
| BlankFileData::issetType($type) |
| BlankFileData::getTypeList() |
| BlankFileData::getPathToBlankDocsFolder() |
| BlankFileData::getType($type) |
| BoxHandler::getCode() |
| BoxHandler::getName() |
| BoxHandler::getStorageName() |
| BoxHandler::checkAccessibleTokenService() |
| BoxHandler::getUrlForAuthorizeInTokenService($mode = 'modal') |
| BoxHandler::queryAccessToken() |
| BoxHandler::createBlankFile(FileData $fileData) |
| BoxHandler::createFile(FileData $fileData) |
| BoxHandler::downloadFile(FileData $fileData) |
| BoxHandler::getFileMetadata(FileData $fileData) |
| BoxHandler::downloadPartFile(FileData $fileData, $startRange, $chunkSize) |
| BoxHandler::deleteFile(FileData $fileData) |
| BoxHandler::getDataForViewFile(FileData $fileData) |
| BoxHandler::listFolder($path, $folderId) |
| BoxHandler::normalizeMetadata($metaData) |
| DocumentHandler::__construct($userId) |
| DocumentHandler::className() |
| DocumentHandler::getUserId() |
| DocumentHandler::setUserId($userId) |
| DocumentHandler::isEditable($extension) |
| DocumentHandler::isNeedConvertExtension($extension) |
| DocumentHandler::getConvertExtension($extension) |
| DocumentHandler::getCode() |
| DocumentHandler::getName() |
| DocumentHandler::getStorageName() |
| DocumentHandler::wasChangedAfterCreation(array $currentMetadata, array $oldMetadata = array()) |
| DocumentHandler::checkViewFile(FileData $fileData) |
| DocumentHandler::getAccessToken() |
| DocumentHandler::hasAccessToken() |
| DocumentHandler::getErrorContainer() |
| DocumentHandler::getErrors() |
| DocumentHandler::getErrorsByCode($code) |
| DocumentHandler::getErrorByCode($code) |
| DocumentHandler::isRequiredAuthorization() |
| DocumentHandler::checkHttpResponse(HttpClient $http) |
| DocumentHandler::recoverExtensionInName(&$fileName, $mimeType) |
| DocumentHandler::checkRequiredInputParams(array $inputParams, array $required) |
| DocumentHandler::convertToUtf8($data) |
| DocumentHandler::retryMethod($method, array $args, $numberOfTimesToRetry = 2) |
| DocumentHandler::normalizeMetadata($metaData) |
| MyOfficeHandler::getCode() |
| MyOfficeHandler::getName() |
| MyOfficeHandler::getStorageName() |
| MyOfficeHandler::checkAccessibleTokenService() |
| MyOfficeHandler::getUrlForAuthorizeInTokenService($mode = 'modal') |
| MyOfficeHandler::isEnabled() |
| MyOfficeHandler::getPredefinedUser($userId) |
| MyOfficeHandler::queryAccessToken() |
| MyOfficeHandler::createBlankFile(FileData $fileData) |
| MyOfficeHandler::createFile(FileData $fileData) |
| MyOfficeHandler::getEditLink(array $links) |
| MyOfficeHandler::getApiUrlRoot() |
| MyOfficeHandler::downloadFile(FileData $fileData) |
| MyOfficeHandler::downloadFileContent(FileData $fileData, $startRange = null, $chunkSize = null) |
| MyOfficeHandler::getFileMetadata(FileData $fileData) |
| MyOfficeHandler::downloadPartFile(FileData $fileData, $startRange, $chunkSize) |
| MyOfficeHandler::deleteFile(FileData $fileData) |
| MyOfficeHandler::getDataForViewFile(FileData $fileData) |
| MyOfficeHandler::listFolder($path, $folderId) |
| MyOfficeHandler::normalizeMetadata($metaData) |
| DocumentController::listActions() |
| DocumentController::isActionWithExistsFile() |
| DocumentController::init() |
| DocumentController::processBeforeAction($actionName) |
| DocumentController::redirectToAuth($backUrl = null) |
| DocumentController::isSpecificVersion() |
| DocumentController::checkReadPermissions() |
| DocumentController::checkUpdatePermissions() |
| DocumentController::getDocumentHandlerName() |
| DocumentController::setDocumentHandlerName($serviceName) |
| DocumentController::prepareParams() |
| DocumentController::processActionStart() |
| DocumentController::renderStartPage($vars) |
| DocumentController::onBeforeActionShow() |
| DocumentController::processActionShow() |
| DocumentController::prepareFileData() |
| DocumentController::processActionCheckView() |
| DocumentController::onBeforeActionPublishBlank() |
| DocumentController::processActionPublishBlank() |
| DocumentController::processActionSaveBlank() |
| DocumentController::getFolderToSaveFile($targetFolderId) |
| DocumentController::processActionRename() |
| DocumentController::findShowSessionByCurrentUser() |
| DocumentController::createEditSessionFromShowSession(ShowSession $showSession) |
| DocumentController::onBeforeActionPublish() |
| DocumentController::processActionPublish() |
| DocumentController::getFileSrcToPublish() |
| DocumentController::getDocumentHandlerForSession(EditSession $session) |
| DocumentController::downloadFile(EditSession $session, FileData $fileData) |
| DocumentController::processActionCommit() |
| DocumentController::processActionGetLastVersionUri() |
| DocumentController::processActionDiscardBlank() |
| DocumentController::processActionDiscard() |
| DocumentController::initializeData() |
| DocumentController::initializeFile($fileId) |
| DocumentController::initializeVersion($versionId) |
| DocumentController::isViewAction() |
| DocumentController::initializeDocumentService() |
| DocumentController::forkEditSessionForCurrentUser(EditSession $editSession) |
| DocumentController::addFileEditSessionByCurrentUser(FileData $fileData) |
| DocumentController::addCreateEditSessionByCurrentUser(FileData $fileData) |
| DocumentController::isLastEditSessionForFile() |
| DocumentController::getOnlineEditSessionForFile() |
| DocumentController::getEditSessionByCurrentUser($sessionId) |
| DocumentController::deleteEditSession(EditSession $editSession) |
| DocumentController::deleteFile(EditSession $editSession, FileData $fileData) |
| DocumentController::sendNeedAuth(array $response = array()) |
| DocumentController::processWithLockedFile($fileId, $fileArray) |
| Office365Handler::getCode() |
| Office365Handler::getName() |
| Office365Handler::getStorageName() |
| Office365Handler::getOAuthService() |
| Office365Handler::instantiateResumableUpload(FileData $fileData) |
| Office365Handler::getApiUrlRoot() |
| Office365Handler::getScopes() |
| Office365Handler::getDataForViewFile(FileData $fileData) |
| Office365Handler::getSharedEmbedLink(FileData $fileData) |
| Office365Handler::shareFileToEdit(FileData $fileData) |
| Office365Handler::getFileMetadata(FileData $fileData) |
| Office365Handler::getUploadPath(FileData $fileData) |
| EditSession::getTableClassName() |
| EditSession::getCreateTime() |
| EditSession::getObject() |
| EditSession::getObjectId() |
| EditSession::getVersionId() |
| EditSession::getVersion() |
| EditSession::getOwner() |
| EditSession::getOwnerId() |
| EditSession::getService() |
| EditSession::getServiceFileId() |
| EditSession::getServiceFileLink() |
| EditSession::getUser() |
| EditSession::getUserId() |
| EditSession::isExclusive() |
| EditSession::getMapAttributes() |
| EditSession::getMapReferenceAttributes() |
| Group::canAttachToExternalEntity() |
| Group::getEntityUrl() |
| Group::getEntityTitle() |
| Group::getEntityImageSrc($width, $height) |
| Group::getTitle() |
| Group::getGroup() |
| Group::canRead($user, $groupId) |
| Group::isExtranetGroup() |
| Common::__construct($entityId, Storage $storage, $entityMiscData = null) |
| Common::canAttachToExternalEntity() |
| Common::getStorageBaseUrl() |
| Common::getEntityImageSrc($width, $height) |
| Common::getTitle() |
| RestApp::canAttachToExternalEntity() |
| RestApp::canIndexBySearch() |
| RestApp::getStorageBaseUrl() |
| RestApp::getEntityUrl() |
| RestApp::getEntityImageSrc($width, $height) |
| User::canAttachToExternalEntity() |
| User::getEntityUrl() |
| User::getEntityTitle() |
| User::getEntityImageSrc($width, $height) |
| User::getTitle() |
| User::getTitleForCurrentUser() |
| User::getUser() |
| Base::__construct($methodName, array $params, $start, \CRestServer $restServer) |
| Base::className() |
| Base::canAttachToExternalEntity() |
| Base::canIndexBySearch() |
| Base::getSecurityContextByCurrentUser() |
| Base::getBaseUrlFolderList() |
| Base::getBaseUrlTashcanList() |
| Base::getBaseUrlFileDetail() |
| Base::getBaseUrlFileHistory() |
| Base::getBaseUrlTrashcanFileDetail() |
| Base::getEntityUrl() |
| Base::getEntityTitle() |
| Base::getTitle(Volume\Fragment $fragment) |
| Base::getTitleForCurrentUser() |
| Disk::getSecurityContextByUser($user) |
| Disk::getStorageBaseUrl() |
| Disk::canIndexBySearch() |
| Disk::isCurrentUser($user) |
| Text::getNumericCase($number, $once, $multi21, $multi2_4, $multi5_20) |
| Text::cleanTrashCanSuffix($string) |
| Text::appendTrashCanSuffix($string) |
| Text::killTags($text) |
| Text::correctFilename($filename) |
| Text::correctFolderName($folderName) |
| Text::correctObjectName($objectName) |
| ExternalLink::buildPreview(array $params) |
| ExternalLink::checkUserReadAccess(array $params, $userId) |
| File::buildPreview(array $params) |
| File::checkUserReadAccess(array $params, $userId) |
| ExternalLinkAttributes::getViewerTypeByFile(array $fileArray) |
| FileAttributes::tryBuildByFileId($fileId, $sourceUri) |
| FileAttributes::setObjectId($objectId) |
| FileAttributes::setAttachedObjectId($attachedObjectId) |
| FileAttributes::setDefaultAttributes() |
| FileAttributes::getViewerTypeByFile(array $fileArray) |
| FileAttributes::refineType($type, $fileArray) |
| FileAttributes::isSetViewDocumentInClouds() |
| FileAttributes::isAllowedUseClouds($contentType) |
| FileAttributes::getInputContentTypes() |
| LazyLoad::getBase64Stub() |
| Image::getBase64Stub() |
| Destination::getSocNetDestination($userId, $selected = array()) |
| Destination::getRightsDestination($userId, $selected = array()) |
| Destination::getLocMessageToAllEmployees() |
| Destination::getLocMessageToAllUsers() |
| Viewer::isViewable($extension) |
| Viewer::isOnlyViewable($extension) |
| Viewer::getAttributesByArray(array $file) |
| Viewer::getAttributesByObject(BaseObject $object, array $additionalParams = array()) |
| Viewer::getAttributesByExternalLink(ExternalLink $externalLink, BaseObject $dependedObject = null, array $additionalParams = array()) |
| Viewer::getAttributesByVersion(Version $version, array $additionalParams = array()) |
| Viewer::getAttributesByAttachedObject(AttachedObject $attachedObject, array $additionalParams = array()) |
| Viewer::getAttributesForDocumentPreviewImageByObject(BaseObject $object) |
| Icon::getIconClassByObject(BaseObject $object, $appendSharedClass = false) |
| Avatar::getPerson($avatarId, $width = 58, $height = 58) |
| Avatar::getGroup($avatarId, $width = 58, $height = 58) |
| Avatar::getDefaultGroup() |
| Avatar::getDefaultPerson() |
| Avatar::getSrc($avatarId, $width = 58, $height = 58) |
| Stepper::getHtml() |
| TrashCrumbStorage::fetchNameByObject(BaseObject $object) |
| TestArchiveEntry::__construct() |
| TestArchiveEntry::create() |
| TestArchiveEntry::createFromFile(File $file, $name = null) |
| TestArchiveEntry::createFromAttachedObject(AttachedObject $attachedObject, $name = null) |
| TestArchiveEntry::createFromFileArray(array $fileArray, $name) |
| EmptyArchive::__construct($name) |
| EmptyArchive::send() |
| TestDownloadController::listActions() |
| TestDownloadController::runProcessingIfUserNotAuthorized() |
| TestDownloadController::processActionDownloadTestZipArchive() |
| Configuration::isEnabled() |
| Configuration::disable() |
| Configuration::enable() |
| Configuration::isModInstalled() |
| ArchiveEntry::__construct() |
| ArchiveEntry::createFromFile(File $file, $name = null) |
| ArchiveEntry::createFromAttachedObject(AttachedObject $attachedObject, $name = null) |
| ArchiveEntry::createFromFileArray(array $fileArray, $name) |
| ArchiveEntry::getName() |
| ArchiveEntry::getPath() |
| ArchiveEntry::getSize() |
| ArchiveEntry::getCrc32() |
| ArchiveEntry::__toString() |
| ArchiveEntry::checkRequiredInputParams(array $inputParams, array $required) |
| ArchiveEntry::getErrors() |
| ArchiveEntry::getErrorsByCode($code) |
| ArchiveEntry::getErrorByCode($code) |
| Archive::__construct($name, array $entries = array()) |
| Archive::createFromFolder(Folder $folder, SecurityContext $securityContext) |
| Archive::collectDescendants(Folder $folder, SecurityContext $securityContext, $currentPath = '') |
| Archive::isEmpty() |
| Archive::getName() |
| Archive::setName($name) |
| Archive::addEntry(ArchiveEntry $entry) |
| Archive::addHeaders() |
| Archive::getFileList() |
| Archive::send() |
| Archive::disableCompression() |
| SecurityContext::__construct($user) |
| SecurityContext::getUserId() |
| SecurityContext::preloadOperationsForChildren($parentObjectId) |
| SecurityContext::preloadOperationsForSpecifiedObjects($parentObjectId, array $objectIds) |
| SecurityContext::getErrors() |
| SecurityContext::getErrorsByCode($code) |
| SecurityContext::getErrorByCode($code) |
| DiskSecurityContext::canDoOperation($objectId, $operation) |
| DiskSecurityContext::getOperationsByObject($objectId) |
| DiskSecurityContext::preloadOperationsForChildren($parentObjectId) |
| DiskSecurityContext::preloadOperationsForSpecifiedObjects($parentObjectId, array $objectIds) |
| DiskSecurityContext::canAdd($targetId) |
| DiskSecurityContext::canChangeRights($objectId) |
| DiskSecurityContext::canChangeSettings($objectId) |
| DiskSecurityContext::canCreateWorkflow($objectId) |
| DiskSecurityContext::canDelete($objectId) |
| DiskSecurityContext::canMarkDeleted($objectId) |
| DiskSecurityContext::canMove($objectId, $targetId) |
| DiskSecurityContext::canRead($objectId) |
| DiskSecurityContext::canRename($objectId) |
| DiskSecurityContext::canRestore($objectId) |
| DiskSecurityContext::canShare($objectId) |
| DiskSecurityContext::canUpdate($objectId) |
| DiskSecurityContext::canStartBizProc($objectId) |
| DiskSecurityContext::getSqlExpressionForList($columnObjectId, $columnCreatedBy) |
| ParameterSigner::getImageSignature($id, $width, $height) |
| ParameterSigner::validateImageSignature($signature, $id, $width, $height) |
| ParameterSigner::getArchiveSignature(array $ids) |
| ParameterSigner::getEntityArchiveSignature($entity, $entityId, $fieldName) |
| ParameterSigner::validateEntityArchiveSignature($signature, $entity, $entityId, $fieldName) |
| ParameterSigner::validateArchiveSignature($signature, array $ids) |
| ParameterSigner::prepareList(array $list) |
| FakeSecurityContext::canAdd($targetId) |
| FakeSecurityContext::canChangeRights($objectId) |
| FakeSecurityContext::canChangeSettings($objectId) |
| FakeSecurityContext::canCreateWorkflow($objectId) |
| FakeSecurityContext::canDelete($objectId) |
| FakeSecurityContext::canMarkDeleted($objectId) |
| FakeSecurityContext::canMove($objectId, $targetId) |
| FakeSecurityContext::canRead($objectId) |
| FakeSecurityContext::canRename($objectId) |
| FakeSecurityContext::canRestore($objectId) |
| FakeSecurityContext::canShare($objectId) |
| FakeSecurityContext::canUpdate($objectId) |
| FakeSecurityContext::canStartBizProc($objectId) |
| FakeSecurityContext::getSqlExpressionForList($columnObjectId, $columnCreatedBy) |
| Right::getDomain() |
| Right::getAccessCode() |
| Right::getObjectId() |
| Right::getTaskId() |
| Right::isNegative() |
| Right::getMapAttributes() |
| BizProcDocumentCompatible::generateDocumentType($storageId) |
| BizProcDocumentCompatible::generateDocumentComplexType($storageId) |
| BizProcDocumentCompatible::getDocumentComplexId($documentId) |
| BizProcDocumentCompatible::getDocument($documentId) |
| BizProcDocumentCompatible::getUserTypeFields($storageId) |
| BizProcDocumentCompatible::getDocumentFields($documentType) |
| BizProcDocumentCompatible::getPrefixForCustomType() |
| ArrayHelper::getByPath($array, $path, $defaultValue = null) |
| ObjectCollection::__construct(BaseObject ...$baseObjects) |
| ObjectCollection::createByIds(...$id) |
| ObjectCollection::getIterator() |
| ObjectCollection::toArray() |
| ObjectCollection::getIds() |
| DataSet::__construct($items) |
| DataSet::createByIterator(\Traversable $iterator) |
| DataSet::createByArray(array $items) |
| DataSet::filterByCallback($callback) |
| DataSet::filterByField($field, $value) |
| DataSet::filterByFields(array $necessaryFields) |
| DataSet::isExists(array $necessaryFields) |
| DataSet::getById($id) |
| DataSet::getFirst() |
| DataSet::sortByColumn($columns, $callbacks = '', $defaultValueIfNotSetValue = null, $preserveKeys = false) |
| CrumbStorage::__construct() |
| CrumbStorage::setEvents() |
| CrumbStorage::__clone() |
| CrumbStorage::getInstance() |
| CrumbStorage::onObjectOnAfterMove(Event $event) |
| CrumbStorage::onAfterRenameObject(\Bitrix\Main\Event $event) |
| CrumbStorage::cleanByObjectId($objectId) |
| CrumbStorage::getByObject(BaseObject $object, $includeSelf = false) |
| CrumbStorage::calculateDistance(Folder $fromFolder, BaseObject $toObject) |
| CrumbStorage::calculateCrumb(BaseObject $object) |
| CrumbStorage::fetchNameByObject(BaseObject $object) |
| DownloadController::listActions() |
| DownloadController::onBeforeActionShowFile() |
| DownloadController::onBeforeActionShowPreview() |
| DownloadController::onBeforeActionShowView() |
| DownloadController::onBeforeActionShowViewHtml() |
| DownloadController::onBeforeActionShowVersionView() |
| DownloadController::onBeforeActionShowTransformationInfo() |
| DownloadController::onBeforeActionDownloadFile() |
| DownloadController::onBeforeActionDownloadVersion() |
| DownloadController::onBeforeActionCopyToMe() |
| DownloadController::onBeforeActionTransformOnOpen() |
| DownloadController::onWorkWithOneFile() |
| DownloadController::checkPermissions() |
| DownloadController::processActionDownloadFile() |
| DownloadController::processActionShowViewHtml($pathToView, $mode = '', $print = '', $preview = '', $sizeType = '', $printUrl = '', $autostart = 'Y') |
| DownloadController::processActionShowVersionView() |
| DownloadController::processActionShowView() |
| DownloadController::processActionTransformOnOpen() |
| DownloadController::processActionShowTransformationInfo($noError = '') |
| DownloadController::processActionShowFile() |
| DownloadController::processActionShowPreview() |
| DownloadController::showFileByArray($fileName, $fileData = array(), $cacheTime = 86400, $forceDownload = false) |
| DownloadController::processActionDownloadVersion() |
| DownloadController::processActionCopyToMe() |
| DownloadController::processActionDownloadArchive($signature, array $objectIds) |
| DownloadController::processActionDownloadByExternalLink($externalLink) |
| SocialnetworkHandlers::onAfterUserAdd($fields) |
| SocialnetworkHandlers::onAfterUserUpdate($fields) |
| SocialnetworkHandlers::onUserDelete($userId) |
| SocialnetworkHandlers::onSocNetGroupAdd($id, $fields) |
| SocialnetworkHandlers::onSocNetGroupUpdate($groupId, $fields) |
| SocialnetworkHandlers::onSocNetGroupDelete($groupId) |
| SocialnetworkHandlers::onSocNetUserToGroupDelete($id, $fields) |
| SocialnetworkHandlers::onSocNetUserToGroupUpdate($id, $fields) |
| SocialnetworkHandlers::onSocNetUserToGroupAdd($id, $fields) |
| SocialnetworkHandlers::onSocNetFeaturesAdd($id, $fields) |
| SocialnetworkHandlers::onSocNetFeaturesUpdate($id, $fields) |
| SocialnetworkHandlers::onAfterFetchDiskUfEntity(array $entities) |
| SocialnetworkHandlers::getActivityUserId() |
| Configuration::isEnabledDefaultEditInUf() |
| Configuration::isEnabledKeepVersion() |
| Configuration::isEnabledStorageSizeRestriction() |
| Configuration::getVersionLimitPerFile() |
| Configuration::isPossibleToShowExternalLinkControl() |
| Configuration::isEnabledExternalLink() |
| Configuration::isEnabledObjectLock() |
| Configuration::getDocumentServiceCodeForCurrentUser() |
| Configuration::canCreateFileByCloud() |
| Configuration::canAutoConnectSharedObjects() |
| Configuration::isSuccessfullyConverted() |
| Configuration::getRevisionApi() |
| Configuration::getMaxFileSizeForIndex() |
| Configuration::getMaxIndexSize() |
| Configuration::allowIndexFiles() |
| Configuration::allowFullTextIndex() |
| Configuration::getDefaultViewerServiceCode() |
| Configuration::allowDocumentTransformation() |
| Configuration::getMaxSizeForDocumentTransformation() |
| Configuration::allowVideoTransformation() |
| Configuration::getMaxSizeForVideoTransformation() |
| Configuration::allowTransformFilesOnOpen() |
| UserConfiguration::resetDocumentServiceCode() |
| UserConfiguration::getDocumentServiceCode() |
| UserConfiguration::isSetLocalDocumentService() |
| UrlManager::__construct() |
| UrlManager::resolvePathComponentEngine(\CComponentEngine $engine, $pageCandidates, &$variables) |
| UrlManager::resolveSocNetPathComponentEngine(\CComponentEngine $engine, $pageCandidates, &$variables) |
| UrlManager::getStorageByVariables($variablesTmp) |
| UrlManager::encodeUrn($uri) |
| UrlManager::getUrlExternalLink(array $paramsUri, $absolute = false) |
| UrlManager::getShortUrlExternalLink(array $paramsUri, $absolute = false) |
| UrlManager::getHostUrl() |
| UrlManager::getPathInListing(BaseObject $object) |
| UrlManager::getPathInTrashcanListing(BaseObject $object) |
| UrlManager::getTrashcan(Storage $storage) |
| UrlManager::getPathFolderList(Folder $folder) |
| UrlManager::getPathFileDetail(File $file) |
| UrlManager::getPathTrashcanFileDetail(File $file) |
| UrlManager::getUrlForStartCreateFile($typeFile, $service) |
| UrlManager::getUrlForStartEditFile($fileId, $service) |
| UrlManager::getUrlForStartEditVersion($fileId, $versionId, $service) |
| UrlManager::getUrlToShowFileByService($fileId, $service, array $params = array()) |
| UrlManager::getUrlToShowVersionByService($fileId, $versionId, $service) |
| UrlManager::getUrlToShowAttachedFileByService($attachedId, $service) |
| UrlManager::getUrlToStartCreateUfFileByService($typeFile, $service) |
| UrlManager::getUrlToStartEditUfFileByService($attachedId, $service) |
| UrlManager::getUrlToActionShowUfFile($attachedId, array $params = array()) |
| UrlManager::getUrlToUploadUfFile() |
| UrlManager::getUrlUfController($action, array $params = array()) |
| UrlManager::getUrlFocusController($action, array $params = array(), $absolute = false) |
| UrlManager::getUrlDocumentController($action, array $params = array()) |
| UrlManager::getUrlForDownloadFile(File $file, $absolute = false) |
| UrlManager::getUrlForShowFile(File $file, array $params = array(), $absolute = false) |
| UrlManager::getUrlForShowPreview(File $file, array $params = array(), $absolute = false) |
| UrlManager::getUrlForShowView(File $file, array $params = array(), $absolute = false) |
| UrlManager::getUrlForShowViewHtml(File $file, array $params = array(), $absolute = false) |
| UrlManager::getUrlForShowAttachedFileViewHtml($attachedId, array $params = array(), $updateTime = 0) |
| UrlManager::getUrlForShowAttachedVersionViewHtml($attachedId, array $params = array()) |
| UrlManager::getUrlForShowVersionView(Version $version, array $params = array(), $absolute = false) |
| UrlManager::getUrlForShowVersionViewHtml(Version $version, array $params = array(), $absolute = false) |
| UrlManager::getUrlForTransformOnOpen(File $file) |
| UrlManager::getUrlForShowTransformInfo(File $file, $params = array()) |
| UrlManager::getUrlForDownloadVersion(Version $version, $absolute = false) |
| UrlManager::getUrlDownloadController($action, array $params = array(), $absolute = false) |
| UrlManager::getUrlToDownloadByExternalLink($externalLinkHash, array $params = array(), $absolute = false) |
| UrlManager::getUrlToGetLastVersionUriByFile($fileId) |
| UrlManager::getUrlToGetLastVersionUriByAttachedFile($attachedObjectId) |
| UrlManager::generateUrlForGoogleViewer($downloadLink) |
| UrlManager::resolveFolderIdFromPath(Storage $storage, $path) |
| UrlManager::resolveFileIdFromPath(Storage $storage, $path) |
| UrlManager::resolveObjectIdFromPath(Storage $storage, $path) |
| UrlManager::resolveObjectIdFromPathUnderRootObject(BaseObject $rootObject, $path) |
| UrlManager::resolvePathUnderRootObject(BaseObject $rootObject, $path) |
| UrlManager::getErrors() |
| UrlManager::getErrorsByCode($code) |
| UrlManager::getErrorByCode($code) |
| UrlManager::setComponent(BaseComponent $component) |
| UrlManager::buildUrl($rewriteCondition, array $paramsUri) |
| UrlManager::resolvePath(Storage $storage, $path, $lookUpFromFolderId, $lastPart = FolderTable::TYPE_FOLDER) |
| UrlManager::resolvePathToFolder(Storage $storage, $path) |
| UrlManager::resolvePathToFile(Storage $storage, $path) |
| UrlManager::resolvePathToTrashFolder(Storage $storage, $path) |
| UrlManager::resolvePathToTrashFile(Storage $storage, $path) |
| UrlManager::buildPathToDeletedObject(BaseObject $object) |
| SystemUser::init() |
| SystemUser::create() |
| SystemUser::isSystemUserId($id) |
| SystemUser::getId() |
| SystemUser::isIntranetUser() |
| SystemUser::isExtranetUser() |
| SystemUser::getLastName() |
| SystemUser::getLogin() |
| SystemUser::getName() |
| SystemUser::getSecondName() |
| SystemUser::getShortName() |
| ObjectTtl::getTableClassName() |
| ObjectTtl::add(array $data, ErrorCollection $errorCollection) |
| ObjectTtl::addAgentIfNotExist() |
| ObjectTtl::loadByObjectId($objectId) |
| ObjectTtl::getCreateTime() |
| ObjectTtl::getDeathTime() |
| ObjectTtl::changeDeathTime(DateTime $dateTime) |
| ObjectTtl::getObjectId() |
| ObjectTtl::isReadyToDeath() |
| ObjectTtl::deleteObject($deletedBy) |
| ObjectTtl::delete($deletedBy) |
| ObjectTtl::getMapAttributes() |
| ObjectTtl::getMapReferenceAttributes() |
| UploadFileManager::setTmpFileClass($tmpFileClass) |
| UploadFileManager::getErrors() |
| UploadFileManager::getErrorsByCode($code) |
| UploadFileManager::getErrorByCode($code) |
| UploadFileManager::getFileSize() |
| UploadFileManager::setFileSize($fileSize) |
| UploadFileManager::getContentRange() |
| UploadFileManager::setContentRange(array $contentRange) |
| UploadFileManager::getToken() |
| UploadFileManager::setToken($token) |
| UploadFileManager::hasToken() |
| UploadFileManager::getUserId() |
| UploadFileManager::setUserId($userId) |
| UploadFileManager::setUser($user) |
| UploadFileManager::upload($filename, array $fileData) |
| UploadFileManager::isValidChunkSize($startRange, $endRange, array $fileData) |
| UploadFileManager::removeIrrelevant() |
| UploadFileManager::rollbackByToken() |
| UploadFileManager::findBucketForFile(array $params) |
| UploadFileManager::findUserSpecificTmpFileByToken() |
| UploadFileManager::isFirstChunk($startRange) |
| UploadFileManager::getChunkSize($filename, $fileSize) |
| TreeNode::__construct($id, $name, $parentId, $realObjectId) |
| TreeNode::setAsRoot() |
| TreeNode::isLink() |
| TreeNode::isRoot() |
| TreeNode::isReplica() |
| TreeNode::markAsReplica() |
| TreeNode::getPathWithoutFirstLink() |
| TreeNode::getPath() |
| TreeNode::removeLastComponent($path) |
| TreeNode::setTree(array &$tree) |
| TreeNode::setCreateDate($createDate) |
| TreeNode::setLink(TreeNode $link) |
| SubscriberManager::__construct() |
| SubscriberManager::setEvents() |
| SubscriberManager::onObjectOnAfterMove(Event $event) |
| SubscriberManager::onSharingUpdated(Event $event) |
| SubscriberManager::cleanByObjectId($objectId) |
| SubscriberManager::collectSubscribersFromSubtree(BaseObject $object) |
| SubscriberManager::collectSubscribersGeneralWay(BaseObject $object, $direction) |
| SubscriberManager::getSubscribresByStorages(array $storagesId) |
| SubscriberManager::collectSubscribersSmart(BaseObject $object) |
| SubscriberManager::collectSubscribers(BaseObject $object) |
| SubscriberManager::collectSubscribersBySharings(BaseObject $object) |
| SubscriberManager::appendSubscribersBySharings(BaseObject $object, array $alreadySubscribers) |
| SubscriberManager::getSharingsByObject(BaseObject $object) |
| SubscriberManager::preloadSharingsForSubtree(Folder $folder) |
| SubscriberManager::clean() |
| TmpFile::getTableClassName() |
| TmpFile::getToken() |
| TmpFile::getFilename() |
| TmpFile::getContentType() |
| TmpFile::getPath() |
| TmpFile::getBucketId() |
| TmpFile::getSize() |
| TmpFile::getReceivedSize() |
| TmpFile::getWidth() |
| TmpFile::getHeight() |
| TmpFile::getCreateTime() |
| TmpFile::getCreatedBy() |
| TmpFile::getCreateUser() |
| TmpFile::isCloud() |
| TmpFile::getBucket() |
| TmpFile::delete() |
| TmpFile::registerDelayedDeleteOnShutdown() |
| TmpFile::generateTokenByPath($path) |
| TmpFile::createFromFileArray(array $fileData, array $data, ErrorCollection $errorCollection) |
| TmpFile::createInBucketFirstPartFromFileArray(array $fileData, array $data, \CCloudStorageBucket $bucket, array $params, ErrorCollection $errorCollection) |
| TmpFile::append($fileContent, array $params) |
| TmpFile::appendContentCloud($fileContent, $startRange, $endRange, $fileSize) |
| TmpFile::appendContentNonCloud($fileContent, $startRange, $endRange, $fileSize) |
| TmpFile::increaseReceivedSize($bytes) |
| TmpFile::generatePath() |
| TmpFile::getAbsoluteCloudPath() |
| TmpFile::getAbsoluteNonCloudPath() |
| TmpFile::getAbsolutePath() |
| TmpFile::getMapAttributes() |
| TmpFile::getMapReferenceAttributes() |
| StorageController::listActions() |
| StorageController::runProcessingException(\Exception $e) |
| StorageController::runProcessingIfUserNotAuthorized() |
| StorageController::isActualApiDiskVersion() |
| StorageController::isDesktopReadyForNewSnapshot() |
| StorageController::runProcessingIfInvalidCsrfToken() |
| StorageController::getStorage() |
| StorageController::processBeforeAction($actionName) |
| StorageController::sendJsonResponse($response, $params = null) |
| StorageController::storeUsagePerDay() |
| StorageController::processActionUpload() |
| StorageController::processActionSnapshot() |
| StorageController::generateNextPageUrl(Bitrix24Disk\PageState $pageState = null) |
| StorageController::isLicensePaid() |
| StorageController::processActionDownload() |
| StorageController::processActionDelete() |
| StorageController::processActionDirectory() |
| StorageController::processActionGetChunkSize() |
| StorageController::processActionRollbackUpload() |
| StorageController::processActionGetMaxUploadSize() |
| StorageController::processActionUpdate() |
| StorageController::processActionInitialize() |
| StorageController::processActionGetDiskSpace() |
| StorageController::processActionGetDiskQuota() |
| StorageController::getPathToDiscuss(User $userModel) |
| StorageController::getPathToUserLib(User $userModel, Storage $storageModel) |
| StorageController::onBeforeActionGetPublicLink() |
| StorageController::processActionGetPublicLink() |
| StorageController::processActionLock() |
| StorageController::processActionUnlock() |
| StorageController::getAllHeaders() |
| StorageController::getContentRange() |
| StorageController::compareStringVersion($a , $b) |
| StorageController::enableIgnoreQuotaError() |
| StorageController::getVersionFromRequest() |
| StorageController::getPageStateFromRequest() |
| StorageController::ignoreQuotaError() |
| StorageController::appendLastErrorToErrorCollection() |
| StorageController::isQuotaError() |
| StorageController::getUserStorageId() |
| StorageController::getStorageObject(array $extra = array(), $storageId = '') |
| StorageController::getDiskQuotaData() |
| NewDiskStorage::getSnapshot($version = 0, PageState $pageState = null, PageState &$nextPageState = null) |
| NewDiskStorage::setEmptyArray(FixedArray $items) |
| NewDiskStorage::workFromState(PageState $pageState, FixedArray $items, PageState &$newPageState, $internalVersion) |
| NewDiskStorage::runStep($stepName, array $args) |
| NewDiskStorage::getSteps() |
| NewDiskStorage::getStep($stepName) |
| NewDiskStorage::getNextStep($stepName) |
| NewDiskStorage::getStepSlice($startStepName) |
| NewDiskStorage::getSelectableColumnsForObject() |
| NewDiskStorage::snapshotFromPersonalStorage(FixedArray $items, PageState $pageState, $internalVersion, $pageSize = self::SNAPSHOT_PAGE_SIZE) |
| NewDiskStorage::countIdsWithSameSyncDate(FixedArray $items, $syncDateVersion) |
| NewDiskStorage::formatObjectRowToResponse(array $row) |
| NewDiskStorage::formatFolderRowToResponse(array $row) |
| NewDiskStorage::formatFileRowToResponse(array $row) |
| NewDiskStorage::getLockFromRow(array $row, $prefix = self::LOCK_PREFIX_IN_SELECT) |
| NewDiskStorage::snapshotFromLinks(FixedArray $items, PageState $pageState, $internalVersion, $pageSize = self::SNAPSHOT_PAGE_SIZE) |
| NewDiskStorage::snapshotFromLink(TreeNode $link, FixedArray $items, PageState $pageState, $internalVersion, $pageSize = self::SNAPSHOT_PAGE_SIZE) |
| NewDiskStorage::getSymlinkFoldersSortedById() |
| NewDiskStorage::snapshotDeletedElements(FixedArray $items, PageState $pageState, $internalVersion, $pageSize = self::SNAPSHOT_PAGE_SIZE) |
| NewDiskStorage::formatDeletedObjectRowToResponse(array $row) |
| NewDiskStorage::buildSelfTree() |
| NewDiskStorage::buildTreeFromFirstLevelLinks(array $firstLevelLinks) |
| NewDiskStorage::flushTreeCache() |
| NewDiskStorage::loadTree() |
| NewDiskStorage::buildTree() |
| NewDiskStorage::buildTreeRecursiveFromLinks(array $links) |
| NewDiskStorage::buildTreeFromLink(TreeNode $link) |
| NewDiskStorage::isRealObjectExists(TreeNode $node) |
| NewDiskStorage::isTreeNodeExists(array $folderRow) |
| NewDiskStorage::fillTreeData(array $folderRow) |
| NewDiskStorage::getPath($id, $getDirectPathIfPossible = false) |
| NewDiskStorage::getPathByObject(BaseObject $object) |
| NewDiskStorage::checkOpportunityToSkipRights() |
| NewDiskStorage::checkRootNodeReadRights() |
| NewDiskStorage::checkNegativeRightsInSubTree() |
| DiskStorage::__construct($user = null) |
| DiskStorage::getErrors() |
| DiskStorage::clearErrors() |
| DiskStorage::setStorageId($storageId) |
| DiskStorage::getUserStorage() |
| DiskStorage::getStorageClassName() |
| DiskStorage::parseStorageExtra(array $source) |
| DiskStorage::parseElementExtra(array $source) |
| DiskStorage::generateId(array $element) |
| DiskStorage::walkAndBuildTree(Folder $rootFolder) |
| DiskStorage::flushTreeCache() |
| DiskStorage::loadTree() |
| DiskStorage::loadSharedData() |
| DiskStorage::buildSharedData() |
| DiskStorage::isSharedObject($objectId) |
| DiskStorage::loadFormattedFolderTreeAndBreadcrumbs($returnTree = false) |
| DiskStorage::getSnapshot($version = 0, PageState $pageState = null, PageState &$nextPageState = null) |
| DiskStorage::getSnapshotFromLinks(array $folderLinks, $version) |
| DiskStorage::getDeletedElements($version) |
| DiskStorage::filterByVersion(array $items, $version = 0) |
| DiskStorage::getFile($id, array $extra, $skipCheckId = true) |
| DiskStorage::getDirectory($id, array $extra, $skipCheckId = true) |
| DiskStorage::sendFile($file) |
| DiskStorage::addDirectory($name, $parentDirectoryId, array $data = array()) |
| DiskStorage::moveDirectory($name, $targetDirectoryId, $newParentDirectoryId) |
| DiskStorage::moveFile($name, $targetElementId, $newParentDirectoryId) |
| DiskStorage::addFile($name, $targetDirectoryId, TmpFile $tmpFile, array $data = array()) |
| DiskStorage::updateFile($name, $targetElementId, TmpFile $tmpFile, array $data = array()) |
| DiskStorage::processWithLockedFile(File $file, $fileArray, $fileId = null) |
| DiskStorage::deleteFile($fileArray) |
| DiskStorage::belongsToUploaded(File $file) |
| DiskStorage::deleteDirectory($directory) |
| DiskStorage::getVersionDelete($element) |
| DiskStorage::renameDirectory($name, $targetDirectoryId, $parentDirectoryId) |
| DiskStorage::renameFile($name, $targetElementId, $parentDirectoryId) |
| DiskStorage::isUnique($name, $targetDirectoryId, &$opponentId = null) |
| DiskStorage::isCorrectName($name, &$msg) |
| DiskStorage::getPublicLink(array $objectData) |
| DiskStorage::lockFile(array $file) |
| DiskStorage::unlockFile(array $file) |
| DiskStorage::getUser() |
| DiskStorage::getPathByObject(BaseObject $object) |
| DiskStorage::getBreadcrumbs(BaseObject $object) |
| DiskStorage::getUpdateDateTimeFromObject(BaseObject $object) |
| DiskStorage::formatFolderToResponse(Folder $folder) |
| DiskStorage::formatFileToResponse(File $file) |
| DiskStorage::generateTimestamp($date) |
| DiskStorage::convertFromExternalVersion($version) |
| DiskStorage::convertToExternalVersion($version) |
| AbstractStorage::getStorageId() |
| AbstractStorage::setStorageId($storageId) |
| AbstractStorage::getStringStorageId() |
| AbstractStorage::setStorageExtra($storageExtra) |
| AbstractStorage::getStorageExtra() |
| AbstractStorage::compareVersion($a , $b) |
| PageState::__construct($step, array $dataByStep = null) |
| PageState::createFromSignedString($signedData) |
| PageState::__toString() |
| PageState::getStep() |
| PageState::setStep($step) |
| PageState::getCursor() |
| PageState::setCursor($cursor) |
| PageState::hasCursor() |
| PageState::getDataByStep() |
| PageState::setDataByStep(array $dataByStep) |
| PageState::getNextId() |
| PageState::hasNextId() |
| PageState::setNextId($nextId) |
| PageState::getOffset() |
| PageState::setOffset($offset) |
| PageState::reset() |
| PageState::isEqual(PageState $pageState) |
| Folder::getTableClassName() |
| Folder::hasSubFolders() |
| Folder::canAdd(SecurityContext $securityContext) |
| Folder::preloadOperationsForChildren(SecurityContext $securityContext) |
| Folder::preloadOperationsForSpecifiedObjects(array $ids, SecurityContext $securityContext) |
| Folder::add(array $data, ErrorCollection $errorCollection) |
| Folder::load(array $filter, array $with = array()) |
| Folder::getClassNameModel(array $row) |
| Folder::isRoot() |
| Folder::uploadFile($id, array $data = array(), $fileContent = null, array $rights = array(), $generateUniqueName = false) |
| Folder::resolveFileName(array $fileArray, array $data) |
| Folder::addBlankFile(array $data, array $rights = array(), $generateUniqueName = false) |
| Folder::addFile(array $data, array $rights = array(), $generateUniqueName = false) |
| Folder::isDuplicateKeyError(SqlQueryException $exception) |
| Folder::processAdd(array $data, ErrorCollection $errorCollection, $generateUniqueName = false, $countStepsToGenerateName = 0) |
| Folder::addFileLink(File $sourceFile, array $data, array $rights = array(), $generateUniqueName = false) |
| Folder::notifySonetGroup(File $fileModel) |
| Folder::addSubFolder($id, array $data, array $rights = array()) |
| Folder::addSubFolderLink(Folder $sourceFolder, array $data, array $rights = array(), $generateUniqueName = false) |
| Folder::prepareDataForAddLink(BaseObject $object, array $data, $generateUniqueName = false) |
| Folder::copyTo(Folder $targetFolder, $updatedBy, $generateUniqueName = false) |
| Folder::copyToInternal(Folder $targetFolder, $updatedBy, $generateUniqueName = false) |
| Folder::getDescendants(SecurityContext $securityContext, array $parameters = array(), $orderDepthLevel = SORT_ASC) |
| Folder::getChildren($id, array $filter = array(), array $order = array()) |
| Folder::getChild(array $filter, array $with = array()) |
| Folder::countSizeOfVersions(SecurityContext $securityContext = null, array $filter = array()) |
| Folder::countSizeOfFiles(SecurityContext $securityContext = null, array $filter = array()) |
| Folder::countSizeHeadOfVersions(SecurityContext $securityContext = null, array $filter = array()) |
| Folder::markDeleted($deletedBy) |
| Folder::markDeletedNonRecursiveInternal($deletedBy, $deletedType = ObjectTable::DELETED_TYPE_ROOT) |
| Folder::restore($restoredBy) |
| Folder::restoreNonRecursive($restoredBy) |
| Folder::deleteTree($id) |
| Folder::deleteNonRecursive($deletedBy) |
| Folder::getSize($filter = null) |
| Folder::getMapAttributes() |
| SpecificFolder::getName($code) |
| SpecificFolder::getFolder(Storage $storage, $code) |
| SpecificFolder::createFolder(Storage $storage, $code) |
| SpecificFolder::shouldBeUnderUploadedFolder($code) |
| SpecificFolder::getCodes() |
| AttachedObject::getTableClassName() |
| AttachedObject::canRead($userId) |
| AttachedObject::storeDataByObjectId($objectId, $data) |
| AttachedObject::getStoredDataByObjectId($objectId) |
| AttachedObject::canUpdate($userId) |
| AttachedObject::setOperableEntity(array $entityData) |
| AttachedObject::isConfidenceToOperableEntity() |
| AttachedObject::add(array $data, ErrorCollection $errorCollection) |
| AttachedObject::detach() |
| AttachedObject::getCreateTime() |
| AttachedObject::getCreatedBy() |
| AttachedObject::getCreateUser() |
| AttachedObject::getEntityId() |
| AttachedObject::getEntityType() |
| AttachedObject::isEditable() |
| AttachedObject::getAllowEdit() |
| AttachedObject::getAllowAutoComment() |
| AttachedObject::getModuleId() |
| AttachedObject::getObject() |
| AttachedObject::getFile() |
| AttachedObject::getObjectId() |
| AttachedObject::getVersionId() |
| AttachedObject::getVersion() |
| AttachedObject::isSpecificVersion() |
| AttachedObject::getName() |
| AttachedObject::getFileId() |
| AttachedObject::getConnector() |
| AttachedObject::detachByFilter(array $filter) |
| AttachedObject::delete() |
| AttachedObject::disableAutoComment() |
| AttachedObject::enableAutoComment() |
| AttachedObject::getMapAttributes() |
| AttachedObject::getMapReferenceAttributes() |
| AttachedObject::getStubConnector() |
| BaseObject::getTableClassName() |
| BaseObject::canChangeRights(SecurityContext $securityContext) |
| BaseObject::canDelete(SecurityContext $securityContext) |
| BaseObject::canMarkDeleted(SecurityContext $securityContext) |
| BaseObject::canMove(SecurityContext $securityContext, BaseObject $targetObject) |
| BaseObject::canRead(SecurityContext $securityContext) |
| BaseObject::canRename(SecurityContext $securityContext) |
| BaseObject::canRestore(SecurityContext $securityContext) |
| BaseObject::canShare(SecurityContext $securityContext) |
| BaseObject::canUpdate(SecurityContext $securityContext) |
| BaseObject::canUpdateByCloudImport(SecurityContext $securityContext) |
| BaseObject::canLock(SecurityContext $securityContext) |
| BaseObject::canUnlock(SecurityContext $securityContext) |
| BaseObject::getCreateTime() |
| BaseObject::getCreatedBy() |
| BaseObject::getCreateUser() |
| BaseObject::getDeleteTime() |
| BaseObject::getDeletedBy() |
| BaseObject::getDeletedType() |
| BaseObject::getDeleteUser() |
| BaseObject::getRealObject() |
| BaseObject::getRealObjectId() |
| BaseObject::isDeleted() |
| BaseObject::getName() |
| BaseObject::getOriginalName() |
| BaseObject::getNameWithTrashCanSuffix() |
| BaseObject::getNameWithoutTrashCanSuffix() |
| BaseObject::getCode() |
| BaseObject::getXmlId() |
| BaseObject::getParentId() |
| BaseObject::getContentProvider() |
| BaseObject::getStorageId() |
| BaseObject::getStorage() |
| BaseObject::getType() |
| BaseObject::getUpdateTime() |
| BaseObject::getSyncUpdateTime() |
| BaseObject::getUpdatedBy() |
| BaseObject::getUpdateUser() |
| BaseObject::addExternalLink(array $data) |
| BaseObject::getExternalLinks(array $parameters = array()) |
| BaseObject::isLink() |
| BaseObject::getLastCloudImportEntry() |
| BaseObject::renameInternal($newName, $generateUniqueName = false) |
| BaseObject::rename($id, $newName) |
| BaseObject::changeParentUpdateTime(DateTime $datetime = null, $updatedBy = null) |
| BaseObject::changeSelfUpdateTime(DateTime $datetime = null) |
| BaseObject::changeXmlId($newXmlId) |
| BaseObject::changeCode($newCode) |
| BaseObject::moveTo($id, $targetFolderId) |
| BaseObject::moveInSameStorage(Folder $folder, $movedBy) |
| BaseObject::moveInAnotherStorage(Folder $targetFolder, $movedBy) |
| BaseObject::buildFromArray(array $attributes, array &$aliases = null) |
| BaseObject::buildFromResult(Result $result) |
| BaseObject::getClassNameModel(array $row) |
| BaseObject::load(array $filter, array $with = array()) |
| BaseObject::restoreByLinkObject($restoredBy) |
| BaseObject::markDeletedInternal($deletedBy, $deletedType = ObjectTable::DELETED_TYPE_ROOT) |
| BaseObject::createLinkInTrashcan($deletedBy) |
| BaseObject::restoreInternal($restoredBy) |
| BaseObject::recalculateDeletedTypeAfterRestore($restoredBy) |
| BaseObject::getParents(SecurityContext $securityContext, array $parameters = array(), $orderDepthLevel = SORT_ASC) |
| BaseObject::getParent() |
| BaseObject::isRoot() |
| BaseObject::isUniqueName($name, $underObjectId, $excludeId = null, &$opponentId = null) |
| BaseObject::generateUniqueName($potentialName, $underObjectId) |
| BaseObject::generateFallbackName($mainPartName, $suffix) |
| BaseObject::getNextGeneratedName($mainPartName, $suffix, $underObjectId, $withoutLike = false) |
| BaseObject::updateLinksAttributes(array $attr) |
| BaseObject::getSharingsAsReal() |
| BaseObject::getSharingsAsLink() |
| BaseObject::getMembersOfSharing() |
| BaseObject::getTtl() |
| BaseObject::setTtl($ttl) |
| BaseObject::getMapAttributes() |
| BaseObject::getMapReferenceAttributes() |
| BaseObject::jsonSerialize() |
| Banner::isActive($name) |
| Banner::deactivate($name) |
| ObjectLock::getTableClassName() |
| ObjectLock::getCreateTime() |
| ObjectLock::getCreatedBy() |
| ObjectLock::getCreateUser() |
| ObjectLock::getObject() |
| ObjectLock::getObjectId() |
| ObjectLock::getToken() |
| ObjectLock::getExpiryTime() |
| ObjectLock::getType() |
| ObjectLock::isExclusive() |
| ObjectLock::delete($deletedBy) |
| ObjectLock::generateLockToken() |
| ObjectLock::canUnlock($userId) |
| ObjectLock::getMapAttributes() |
| ObjectLock::getMapReferenceAttributes() |
| ExternalLink::getTableClassName() |
| ExternalLink::getCreateTime() |
| ExternalLink::getCreateUser() |
| ExternalLink::getCreatedBy() |
| ExternalLink::getDeathTime() |
| ExternalLink::getDescription() |
| ExternalLink::getDownloadCount() |
| ExternalLink::getHash() |
| ExternalLink::getObjectId() |
| ExternalLink::getVersionId() |
| ExternalLink::getVersion() |
| ExternalLink::getFile() |
| ExternalLink::getFolder() |
| ExternalLink::getObject() |
| ExternalLink::getPassword() |
| ExternalLink::hasPassword() |
| ExternalLink::hasDeathTime() |
| ExternalLink::getSalt() |
| ExternalLink::getType() |
| ExternalLink::isAutomatic() |
| ExternalLink::isSpecificVersion() |
| ExternalLink::isImage() |
| ExternalLink::getMapAttributes() |
| ExternalLink::getMapReferenceAttributes() |
| ExternalLink::add(array $data, ErrorCollection $errorCollection) |
| ExternalLink::generatePasswordAndSalt($password) |
| ExternalLink::hashPassword($password, $salt) |
| ExternalLink::checkPassword($password) |
| ExternalLink::isExpired() |
| ExternalLink::incrementDownloadCount() |
| ExternalLink::revokeDeathTime() |
| ExternalLink::revokePassword() |
| ExternalLink::changeDeathTime(DateTime $dateTime) |
| ExternalLink::changePassword($newPassword) |
| ExternalLink::removeExpiredWithTypeAuto() |
| ExternalLink::delete() |
| ExternalLink::deleteShortUri($uri) |
| Driver::__construct() |
| Driver::__clone() |
| Driver::getInstance() |
| Driver::isSuccessfullyConverted() |
| Driver::addStorage(array $data, array $rights = array()) |
| Driver::addStorageIfNotExist(array $data, array $rights = array()) |
| Driver::addUserStorage($userId) |
| Driver::addGroupStorage($groupId) |
| Driver::addCommonStorage(array $data, array $rights) |
| Driver::addRestAppStorage(array $data) |
| Driver::getStorageByUserId($userId) |
| Driver::getStorageByGroupId($groupId) |
| Driver::getStorageByCommonId($commonId) |
| Driver::getStorageByRestApp($appId) |
| Driver::getFakeSecurityContext() |
| Driver::getRightsManager() |
| Driver::getUrlManager() |
| Driver::getUserFieldManager() |
| Driver::getIndexManager() |
| Driver::getRecentlyUsedManager() |
| Driver::getDocumentHandlersManager() |
| Driver::getSubscriberManager() |
| Driver::getDeletedLogManager() |
| Driver::getRestManager() |
| Driver::getExternalLinkAccessControl() |
| Driver::getErrors() |
| Driver::getErrorsByCode($code) |
| Driver::getErrorByCode($code) |
| Driver::sendNotify($toUserId, array $dataNotify) |
| Driver::sendChangeStatusToSubscribers(BaseObject $object, $way = 'old') |
| Driver::collectSubscribers(BaseObject $object) |
| Driver::cleanCacheTreeBitrixDisk(array $storageIds) |
| Driver::sendChangeStatus($userIds, $debug = '') |
| Driver::sendEvent($userIds, $command, array $data = array()) |
| Driver::checkRequiredInputParams(array $inputParams, array $required) |
| RightsManager::__construct() |
| RightsManager::set(BaseObject $object, array $rights) |
| RightsManager::setAsNewLeaf(BaseObject $object, array $rights) |
| RightsManager::validateNegativeRights(BaseObject $object, array $rights) |
| RightsManager::setAfterMove(BaseObject $object) |
| RightsManager::cleanWrongNegativeRights(BaseObject $object, array $rights) |
| RightsManager::getSpecificRights(BaseObject $object) |
| RightsManager::getAllListNormalizeRights(BaseObject $object) |
| RightsManager::getAllListNormalizeRightsForUserId(BaseObject $object, $userId) |
| RightsManager::delete(BaseObject $object) |
| RightsManager::deleteByDomain(BaseObject $object, $domain) |
| RightsManager::append(BaseObject $object, array $rights) |
| RightsManager::revokeByAccessCodes(BaseObject $object, array $accessCodes) |
| RightsManager::resetSimpleRights(BaseObject $object) |
| RightsManager::isEqual(array $right1, array $right2) |
| RightsManager::isOpposite(array $right1, array $right2) |
| RightsManager::uniqualizeRightsOnObject(array $rights) |
| RightsManager::deleteInternal(BaseObject $object, $domain = null) |
| RightsManager::generateDomain($domain, $id) |
| RightsManager::getSharingDomain($id) |
| RightsManager::getIdBySharingDomain($domain) |
| RightsManager::getBizProcDomain($id) |
| RightsManager::getErrors() |
| RightsManager::getErrorsByCode($code) |
| RightsManager::getErrorByCode($code) |
| RightsManager::getOperationsByTask($taskId) |
| RightsManager::containsOperationInTask($operationName, $taskId) |
| RightsManager::listOperations() |
| RightsManager::getParentsRights($objectId) |
| RightsManager::getDescendantsRights($objectId) |
| RightsManager::getChildrenRights($objectId) |
| RightsManager::getUserOperationsByObject($objectId, $userId) |
| RightsManager::getUserOperationsForChildren($parentId, $userId, array $restrictIds = []) |
| RightsManager::appendChildRightsForChildren($parentId, $userId, array $restrictIds, array &$rightsByObjectId) |
| RightsManager::appendChildRightsForConnectedChildren($parentId, $userId, array $restrictIds, &$rightsByObjectId) |
| RightsManager::appendChildCrRightsForChildren($parentId, $userId, array $restrictIds, &$rightsByObjectId) |
| RightsManager::getTasks() |
| RightsManager::isValidTaskName($taskName) |
| RightsManager::getTaskById($taskId) |
| RightsManager::getTaskIdByName($name) |
| RightsManager::getTaskNameById($taskId) |
| RightsManager::getTaskTitleByName($name) |
| RightsManager::pseudoCompareTaskName($taskName1, $taskName2) |
| RightsManager::getPseudoMaxTaskByObjectForUser(BaseObject $object, $userId) |
| RightsManager::loadAccessTasks() |
| RightsManager::insertRightsInternal(BaseObject $object, array $rights) |
| RightsManager::checkUseInternalsRightsOnStorage(BaseObject $object, $rights) |
| RightsManager::reformatRightsToOperations(array $rights) |
| RightsManager::getUserRightsByObject($objectId, $userId) |
| RightsManager::addRightsCheck(Security\SecurityContext $securityContext, array $parameters, array $specificColumns) |
| SimpleReBuilder::__construct(BaseObject $object, array $specificRights) |
| SimpleReBuilder::run() |
| SimpleReBuilder::runAsNewLeaf() |
| SimpleReBuilder::finalize() |
| SimpleReBuilder::runByOnceObject() |
| SimpleReBuilder::uniqualizeSimpleRights(array $rights) |
| SimpleReBuilder::getParentRights() |
| SimpleReBuilder::getNewSimpleRight(array $specificRights, array $parentRights, array $parentSimpleRights) |
| SimpleReBuilder::getSimpleRightsFromParent() |
| SimpleReBuilder::splitRightsByReadable(array $specificRights) |
| SimpleReBuilder::fillChildren() |
| RightsSetter::__construct(BaseObject $object, array $rights) |
| RightsSetter::run() |
| RightsSetter::appendOne(array $right) |
| RightsSetter::isEqual(array $right1, array $right2) |
| RightsSetter::isOpposite(array $right1, array $right2) |
| RightsSetter::appendOnePositive(array $right, $hadOppositeRight = false) |
| RightsSetter::removeDuplicates($parentObjectId) |
| RightsSetter::hasAlreadySimpleRight($accessCode) |
| RightsSetter::getConflictRightsInSubTree($accessCode, $taskId) |
| RightsSetter::splitNegativeAndPositive(array $rights) |
| RightsSetter::appendOneNegative(array $right, $hadOppositeRight = false) |
| RightsSetter::deleteOnePositive(array $right) |
| RightsSetter::deleteOneNegative(array $right) |
| RightsSetter::updateOnePositive(array $oldRight, array $newRight) |
| RightsSetter::getCurrentRightsOnObject() |
| RightsSetter::getParentRights() |
| RightsSetter::validateNegaviteRight(array $potentialRight) |
| RightsSetter::getErrors() |
| RightsSetter::getErrorsByCode($code) |
| RightsSetter::getErrorByCode($code) |
| SimpleRightBuilder::__construct($objectId) |
| SimpleRightBuilder::run() |
| SimpleRightBuilder::workWithNegativeNodes() |
| SimpleRightBuilder::deleteSimpleRightFromSubTree($objectId, $accessCode) |
| SimpleRightBuilder::getConflictRightsInSubTree($objectId, $accessCode) |
| SimpleRightBuilder::cleanTree() |
| SimpleRightBuilder::fillTree() |
| SimpleRightBuilder::getTasksWithOperationRead() |
| SimpleRightBuilder::hasAllTasksWithOperationRead() |
| DataSetOfRights::filterByTaskId($taskId) |
| DataSetOfRights::filterByAccessCode($accessCode) |
| DataSetOfRights::filterNegative() |
| DataSetOfRights::filterPositive() |
| File::getTableClassName() |
| File::canStartBizProc(SecurityContext $securityContext) |
| File::add(array $data, ErrorCollection $errorCollection) |
| File::load(array $filter, array $with = array()) |
| File::getClassNameModel(array $row) |
| File::getExtension() |
| File::getExternalHash() |
| File::getEtag() |
| File::changeEtag($etag) |
| File::getGlobalContentVersion() |
| File::getFileId() |
| File::getFile() |
| File::getPreviewId() |
| File::changePreviewId($fileId) |
| File::getViewId() |
| File::changeViewId($fileId) |
| File::deleteViewId() |
| File::getSize($filter = null) |
| File::getTypeFile() |
| File::rename($newName) |
| File::copyTo(Folder $targetFolder, $updatedBy, $generateUniqueName = false) |
| File::increaseGlobalContentVersion() |
| File::getLock() |
| File::lock($lockedBy, $token = null, array $data = array()) |
| File::unlock($unlockedBy, $token = null) |
| File::updateContent(array $file, $updatedBy) |
| File::addVersion(array $file, $createdBy, $disableJoin = false) |
| File::generateEtag() |
| File::tryToRunBizProcAfterCreate() |
| File::tryToRunBizProcAfterEdit() |
| File::commentAttachedObjects(Version $version) |
| File::cleanVersionsOverLimit($createdBy) |
| File::joinVersion() |
| File::isNeedToJoinVersion($createdBy) |
| File::resetHeadVersionToAttachedObject(Version $version) |
| File::getTextForComment(User $createUser) |
| File::uploadVersion($id, $fileContent) |
| File::getVersion($versionId) |
| File::getLastVersion() |
| File::getVersions($id, array $filter = array()) |
| File::restoreFromVersion($id, $versionId) |
| File::moveTo(Folder $folder, $movedBy, $generateUniqueName = false) |
| File::moveToAnotherFolder(Folder $folder, $movedBy, $generateUniqueName = false) |
| File::markDeleted($deletedBy) |
| File::markDeletedInternal($deletedBy, $deletedType = ObjectTable::DELETED_TYPE_ROOT) |
| File::restore($restoredBy) |
| File::delete($id) |
| File::getCurrentState() |
| File::getHistoricalData() |
| File::getAttachedObjects(array $parameters = array()) |
| File::countAttachedObjects() |
| File::restoreFromHistoricalData(array $data) |
| File::updateLinksAttributes(array $attr) |
| File::getMapAttributes() |
| File::getView() |
| File::jsonSerialize() |
| BlogPostConnector::isAnonymousAllowed() |
| BlogPostConnector::createFromBlogPostCommentConnector(BlogPostCommentConnector $blogPostCommentConnector) |
| BlogPostConnector::getDataToShow() |
| BlogPostConnector::addComment($authorId, array $data) |
| BlogPostConnector::canRead($userId) |
| BlogPostConnector::canUpdate($userId) |
| BlogPostConnector::canConfidenceReadInOperableEntity() |
| BlogPostConnector::canConfidenceUpdateInOperableEntity() |
| BlogPostConnector::loadBlogPostData() |
| BlogPostConnector::loadBlogPostDataByCommentId($commentId) |
| BlogPostConnector::getDestinations() |
| BlogPostConnector::clearCacheByObjectId($id) |
| StubConnector::getDataToShow() |
| StubConnector::addComment($authorId, array $data) |
| StubConnector::canRead($userId) |
| StubConnector::canUpdate($userId) |
| StubConnector::setAttachedObject(AttachedObject $attachedObject) |
| StubConnector::getAttachedObject() |
| StubConnector::isSetAttachedObject() |
| FileUserType::getUserTypeDescription() |
| FileUserType::getDBColumnType($userField) |
| FileUserType::prepareSettings($userField) |
| FileUserType::getSettingsHTML($userField = false, $htmlControl, $varsFromForm) |
| FileUserType::getEditFormHTML($userField, $htmlControl) |
| FileUserType::getFilterHTML($userField, $htmlControl) |
| FileUserType::getAdminListViewHTML($userField, $htmlControl) |
| FileUserType::getAdminListEditHTML($userField, $htmlControl) |
| FileUserType::getAdminListEditHTMLMulty($userField, $htmlControl) |
| FileUserType::onSearchIndex($userField) |
| FileUserType::onBeforeSaveAll($userField, $values, $userId = false) |
| FileUserType::onBeforeSave($userField, $value, $userId = false) |
| FileUserType::onDelete($userField, $value) |
| FileUserType::getPublicViewHTML($userField, $id, $params = "", $settings = array(), $matches) |
| FileUserType::detectType($value) |
| FileUserType::checkFields($userField, $value, $userId = false) |
| FileUserType::getFileById($id) |
| FileUserType::isLoadedFile($id) |
| FileUserType::getActivityUserId() |
| FileUserType::setValueForAllowEdit($entity, $value) |
| FileUserType::getValueForAllowEdit(array $userField) |
| FileUserType::getItemsInfo($itemsList) |
| ForumMessageConnector::getDataToShow($userId = 0) |
| ForumMessageConnector::getDataToCheck($messageId) |
| ForumMessageConnector::canAccess($userId, $codes) |
| ForumMessageConnector::canRead($userId) |
| ForumMessageConnector::canUpdate($userId) |
| ForumMessageConnector::addComment($authorId, array $data) |
| CalendarEventConnector::canRead($userId) |
| CalendarEventConnector::canUpdate($userId) |
| CalendarEventConnector::canConfidenceReadInOperableEntity() |
| CalendarEventConnector::canConfidenceUpdateInOperableEntity() |
| CalendarEventConnector::getDataToShow() |
| CrmConnector::getMembers($members) |
| CrmMessageConnector::getDataToShow() |
| CrmMessageCommentConnector::__construct($entityId, $logId) |
| CrmMessageCommentConnector::getDataToShow() |
| CrmDealConnector::getDataToShow() |
| CrmLeadConnector::getDataToShow() |
| CrmCompanyConnector::getDataToShow() |
| CrmContactConnector::getDataToShow() |
| VersionUserType::getUserTypeDescription() |
| VersionUserType::getDBColumnType($userField) |
| VersionUserType::prepareSettings($userField) |
| VersionUserType::getSettingsHTML($userField = false, $htmlControl, $varsFromForm) |
| VersionUserType::getEditFormHTML($userField, $htmlControl) |
| VersionUserType::getFilterHTML($userField, $htmlControl) |
| VersionUserType::getAdminListViewHTML($userField, $htmlControl) |
| VersionUserType::getAdminListEditHTML($userField, $htmlControl) |
| VersionUserType::getAdminListEditHTMLMulty($userField, $htmlControl) |
| VersionUserType::onSearchIndex($userField) |
| VersionUserType::onBeforeSave($userField, $value, $userId = false) |
| VersionUserType::onDelete($userField, $value) |
| VersionUserType::getPublicViewHTML($userField, $id, $params = "", $settings = array()) |
| VersionUserType::detectType($value) |
| VersionUserType::checkFields($userField, $value, $userId = false) |
| VersionUserType::getVersionById($id) |
| VersionUserType::getAttachedObjectById($id) |
| VersionUserType::getActivityUserId() |
| IblockWorkflowConnector::canRead($userId) |
| IblockWorkflowConnector::canUpdate($userId) |
| BlogPostCommentConnector::canRead($userId) |
| BlogPostCommentConnector::canUpdate($userId) |
| BlogPostCommentConnector::canConfidenceReadInOperableEntity() |
| BlogPostCommentConnector::canConfidenceUpdateInOperableEntity() |
| BlogPostCommentConnector::getDataToShow() |
| BlogPostCommentConnector::addComment($authorId, array $data) |
| BlogPostCommentConnector::clearCacheByObjectId($id) |
| UserFieldManager::__construct() |
| UserFieldManager::getFieldsForObject(BaseObject $object) |
| UserFieldManager::getConnectorDataByEntityType($entityType) |
| UserFieldManager::getConnectors() |
| UserFieldManager::getDefaultConnectors() |
| UserFieldManager::getInputNameForAllowEditByEntityType($entityType) |
| UserFieldManager::belongsToEntity(AttachedObject $attachedObject, $entityType, $entityId) |
| UserFieldManager::getAdditionalConnectors() |
| UserFieldManager::getAdditionalConnector($entityType) |
| UserFieldManager::buildAdditionalConnectorList() |
| UserFieldManager::showEdit(&$params, &$result, $component = null) |
| UserFieldManager::showView(&$params, &$result, $component = null) |
| UserFieldManager::showViewVersion(&$params, &$result, $component = null) |
| UserFieldManager::getShowTemplate($params, $possibleTemplates) |
| UserFieldManager::getUfEntityName(BaseObject $object) |
| UserFieldManager::loadBatchAttachedObject(array $ids) |
| UserFieldManager::getAttachedObjectByEntity($entity, $entityId, $fieldName) |
| UserFieldManager::loadBatchAttachedObjectInBlogPost(array $blogPostIds) |
| UserFieldManager::isLoadedAttachedObject($id) |
| UserFieldManager::getAttachedObjectById($id) |
| UserFieldManager::getErrors() |
| UserFieldManager::getErrorsByCode($code) |
| UserFieldManager::getErrorByCode($code) |
| UserFieldManager::cloneUfValuesFromAttachedObject(array $attachedIds, $userId) |
| Controller::getUserGroupWithStorage() |
| Controller::getCommonStorages() |
| Controller::getSecurityContextByUser($user) |
| Controller::processActionReloadAttachedObject() |
| Controller::processActionStartUpload() |
| Controller::processActionUploadChunk() |
| Controller::processActionSaveAsNewFile() |
| Controller::processActionUpdateAttachedObject() |
| Controller::listStorages() |
| Controller::listCloudStorages() |
| Controller::processActionOpenDialog() |
| Controller::processActionListStorages() |
| Controller::processActionGetUploadIniSettings() |
| Controller::processActionUploadFileMobileImport($storageId, $folderId = null) |
| Controller::processActionListFolders($storageId, $folderId = null) |
| Controller::processActionGetFolderForSavedFiles() |
| Controller::processActionLoadItems() |
| Controller::getStorageByType($type, $storageId) |
| Controller::listItems(Storage $storage, $path = '/') |
| Controller::listItemsCloud(DocumentHandler $documentHandler, $path = '/') |
| Controller::processActionDownloadArchiveByEntity($signature, $entity, $entityId, $fieldName) |
| Controller::processActionDownloadArchive($signature, array $attachedIds = array()) |
| Controller::processActionDownload($showFile = false) |
| Controller::processActionShow() |
| Controller::processActionShowView() |
| Controller::processActionShowPreview() |
| Controller::processActionShowVersionView() |
| Controller::processActionShowViewHtml($pathToView, $mode = '', $print = '', $preview = '', $sizeType = '', $printUrl = '', $autostart = 'Y', $width = null, $height = null) |
| Controller::processActionTransformOnOpen() |
| Controller::processActionShowTransformationInfo($transformOnOpenUrl = '', $refreshUrl = '', $noError = '') |
| Controller::getAttachedModel() |
| Controller::processActionCopyToMe() |
| Controller::processActionHandleFile($hash, &$file, &$package, &$upload, &$error) |
| Controller::processActionUploadFile() |
| Controller::processActionDownloadFile() |
| Controller::processActionDeleteFile($attachedId) |
| Controller::processActionSearchFile($entityType, $entityId, $searchQuery) |
| Controller::searchObjects($entityType, $entityId, $searchQuery, $limit = 40) |
| Controller::processActionMoveUploadedFile() |
| Controller::processActionRenameFile() |
| Controller::processActionDisableAutoCommentToAttachedObject() |
| Controller::processActionEnableAutoCommentToAttachedObject() |
| Controller::processActionGetBreadcrumbs($attachedId) |
| Controller::setAutoCommentToAttachedObject($attachedId, $enable) |
| Controller::sendNeedAuth($authUrl) |
| SonetLogConnector::getDataToShow() |
| SonetLogConnector::addComment($authorId, array $data) |
| SonetLogConnector::canRead($userId) |
| SonetLogConnector::canUpdate($userId) |
| SonetLogConnector::canConfidenceReadInOperableEntity() |
| SonetLogConnector::canConfidenceUpdateInOperableEntity() |
| SonetLogConnector::loadLogEntryData() |
| IblockConnector::canRead($userId) |
| IblockConnector::canUpdate($userId) |
| SonetCommentConnector::getDataToShow() |
| SonetCommentConnector::canRead($userId) |
| SonetCommentConnector::canUpdate($userId) |
| SonetCommentConnector::canConfidenceReadInOperableEntity() |
| SonetCommentConnector::canConfidenceUpdateInOperableEntity() |
| SonetCommentConnector::addComment($authorId, array $data) |
| SonetCommentConnector::loadLogCommentData() |
| Connector::__construct($entityId) |
| Connector::buildFromAttachedObject(AttachedObject $attachedObject) |
| Connector::className() |
| Connector::getDataToShow() |
| Connector::addComment($authorId, array $data) |
| Connector::isAnonymousAllowed() |
| Connector::canRead($userId) |
| Connector::canUpdate($userId) |
| Connector::canConfidenceReadInOperableEntity() |
| Connector::canConfidenceUpdateInOperableEntity() |
| Connector::getPathToUser() |
| Connector::getPathToGroup() |
| Connector::setPathToUser($path) |
| Connector::setPathToGroup($path) |
| Connector::getApplication() |
| Connector::getUser() |
| IblockElementConnector::canRead($userId) |
| IblockElementConnector::canUpdate($userId) |
| IblockElementConnector::getDataToShow() |
| FolderLink::setAttributes(array $attributes, array &$aliases = null) |
| FolderLink::canAdd(SecurityContext $securityContext) |
| FolderLink::canChangeRights(SecurityContext $securityContext) |
| FolderLink::canRead(SecurityContext $securityContext) |
| FolderLink::canShare(SecurityContext $securityContext) |
| FolderLink::preloadOperationsForChildren(SecurityContext $securityContext) |
| FolderLink::getErrors() |
| FolderLink::getErrorsByCode($code) |
| FolderLink::getErrorByCode($code) |
| FolderLink::getRealObject() |
| FolderLink::uploadFile(array $fileArray, array $data, array $rights = array(), $generateUniqueName = false) |
| FolderLink::addFile(array $data, array $rights = array(), $generateUniqueName = false) |
| FolderLink::addFileLink(File $sourceFile, array $data, array $rights = array(), $generateUniqueName = false) |
| FolderLink::addSubFolder(array $data, array $rights = array(), $generateUniqueName = false) |
| FolderLink::addSubFolderLink(Folder $sourceFolder, array $data, array $rights = array(), $generateUniqueName = false) |
| FolderLink::copyTo(Folder $targetFolder, $updatedBy, $generateUniqueName = false) |
| FolderLink::copyToInternal(Folder $targetFolder, $updatedBy, $generateUniqueName = false) |
| FolderLink::getDescendants(SecurityContext $securityContext, array $parameters = array() |
| FolderLink::getChildren(SecurityContext $securityContext, array $parameters = array()) |
| FolderLink::deleteTree($deletedBy) |
| FolderLink::markDeleted($deletedBy) |
| FolderLink::restore($restoredBy) |
| FolderLink::onModelSynchronize(array $attributes) |
| FolderLink::__destruct() |
| User::getTableClassName() |
| User::loadById($id, array $with = array()) |
| User::buildFromArray(array $attributes, array &$aliases = null) |
| User::buildFromResult(Result $result) |
| User::getActive() |
| User::getEmail() |
| User::getId() |
| User::getLastName() |
| User::getLid() |
| User::getLogin() |
| User::getName() |
| User::getPersonalGender() |
| User::getPersonalPhoto() |
| User::getSecondName() |
| User::getWorkPosition() |
| User::getMapAttributes() |
| User::getFieldsForSelect() |
| User::isEmptyName() |
| User::getFormattedName() |
| User::isIntranetUser() |
| User::isExtranetUser() |
| User::isExternalAuthEmail() |
| User::isCrmEmail() |
| User::getAvatarSrc($width = 58, $height = 58) |
| User::getDetailUrl() |
| User::isAdmin() |
| User::isCurrentUserAdmin() |
| User::resolveUserId($user) |
| User::getModelForReferenceField($userId, User $currentFieldValue = null) |
| ShowSession::getTableClassName() |
| ShowSession::getCreateTime() |
| ShowSession::getEtag() |
| ShowSession::getObject() |
| ShowSession::getObjectId() |
| ShowSession::getVersionId() |
| ShowSession::getVersion() |
| ShowSession::getOwner() |
| ShowSession::getOwnerId() |
| ShowSession::getService() |
| ShowSession::getServiceFileId() |
| ShowSession::getServiceFileLink() |
| ShowSession::getUser() |
| ShowSession::getUserId() |
| ShowSession::getMapAttributes() |
| ShowSession::getMapReferenceAttributes() |
| ShowSession::register(Document\DocumentHandler $handler, Document\FileData $fileData, ErrorCollection $errorCollection) |
| ShowSession::delete() |
| SimpleRight::getAccessCode() |
| SimpleRight::getObjectId() |
| SimpleRight::getMapAttributes() |
| BizProcDocument::className() |
| BizProcDocument::generateDocumentType($storageId) |
| BizProcDocument::generateDocumentComplexType($storageId) |
| BizProcDocument::getDocumentComplexId($documentId) |
| BizProcDocument::getStorageIdByType($documentType) |
| BizProcDocument::getDocumentAdminPage($documentId) |
| BizProcDocument::getFieldNameForUfField(array $userFieldData) |
| BizProcDocument::getDocument($documentId) |
| BizProcDocument::getDocumentName($documentId) |
| BizProcDocument::getUserTypeFields($storageId) |
| BizProcDocument::getDocumentFields($documentType) |
| BizProcDocument::getDocumentType($documentId) |
| BizProcDocument::getDocumentFieldTypes($documentType) |
| BizProcDocument::addDocumentField($documentType, $fields) |
| BizProcDocument::updateDocument($documentId, $fields) |
| BizProcDocument::createDocument($parentDocumentId, $fields) |
| BizProcDocument::lockDocument($documentId, $workflowId) |
| BizProcDocument::unlockDocument($documentId, $workflowId) |
| BizProcDocument::isDocumentLocked($documentId, $workflowId) |
| BizProcDocument::getDocumentForHistory($documentId, $historyIndex, $update = false) |
| BizProcDocument::canUserOperateDocument($operation, $userId, $documentId, $parameters = array()) |
| BizProcDocument::canUserOperateDocumentType($operation, $userId, $documentType, $parameters = array()) |
| BizProcDocument::deleteDocument($documentId) |
| BizProcDocument::publishDocument($documentId) |
| BizProcDocument::unPublishDocument($documentId) |
| BizProcDocument::getAllowableUserGroups($documentType) |
| BizProcDocument::getUsersFromUserGroup($group, $documentId) |
| BizProcDocument::setPermissions($documentId, $workflowId, $permissions, $rewrite = true) |
| BizProcDocument::getJSFunctionsForFields($documentType, $objectName, $documentFields = array(), $documentFieldTypes = array()) |
| BizProcDocument::getFieldInputControl($documentType, $fieldType, $fieldName, $fieldValue, $allowSelection = false, $publicMode = false) |
| BizProcDocument::getFieldInputValue($documentType, $fieldType, $fieldName, $request, &$errors) |
| BizProcDocument::getFieldInputValuePrintable($documentType, $fieldType, $fieldValue) |
| BizProcDocument::getFieldInputControlOptions($documentType, &$fieldType, $functionNameJs, &$value) |
| BizProcDocument::getTaskServiceList($taskId, $userId) |
| BizProcDocument::runAfterEdit($storageId, $fileId) |
| BizProcDocument::runAfterCreate($storageId, $fileId) |
| BizProcDocument::runAfterEditWithInputParameters($storageId, $fileId, $workflowParameters) |
| BizProcDocument::runAfterCreateWithInputParameters($storageId, $fileId, $workflowParameters) |
| BizProcDocument::startAutoBizProc($storageId, $fileId, $autoExecuteType, array $workflowParameters = array()) |
| BizProcDocument::getAllowableOperations() |
| BizProcDocument::deleteWorkflowsFile($fileId) |
| BizProcDocument::getEntityName($entityId) |
| BizProcDocument::getDocumentTypeName($documentType) |
| BizProcDocument::getPrefixForCustomType() |
| Desktop::isDesktopDiskInstall() |
| Desktop::isDesktopDiskOnline() |
| Desktop::enableInVersion($version) |
| Desktop::isDesktopInstall() |
| Desktop::isDesktopImOnline() |
| Desktop::setDesktopDiskInstalled() |
| Desktop::setDesktopDiskUninstalled() |
| Desktop::getDiskVersion($strictDisk = false) |
| Desktop::getApiDiskVersion() |
| FileDeleted::measure($collectData = array(self::DISK_FILE, self::PREVIEW_FILE)) |
| FileDeleted::getMeasurementResult($collectedData = array(self::DISK_FILE, self::PREVIEW_FILE, self::ATTACHED_OBJECT, self::EXTERNAL_LINK, self::UNNECESSARY_VERSION)) |
| instanceTimer() |
| startTimer() |
| checkTimeEnd() |
| hasTimeLimitReached() |
| setTimeLimit($timeLimit) |
| getTimeLimit() |
| Bfile::measure($collectData = array()) |
| Bfile::getTitle(Volume\Fragment $fragment) |
| Storage::getMeasureStages() |
| Storage::measure($collectData = array(self::DISK_FILE, self::PREVIEW_FILE, self::UNNECESSARY_VERSION)) |
| Storage::recalculatePercent($totalSizeIndicator = '\\Bitrix\\Disk\\Volume\\Module\\Disk', $excludeSizeIndicator = '') |
| Storage::getMeasurementResult($collectedData = array()) |
| Storage::getTitle(Volume\Fragment $fragment) |
| Storage::getUrl(Volume\Fragment $fragment) |
| Storage::getAvailableSpace(\Bitrix\Disk\Storage $storage = null) |
| Group::getEntityType() |
| Group::measure($collectData = array(self::DISK_FILE, self::PREVIEW_FILE, self::UNNECESSARY_VERSION)) |
| Group::getMeasurementResult($collectedData = array()) |
| TrashCan::measure($collectData = array(self::DISK_FILE, self::PREVIEW_FILE)) |
| TrashCan::recalculatePercent($totalSizeIndicator = '\\Bitrix\\Disk\\Volume\\Module\\Disk', $excludeSizeIndicator = null) |
| TrashCan::getUrl(Volume\Fragment $fragment) |
| Common::getEntityType() |
| Common::measure($collectData = array(self::DISK_FILE, self::PREVIEW_FILE, self::UNNECESSARY_VERSION)) |
| Common::getUrl(Volume\Fragment $fragment) |
| User::getEntityType() |
| User::measure($collectData = array(self::DISK_FILE, self::PREVIEW_FILE, self::UNNECESSARY_VERSION)) |
| User::getMeasurementResult($collectedData = array()) |
| Task::fixState() |
| Task::loadTaskById($filterId, $ownerId = \Bitrix\Disk\SystemUser::SYSTEM_USER_ID) |
| Task::hasTaskFinished($subTask) |
| Task::isRunningMode($status, $runningStatus = array(self::TASK_STATUS_WAIT, self::TASK_STATUS_RUNNING)) |
| Task::hasUserCanceled() |
| Task::getIndicator() |
| Task::getIndicatorType() |
| Task::setIndicatorType($indicatorType) |
| Task::getId() |
| Task::getOwnerId() |
| Task::setOwnerId($ownerId) |
| Task::getLastFileId() |
| Task::setLastFileId($lastFileId) |
| Task::getStatus() |
| Task::setStatus($status) |
| Task::getStatusSubTask($subTask) |
| Task::setStatusSubTask($subTask, $status) |
| Task::getParam($code) |
| Task::setParam($code, $value) |
| Task::getDroppedFileCount() |
| Task::getIterationFileCount() |
| Task::setIterationFileCount($iterationFileCount) |
| Task::getLastError() |
| Task::setLastError($errorText) |
| Task::increaseDroppedFileCount($delta = 1) |
| Task::getDroppedVersionCount() |
| Task::increaseDroppedVersionCount($delta = 1) |
| Task::getDroppedFolderCount() |
| Task::increaseDroppedFolderCount($delta = 1) |
| Task::raiseFatalError() |
| Task::hasFatalError() |
| Task::resetFail() |
| Task::getFailCount() |
| Task::increaseFailCount($delta = 1) |
| Task::getCountFilesToDrop() |
| Task::getCountVersionToDrop() |
| Task::collectLogData($object) |
| Task::log($data, $operation) |
| FileType::measure($collectData = array(self::DISK_FILE, self::PREVIEW_FILE)) |
| FileType::getMeasurementResult($collectedData = array()) |
| FileType::purify() |
| FileType::getFragment(array $filter) |
| FileType::getTitle(Volume\Fragment $fragment) |
| Folder::prepareData() |
| Folder::measure($collectData = array(self::DISK_FILE, self::PREVIEW_FILE, self::UNNECESSARY_VERSION)) |
| Folder::recalculatePercent($totalSizeIndicator = '\\Bitrix\\Disk\\Volume\\Storage\\Storage', $excludeSizeIndicator = null) |
| Folder::loadTotals() |
| Folder::purify() |
| Folder::getTitle(Volume\Fragment $fragment) |
| Folder::getUrl(Volume\Fragment $fragment) |
| Folder::getParents(Volume\Fragment $fragment) |
| Folder::getUpdateTime(Volume\Fragment $fragment) |
| Folder::isAllowDeleteFolder(\Bitrix\Disk\Folder $folder) |
| File::measure($collectData = array(self::DISK_FILE, self::PREVIEW_FILE)) |
| File::getMeasurementResult($collectedData = array(self::DISK_FILE, self::PREVIEW_FILE, self::ATTACHED_OBJECT, self::EXTERNAL_LINK, self::UNNECESSARY_VERSION, self::CRM_OBJECT)) |
| File::getFragment(array $filter) |
| File::getTitle(Volume\Fragment $fragment) |
| File::getUpdateTime(Volume\Fragment $fragment) |
| File::getParents(Volume\Fragment $fragment) |
| File::getUrl(Volume\Fragment $fragment) |
| File::getAttachedList(Volume\Fragment $fragment, $userId) |
| Fragment::__construct(array $parameters) |
| Fragment::getTitle() |
| Fragment::getSpecific() |
| Fragment::getIndicatorType() |
| Fragment::getFileSize() |
| Fragment::getFileCount() |
| Fragment::getDiskSize() |
| Fragment::getDiskCount() |
| Fragment::getVersionCount() |
| Fragment::getPreviewSize() |
| Fragment::getPreviewCount() |
| Fragment::getAttachedCount() |
| Fragment::getLinkCount() |
| Fragment::getSharingCount() |
| Fragment::getUnnecessaryVersionSize() |
| Fragment::getUnnecessaryVersionCount() |
| Fragment::getStorageId() |
| Fragment::getStorage() |
| Fragment::getFolderId() |
| Fragment::getFolder() |
| Fragment::getFileId() |
| Fragment::getFile() |
| Fragment::getModuleId() |
| Fragment::getEntityType() |
| Fragment::getEntityId() |
| Timer::__construct($timeLimit = -1) |
| Timer::startTimer($startTimestamp = 0) |
| Timer::checkTimeEnd() |
| Timer::hasTimeLimitReached() |
| Timer::getTimeLimit() |
| Timer::setTimeLimit($timeLimit) |
| Cleaner::__construct($ownerId = \Bitrix\Disk\SystemUser::SYSTEM_USER_ID) |
| Cleaner::instanceTask() |
| Cleaner::loadTask($filterId, $ownerId = \Bitrix\Disk\SystemUser::SYSTEM_USER_ID) |
| Cleaner::agentName($filterId) |
| Cleaner::isCronRun() |
| Cleaner::runWorker($filterId) |
| Cleaner::addWorker($params) |
| Cleaner::canAgentUseCrontab() |
| Cleaner::cancelWorkers($ownerId) |
| Cleaner::countWorker($ownerId) |
| Cleaner::checkRestoreWorkers($ownerId) |
| Cleaner::deleteFileByFilter(Volume\IVolumeIndicator $indicator) |
| Cleaner::deleteTrashcanByFilter(Volume\IVolumeIndicator $indicator) |
| Cleaner::deleteUnnecessaryVersionByFilter(Volume\IVolumeIndicator $indicator) |
| Cleaner::getSecurityContext($user, $object) |
| Cleaner::deleteFile(\Bitrix\Disk\File $file) |
| Cleaner::deleteFileUnnecessaryVersion(\Bitrix\Disk\File $file, $additionalFilter = array()) |
| Cleaner::deleteFolder(\Bitrix\Disk\Folder $folder, $emptyOnly = false) |
| Cleaner::isAllowDeleteFolder(\Bitrix\Disk\Folder $folder) |
| Cleaner::isAllowClearStorage(\Bitrix\Disk\Storage $storage) |
| Cleaner::repeatMeasure(Volume\IVolumeIndicator $indicator) |
| Cleaner::getDroppedFileCount() |
| Cleaner::getDroppedVersionCount() |
| Cleaner::getDroppedFolderCount() |
| Cleaner::getOwnerId() |
| Cleaner::getOwner() |
| Cleaner::collectError($errors, $increaseTaskFail = true, $raiseTaskFatalError = false) |
| Cleaner::getErrors() |
| Cleaner::hasErrors() |
| Cleaner::getErrorsByCode($code) |
| Cleaner::getErrorByCode($code) |
| Cleaner::getProgressInfo($ownerId) |
| Cleaner::setProgressInfo($ownerId, $totalFilesToDrop, $droppedFilesCount = 0, $failCount = 0) |
| Cleaner::clearProgressInfo($ownerId) |
| FolderDeleted::measure($collectData = array(self::DISK_FILE, self::PREVIEW_FILE, self::UNNECESSARY_VERSION)) |
| Base::measure($collectData = array(self::DISK_FILE, self::PREVIEW_FILE)) |
| Base::getMeasureStages() |
| Base::getStage() |
| Base::setStage($stageId) |
| Base::prepareData() |
| Base::getIndicatorId() |
| Base::purify() |
| Base::resetMeasurementResult() |
| Base::getMeasurementResult($collectedData = array()) |
| Base::addFilter($key, $value) |
| Base::getFilterValue($key, $acceptedListModificators = '=<>!@%') |
| Base::getFilter(array $defaultFilter = array(), $entity = null) |
| Base::unsetFilter($key = '') |
| Base::restoreFilter($measurementResult) |
| Base::setFilterId($filterId) |
| Base::getFilterId() |
| Base::addSelect($alias, $statement) |
| Base::getSelect() |
| Base::addGroupBy($alias, $statement) |
| Base::getGroupBy() |
| Base::setOrder($order) |
| Base::getOrder(array $defaultOrder = array()) |
| Base::setLimit($limit) |
| Base::getLimit() |
| Base::setOffset($offset) |
| Base::getOffset() |
| Base::isResultAvailable() |
| Base::getTotalSize() |
| Base::getTotalCount() |
| Base::getDiskSize() |
| Base::getDiskCount() |
| Base::getTotalVersion() |
| Base::getPreviewSize() |
| Base::getPreviewCount() |
| Base::getTotalAttached() |
| Base::getTotalLink() |
| Base::getTotalSharing() |
| Base::getUnnecessaryVersionSize() |
| Base::getUnnecessaryVersionCount() |
| Base::setOwner($ownerId) |
| Base::getOwner() |
| Base::loadTotals() |
| Base::recalculatePercent($totalSizeIndicator = null, $excludeSizeIndicator = null) |
| Base::getCorrespondingFileList($additionalFilter = array()) |
| Base::getCorrespondingFolderList($additionalFilter = array()) |
| Base::getCorrespondingUnnecessaryVersionList($additionalFilter = array()) |
| Base::getFragment(array $filter) |
| Base::getUpdateTime(Volume\Fragment $fragment) |
| Base::listIndicator() |
| Base::listClearConstraint() |
| Base::listDeleteConstraint() |
| Base::loadListIndicator($libraryPath = '') |
| Base::getIndicator($indicatorTypeId) |
| Base::addError(\Bitrix\Main\Error $error) |
| Base::hasErrors() |
| Base::clearErrors() |
| Base::getErrors() |
| Base::getErrorsByCode($code) |
| Base::getErrorByCode($code) |
| Calendar::measure($collectData = array()) |
| Calendar::getEntityList() |
| Calendar::getAttachedEntityList() |
| Socialnetwork::measure($collectData = array()) |
| Socialnetwork::getEntityList() |
| Socialnetwork::getAttachedEntityList() |
| Socialnetwork::getTitle(Volume\Fragment $fragment) |
| Tasks::measure($collectData = array()) |
| Tasks::getEntityList() |
| Tasks::getAttachedEntityList() |
| Faceid::measure($collectData = array()) |
| Mail::getEntityType() |
| Mail::getStorageList() |
| Mail::getFolderList($storage) |
| Mail::measure($collectData = array()) |
| Mail::getUrl(Volume\Fragment $fragment) |
| Crm::getMeasureStages() |
| Crm::measure($collectData = array()) |
| Crm::getStorageList() |
| Crm::getFolderList($storage) |
| Crm::getSpecialFolderXmlId() |
| Crm::getEntityList() |
| Crm::isAllowDeleteFolder(\Bitrix\Disk\Folder $folder) |
| Crm::getMeasurementFolderResult($collectedData = array()) |
| Crm::getFragment(array $filter) |
| Crm::getTitle(Volume\Fragment $fragment) |
| Crm::getUpdateTime(Volume\Fragment $fragment) |
| Crm::getUrl(Volume\Fragment $fragment) |
| Crm::getActivity(Volume\Fragment $fragment) |
| Bizproc::measure($collectData = array()) |
| DiskTrashcan::measure($collectData = array(self::DISK_FILE, self::PREVIEW_FILE)) |
| DiskTrashcan::getTitle(Volume\Fragment $fragment) |
| Webdav::isMeasureAvailable() |
| Webdav::measure($collectData = array()) |
| Webdav::getIblockList() |
| Im::measure($collectData = array()) |
| Im::getStorageList() |
| Im::getFolderList($storage) |
| Im::getSpecialFolderCode() |
| Im::getEntityType() |
| Im::isAllowClearStorage(\Bitrix\Disk\Storage $storage) |
| Im::isAllowDeleteFolder(\Bitrix\Disk\Folder $folder) |
| Im::getMeasurementFolderResult($collectedData = array()) |
| Im::getFragment(array $filter) |
| Im::getTitle(Volume\Fragment $fragment) |
| Im::getUpdateTime(Volume\Fragment $fragment) |
| Im::getUrl(Volume\Fragment $fragment) |
| Lists::isMeasureAvailable() |
| Lists::measure($collectData = array()) |
| Lists::getIblockList() |
| Module::getModuleId() |
| Module::measure($collectData = array(self::DISK_FILE, self::PREVIEW_FILE)) |
| Module::recalculatePercent($totalSizeIndicator = '\\Bitrix\\Disk\\Volume\\Bfile', $excludeSizeIndicator = null) |
| Module::getMeasurementResult($collectedData = array()) |
| Module::loadTotals() |
| Module::getFragment(array $filter) |
| Module::getTitle(Volume\Fragment $fragment) |
| Module::getSpecific(Volume\Fragment $fragment) |
| Module::isMeasureAvailable() |
| Module::getStorageList() |
| Module::getFolderList($storage) |
| Module::getSpecialFolderCode() |
| Module::getSpecialFolderXmlId() |
| Module::getEntityType() |
| Module::getEntityList() |
| Module::getIblockList() |
| Module::getAttachedEntityList() |
| Module::getUserTypeFieldList(N/A) |
| Module::prepareUserFieldQuery($entityClass, array $userField, array $relation = null) |
| Module::prepareUserFieldSourceSql(N/A) |
| Timeman::measure($collectData = array()) |
| Iblock::measure($collectData = array()) |
| Iblock::getEntityList() |
| Voximplant::measure($collectData = array()) |
| Voximplant::getStorageList() |
| Voximplant::getFolderList($storage) |
| Voximplant::getSpecialFolderCode() |
| Voximplant::isAllowDeleteFolder(\Bitrix\Disk\Folder $folder) |
| Voximplant::getMeasurementFolderResult($collectedData = array()) |
| Voximplant::getFragment(array $filter) |
| Voximplant::getTitle(Volume\Fragment $fragment) |
| Voximplant::getUpdateTime(Volume\Fragment $fragment) |
| Voximplant::getUrl(Volume\Fragment $fragment) |
| Disk::getSpecialFolderCode() |
| Subscribe::measure($collectData = array()) |
| QueryHelper::prepareSelect(array $selectFields) |
| QueryHelper::prepareWhere(array $filterFields, array $filterAlias = array()) |
| QueryHelper::prepareGroupBy(array $groupByFields) |
| QueryHelper::prepareOrder(array $orderFields, array $fieldAlias = array()) |
| QueryHelper::prepareInsert(array $columns, array $selectFields = array()) |
| QueryHelper::prepareUpdateOnSelect(array $columns, array $selectFields, $tableAlias = 'dest', $selectAlias = 'src') |
| QueryHelper::prepareFolderTreeQuery($parentId) |
| Sharing::getTableClassName() |
| Sharing::add(array $data, ErrorCollection $errorCollection) |
| Sharing::addToManyEntities(array $data, array $entitiesToTask, ErrorCollection $errorCollection) |
| Sharing::deletePossibleCycleFromEntities(BaseObject $objectToSharing, array $entities) |
| Sharing::cleanCache(array $successSharingByEntity) |
| Sharing::parseEntityValue($entity) |
| Sharing::connectGroupToSelfUserStorage($userId, Storage $storage, ErrorCollection $errorCollection) |
| Sharing::connectObjectToSelfUserStorage($userId, BaseObject $object, ErrorCollection $errorCollection) |
| Sharing::connectStorageToUserStorage($createdBy, $userId, Storage $storage, ErrorCollection $errorCollection) |
| Sharing::connectToUserStorage($userId, array $data, ErrorCollection $errorCollection) |
| Sharing::isConnectedToUserStorage($userId, BaseObject $object, array &$returnData = array()) |
| Sharing::getExisting($userId, BaseObject $object) |
| Sharing::processConnectAndNotify(array $successSharingByEntity, BaseObject $objectToSharing) |
| Sharing::isCanForward() |
| Sharing::getDescription() |
| Sharing::isApproved() |
| Sharing::isDeclined() |
| Sharing::isUnreplied() |
| Sharing::isToUser() |
| Sharing::isToGroup() |
| Sharing::isToDepartment() |
| Sharing::isToDepartmentParent() |
| Sharing::isToDepartmentChild() |
| Sharing::getTaskName() |
| Sharing::getLinkObjectId() |
| Sharing::getParentId() |
| Sharing::getParent() |
| Sharing::getCreatedBy() |
| Sharing::getCreateUser() |
| Sharing::getToEntity() |
| Sharing::getFromEntity() |
| Sharing::getLinkStorageId() |
| Sharing::getLinkStorage() |
| Sharing::getRealStorageId() |
| Sharing::getRealStorage() |
| Sharing::getLinkObject() |
| Sharing::getRealObject() |
| Sharing::getRealObjectId() |
| Sharing::getTargetStorageByToEntity() |
| Sharing::changeTaskName($newTaskName) |
| Sharing::approve(array $data = array()) |
| Sharing::decline($declinedBy, $withDeletingObject = true) |
| Sharing::disprove($disprovedBy, $withDeletingObject = true) |
| Sharing::delete($deletedBy, $withDeletingObject = true) |
| Sharing::deleteInternal() |
| Sharing::isLoadedChildren() |
| Sharing::getChildren() |
| Sharing::getMapAttributes() |
| Sharing::getMapReferenceAttributes() |
| Sharing::onBeforeConfirmNotify($module, $tag, $value, $notify) |
| Sharing::getNotifyTags() |
| Sharing::loadByNotifyTag($tag) |
| Version::getTableClassName() |
| Version::add(array $data, ErrorCollection $errorCollection) |
| Version::getCreateTime() |
| Version::getCreatedBy() |
| Version::getCreateUser() |
| Version::getFileId() |
| Version::getFile() |
| Version::getViewId() |
| Version::changeViewId($fileId) |
| Version::deleteView() |
| Version::getGlobalContentVersion() |
| Version::getObjectCreateTime() |
| Version::getObjectCreatedBy() |
| Version::getObjectUpdateTime() |
| Version::getObjectUpdatedBy() |
| Version::getSize() |
| Version::getMiscData() |
| Version::getUnserializeMiscData() |
| Version::getMiscDataByKey($key) |
| Version::getName() |
| Version::getExtension() |
| Version::getObjectId() |
| Version::getObject() |
| Version::joinData(array $data) |
| Version::isHead() |
| Version::getPrevious() |
| Version::delete($deletedBy) |
| Version::getMapAttributes() |
| Version::getMapReferenceAttributes() |
| Version::getView() |
| Uploader::__construct() |
| Uploader::uploadFileToUserStorage($userId, array $file, $createdBy = null, SecurityContext $securityContext = null) |
| Uploader::uploadBatchFilesToUserStorage($userId, array $files, $createdBy = null, SecurityContext $securityContext = null) |
| Uploader::getErrors() |
| Uploader::getErrorsByCode($code) |
| Uploader::getErrorByCode($code) |
| Video::__construct($name, $fileId, $viewId = null, $previewId = null, $isTransformationEnabledInStorage = true) |
| Video::getViewExtension() |
| Video::isTransformationAllowedInOptions() |
| Video::getMaxSizeTransformation() |
| Video::getJsViewerType() |
| Video::render($params = array()) |
| Video::calculateSizes($originalSizes, $maxSizes, $minSizes = array()) |
| Video::isHtmlAvailable() |
| Video::renderTransformationInProcessMessage($params = []) |
| Video::isJsViewerHideEditButton() |
| Video::getEditorTypeFile() |
| Video::getViewableExtensions() |
| Video::getAlternativeExtensions() |
| Video::getAdditionalViewableExtensions() |
| Video::getJsViewerAdditionalJsonParams() |
| Video::isAlwaysTransformToViewFormat() |
| Video::isNeededLimitRightsOnTransformTime() |
| Video::normalizePaths($params) |
| Video::renderForMobileApp($params) |
| Video::renderForDesktop($params, $autostart, $sizeType) |
| Video::isShowTransformationInfo() |
| Document::getViewExtension() |
| Document::render($params = array()) |
| Document::isTransformationAllowedInOptions() |
| Document::getMaxSizeTransformation() |
| Document::isSaveForVersion() |
| Document::getJsViewerFallbackHtmlAttributeName() |
| Document::getJsViewerType() |
| Document::isHtmlAvailable() |
| Document::isJsViewerHideEditButton() |
| Document::getViewableExtensions() |
| Document::getTransformTime() |
| Base::getData() |
| Base::getPreviewData() |
| Base::getFileData($fileId) |
| Base::getId() |
| Base::isOriginViewable() |
| Base::getViewExtension() |
| Base::getMimeType() |
| Base::getPreviewExtension() |
| Base::getPreviewName() |
| Base::getPreviewMimeType() |
| Base::render($params = array()) |
| Base::isSaveForVersion() |
| Base::getName() |
| Base::getJsViewerFallbackHtmlAttributeName() |
| Base::getJsViewerType() |
| Base::getJsViewerAdditionalJsonParams() |
| Base::isTransformationAllowedInOptions() |
| Base::getMaxSizeTransformation() |
| Base::isTransformationAllowed($size = 0) |
| Base::getJsViewerWidth() |
| Base::getJsViewerHeight() |
| Base::getSize() |
| Base::isHtmlAvailable() |
| Base::renderTransformationInProcessMessage() |
| Base::isTransformationAllowedOnOpen($size = 0) |
| Base::transformOnOpen(File $file) |
| Base::isJsViewerHideEditButton() |
| Base::getEditorTypeFile() |
| Base::getViewableExtensions() |
| Base::getAlternativeExtensions() |
| Base::getExtension() |
| Base::isAlwaysTransformToViewFormat() |
| Base::getTransformTime() |
| Base::isNeededLimitRightsOnTransformTime() |
| Base::isShowTransformationInfo() |
| Base::isLastTransformationFailed() |
| Base::isShowTransformationUpgradeMessage() |
| FocusController::listActions() |
| FocusController::showNotFound() |
| FocusController::processActionShowObjectInGrid($objectId) |
| FocusController::processActionShowObjectInTrashCanGrid($objectId) |
| FocusController::buildUrlToFocus($listingPath, $objectId, $finalPage, Internals\Grid\FolderListOptions $gridOptions) |
| FocusController::findObject($objectId) |
| FocusController::checkReadRights(BaseObject $object) |
| FocusController::getPageWithObject(BaseObject $object, Internals\Grid\FolderListOptions $gridOptions, array $filter) |
| FocusController::processActionOpenFileDetail() |
| FocusController::processActionOpenFolderList() |
| FocusController::processActionOpenTrashcanFileDetail() |
| TypeFile::getListOfValues() |
| TypeFile::getByFile(File $file) |
| TypeFile::getByExtension($extension) |
| TypeFile::getByFilename($filename) |
| TypeFile::getByFlexibleVar($file) |
| TypeFile::isImage($file) |
| TypeFile::isVideo($file) |
| TypeFile::isAudio($file) |
| TypeFile::isDocument($file) |
| TypeFile::isArchive($file) |
| TypeFile::isScript($file) |
| TypeFile::isPdf($file) |
| TypeFile::getExtensionByMimeType($mimeType) |
| TypeFile::getMimeTypeByFilename($filename) |
| TypeFile::getMimeTypeExtensionList() |
| TypeFile::normalizeMimeType($mimeType, $filename) |
| TypeFile::getName($type) |
| TypeFile::reindexTypeFile($startFileId = 0) |
| RecentlyUsedManager::__construct() |
| RecentlyUsedManager::push($user, $objectId) |
| RecentlyUsedManager::fixColdStart($user) |
| RecentlyUsedManager::getFileModelListByUser($user, array $filter = array()) |
| RecentlyUsedManager::getFileListByUser($user, array $filter = array()) |
| RecentlyUsedManager::hasData($userId) |
| RecentlyUsedManager::isFirstRun($userId) |
| RecentlyUsedManager::saveFirstRun($userId) |
| SearchAction::provideData($searchQuery, array $options = null, PageNavigation $pageNavigation = null) |
| SearchAction::buildUriForSearchPresentation(Disk\BaseObject $object) |
| Storage::getPrimaryAutoWiredParameter() |
| Storage::isEnabledSizeLimitRestrictionAction(Disk\Storage $storage) |
| Content::configureActions() |
| Content::uploadAction($filename, $token = null) |
| Content::rollbackUploadAction($token) |
| Content::getStatusAction(Disk\Bitrix24Disk\TmpFile $content) |
| Content::getChunkSizeAction($filename, $size) |
| Content::getContentRange() |
| Content::getTmpFileArrayByInput() |
| DocumentService::configureActions() |
| DocumentService::goToEditAction($serviceCode, $attachedObjectId = null, $objectId = null) |
| DocumentService::goToCreateAction($serviceCode, $typeFile, $attachedObjectId = null, $objectId = null) |
| DocumentService::getAction($serviceCode) |
| DocumentService::loveAction() |
| DocumentService::setStatusWorkWithLocalDocumentAction($uidRequest, $status) |
| TrashCan::getDefaultPreFilters() |
| TrashCan::emptyAction(Disk\Storage $storage) |
| Folder::configureActions() |
| Folder::getPrimaryAutoWiredParameter() |
| Folder::getAction(Disk\Folder $folder) |
| Folder::get(Disk\BaseObject $folder) |
| Folder::renameAction(Disk\Folder $folder, $newName, $autoCorrect = false) |
| Folder::markDeletedAction(Disk\Folder $folder) |
| Folder::deleteTreeAction(Disk\Folder $folder) |
| Folder::restoreAction(Disk\BaseObject $folder) |
| Folder::generateExternalLinkAction(Disk\Folder $folder) |
| Folder::disableExternalLinkAction(Disk\Folder $folder) |
| Folder::getAllowedOperationsRightsAction(Disk\Folder $folder) |
| Folder::downloadArchiveAction(Disk\Folder $folder) |
| AttachedObject::configureActions() |
| AttachedObject::getPrimaryAutoWiredParameter() |
| AttachedObject::getDefaultPreFilters() |
| AttachedObject::copyToMeAction(Disk\AttachedObject $attachedObject) |
| AttachedObject::runPreviewGenerationAction(Disk\AttachedObject $attachedObject) |
| AttachedObject::downloadAction(Disk\AttachedObject $attachedObject) |
| BaseObject::get($id) |
| BaseObject::getDefaultPreFilters() |
| BaseObject::getDefaultPostFilters() |
| BaseObject::deleteFile(Disk\File $file) |
| BaseObject::deleteFolder(Disk\Folder $folder) |
| BaseObject::markDeleted($id) |
| BaseObject::restore($id) |
| BaseObject::move(Disk\BaseObject $object, Disk\Folder $toFolder) |
| BaseObject::generateExternalLink(Disk\BaseObject $object) |
| BaseObject::disableExternalLink(Disk\BaseObject $object) |
| BaseObject::getExternalLink($id) |
| BaseObject::getAllowedOperationsRights(Disk\BaseObject $object) |
| ExternalLink::getPrimaryAutoWiredParameter() |
| ExternalLink::getDefaultPreFilters() |
| ExternalLink::setPasswordAction(Disk\ExternalLink $externalLink, $newPassword) |
| ExternalLink::setDeathTimeAction(Disk\ExternalLink $externalLink, $deathTime) |
| ExternalLink::revokeDeathTimeAction(Disk\ExternalLink $externalLink) |
| ExternalLink::revokePasswordAction(Disk\ExternalLink $externalLink) |
| CommonActions::configureActions() |
| CommonActions::getAction(Disk\BaseObject $object) |
| CommonActions::renameAction(Disk\BaseObject $object, $newName, $autoCorrect = false) |
| CommonActions::moveAction(Disk\BaseObject $object, Disk\Folder $toFolder) |
| CommonActions::markDeletedAction(Disk\BaseObject $object) |
| CommonActions::deleteAction(Disk\BaseObject $object) |
| CommonActions::restoreAction(Disk\BaseObject $object) |
| CommonActions::restoreCollectionAction(Disk\Type\ObjectCollection $objectCollection) |
| CommonActions::generateExternalLinkAction(Disk\BaseObject $object) |
| CommonActions::disableExternalLinkAction(Disk\BaseObject $object) |
| CommonActions::getAllowedOperationsRightsAction(Disk\BaseObject $object) |
| CommonActions::getArchiveLinkAction(Disk\Type\ObjectCollection $objectCollection) |
| CommonActions::downloadArchiveAction(Disk\Type\ObjectCollection $objectCollection) |
| CommonActions::listRecentlyUsedAction() |
| File::configureActions() |
| File::getPrimaryAutoWiredParameter() |
| File::getAction(Disk\File $file) |
| File::get(Disk\BaseObject $file) |
| File::getUriToShowObjectInGrid(Disk\File $file) |
| File::renameAction(Disk\File $file, $newName, $autoCorrect = false) |
| File::createByContentAction(Disk\Folder $folder, $filename, Disk\Bitrix24Disk\TmpFile $content, $generateUniqueName = false) |
| File::showImageAction(Disk\File $file, $width = 0, $height = 0, $exact = null) |
| File::showPreviewAction(Disk\File $file, $width = 0, $height = 0, $exact = null) |
| File::downloadAction(Disk\File $file) |
| File::markDeletedAction(Disk\File $file) |
| File::deleteAction(Disk\File $file) |
| File::restoreAction(Disk\File $file) |
| File::restoreFromVersionAction(Disk\File $file, Disk\Version $version) |
| File::generateExternalLinkAction(Disk\File $file) |
| File::disableExternalLinkAction(Disk\File $file) |
| File::getAllowedOperationsRightsAction(Disk\File $file) |
| File::addSharingAction(Disk\File $file, $entity, $taskName) |
| File::showSharingEntitiesAction(Disk\File $file) |
| File::copyToMeAction(Disk\File $file) |
| File::showPropertiesAction(Disk\File $file) |
| File::runPreviewGenerationAction(Disk\File $file) |
| Sharing::getPrimaryAutoWiredParameter() |
| Sharing::deleteAction(Disk\Sharing $sharing) |
| Sharing::changeTaskNameAction(Disk\Sharing $sharing, $newTaskName) |
| Version::getPrimaryAutoWiredParameter() |
| Version::getDefaultPreFilters() |
| Version::deleteAction(Disk\Version $version) |
| RestManager::__construct() |
| RestManager::getMethods() |
| RestManager::onRestServiceBuildDescription() |
| RestManager::onRestGetModule() |
| RestManager::onRestAppDelete(array $fields) |
| RestManager::getNavData($start, $isOrm = false) |
| RestManager::setNavData($result, $dbRes) |
| RestManager::processMethodRequest(array $params, $start, \CRestServer $restServer) |
| RestManager::createExceptionFromErrors(array $errors) |
| RestManager::checkMethodName($methodName) |
| RestManager::getServiceClassByEntity($entityName) |
| RestManager::buildService(array $params, $start, \CRestServer $restServer) |
| RestManager::className() |
| RestManager::getErrors() |
| RestManager::getErrorsByCode($code) |
| RestManager::getErrorByCode($code) |
| Storage::getDataManagerFields() |
| Storage::getFieldsForShow() |
| Storage::getFieldsForFilter() |
| Storage::getFieldsForMap() |
| Folder::getFieldsForShow() |
| AttachedObject::getDataManagerFields() |
| AttachedObject::getFieldsForShow() |
| AttachedObject::getFieldsForFilter() |
| AttachedObject::getFieldsForMap() |
| BaseObject::getDataManagerFields() |
| BaseObject::getFieldsForShow() |
| BaseObject::getFieldsForFilter() |
| BaseObject::getFieldsForMap() |
| ExternalLink::getDataManagerFields() |
| ExternalLink::getFieldsForShow() |
| ExternalLink::getFieldsForFilter() |
| ExternalLink::getFieldsForMap() |
| Base::getFieldsForMap() |
| Base::getFields() |
| Version::getDataManagerFields() |
| Version::getFieldsForShow() |
| Version::getFieldsForFilter() |
| Version::getFieldsForMap() |
| Externalizer::__construct(Service\Base $service, \CRestServer $restServer) |
| Externalizer::getExternalData($data) |
| Externalizer::convertDateTimeFields($data) |
| Externalizer::toArrayFromModel(Disk\Internals\Model $model) |
| Externalizer::toArray($item) |
| Externalizer::isXml(Disk\File $file) |
| Externalizer::isImage(Disk\File $file) |
| Externalizer::getUriToContent(Disk\File $file) |
| Internalizer::__construct(Entity\Base $entity, Service\Base $service) |
| Internalizer::cleanFilter(array $filter) |
| Storage::getFields() |
| Storage::get($id) |
| Storage::getForApp() |
| Storage::getList(array $filter = array(), array $order = array()) |
| Storage::getSecurityContextByUser($user) |
| Storage::getTypes() |
| Storage::getStorageById($id) |
| Folder::getFields() |
| Folder::getWorkObjectById($id) |
| Folder::upload($id, array $data = array(), array $rights = array(), $generateUniqueName = false) |
| Folder::shareToUser($id, $userId, $taskName) |
| Folder::isDiskStorage(Disk\Folder $folder) |
| AttachedObject::get($id) |
| AttachedObject::getAttachedObjectById($id) |
| BaseObject::copyTo($id, $targetFolderId) |
| BaseObject::getFileById($id) |
| BaseObject::getFolderById($id) |
| Rights::getTasks() |
| File::getFields() |
| File::getWorkObjectById($id) |
| File::download($id) |
| Base::init() |
| Base::processMethodRequest() |
| Base::checkRequiredInputParams(array $inputParams, array $required) |
| Version::get($id) |
| Version::download($id) |
| Version::getVersionById($id) |
| Volume::onStorageDelete($storageId, $deletedBy = Disk\SystemUser::SYSTEM_USER_ID) |
| Volume::onUserDelete($userId) |
| TransformerManager::className() |
| TransformerManager::call($status, $command, $params, $result = array()) |
| TransformerManager::clearCacheByFile(File $file) |
| TransformerManager::saveFile($file, $type) |
| TransformerManager::resetCacheInUfAfterTransformation(\Bitrix\Main\Event $event) |
| TransformerManager::transformToView(File $file) |
| TransformerManager::getTransformerByFormat($viewFormat) |
| TransformerManager::checkTransformationAttempts(File $file) |
| TransformerManager::getBlogPostIds(File $file) |
| TransformerManager::getSocNetLogIds(File $file) |
| TransformerManager::getPullTag($fileId) |
| TransformerManager::addToStack(File $file, $viewId = 0, $previewId = 0) |
| TransformerManager::subscribe($fileId, $userId) |
| BizProcManager::isAvailable() |
| Bitrix24Manager::isEnabled() |
| Bitrix24Manager::isAccessEnabled($entityType, $userId) |
| Bitrix24Manager::checkAccessEnabled($entityType, $userId) |
| Bitrix24Manager::isLicensePaid() |
| Bitrix24Manager::initLicenseInfoPopupJS($featureGroupName = "") |
| Bitrix24Manager::isFeatureEnabled($feature) |
| Bitrix24Manager::filterJsAction($feature, $jsAction, $skip = false) |
| FileDiskProperty::getUserTypeDescription() |
| FileDiskProperty::convertToDB($property, $value) |
| FileDiskProperty::attachFilesWorkflow($iblockId, $fileId) |
| FileDiskProperty::deleteAttachedFiles($iblockId, $listAttachedId) |
| FileDiskProperty::getUrlAttachedFileWorkflow($iblockId, $objectId) |
| FileDiskProperty::getUrlAttachedFileElement($elementId, $objectId) |
| FileDiskProperty::deleteAllAttachedFiles($entityId) |
| FileDiskProperty::getObjectId($attachedId) |
| FileDiskProperty::convertFromDB($property, $value) |
| FileDiskProperty::prepareValue($value) |
| FileDiskProperty::checkFields($property, $value) |
| FileDiskProperty::getLength($property, $value) |
| FileDiskProperty::getPublicEditHTML($property, $value, $controlSettings) |
| FileDiskProperty::getPublicViewHTML($property, $value, $controlSettings) |
| NotifySchema::onGetNotifySchema() |
| disk::disk() |
| disk::GetModuleTasks() |
| disk::InstallDB($install_wizard = true) |
| disk::tryToEnableZipNginx() |
| disk::RegisterModuleDependencies($isAlreadyConverted = true) |
| disk::UnInstallDB($arParams = Array()) |
| disk::InstallEvents() |
| disk::UnInstallEvents() |
| disk::InstallFiles() |
| disk::UnInstallFiles() |
| disk::InstallUserFields($moduleId = "all") |
| disk::UnInstallUserFields() |
| disk::DoInstall() |
| disk::DoUninstall() |
| disk::OnGetTableSchema() |
| disk::OnBeforeIBlockDelete($id) |