Retrieves documentation about an operation.

@param string $operation Name of the operation

@return null|string
432377
public function getOperationDocs($operation)
    {
        return isset($this->docs['operations'][$operation])
            ? $this->docs['operations'][$operation]
            : null;
    }
35140
protected function getLogObject(LdapOperationInterface $operation)
    {
        if (!$this->logger) {
            return null;
        }

        return (new LogOperation($operation))->setDomain($this->connection->getConfig()->getDomainName());
    }
1207303
private function resolveRequirements(Operation $operation): array
    {
        $requirements = [];

        foreach ($operation->getParameters() as $parameter) {
            if ($parameter->getIn() === Parameter::IN_PATH
                && ($schema = $parameter->getSchema()) instanceof ScalarSchema
            ) {
                $requirements[$parameter->getName()] = $this->typePatternResolver->resolve($schema);
            }
        }

        return $requirements;
    }
813331
protected function getBltPackage($operation) {
    if ($operation instanceof InstallOperation) {
      $package = $operation->getPackage();
    }
    elseif ($operation instanceof UpdateOperation) {
      $package = $operation->getTargetPackage();
    }
    if (isset($package) && $package instanceof PackageInterface && $package->getName() == 'acquia/blt') {
      return $package;
    }
    return NULL;
  }
226234
protected function getDetail($detail)
    {
        $fromDetails = $this->docvertDetails[$detail];
        if ($fromDetails) {
            return $fromDetails;
        }
        
        $fromConfig = $this->config()->get($detail);
        if ($fromConfig) {
            return $fromConfig;
        }

        $fromEnv = Environment::getEnv('DOCVERT_' . strtoupper($detail));
        if ($fromEnv) {
            return $fromEnv;
        }
    }
18425
private function getOperator($operator)
    {
        $operators = $this->getOperators();

        $key = array_search(strtolower($operator), $operators);

        if ($key !== false && array_key_exists($key, $operators)) {
            return $operators[$key];
        }

        $operators = implode(', ', $operators);

        $message = "Operator: $operator cannot be used in an LDAP query. Available operators are $operators";

        throw new InvalidQueryOperator($message);
    }
908991
public function getOperations()
    {
        $operations = [];
        foreach (static::attributes() as $attribute => $type) {
            if ($type === Operation::class && isset($this->$attribute)) {
                $operations[$attribute] = $this->$attribute;
            }
        }
        return $operations;
    }
272255
public static function parseOperationName(Operation $operation)
    {
        $verb = self::deriveAction($operation->httpMethod, $operation->uri);

        $wordifiedPath = self::wordifyPath($operation->uri);

        if ($operation->version == 'stream') {
            $wordifiedPath = $wordifiedPath.'Stream';
        }

        if (preg_match("/^\/{urlname}.*/", $operation->uri) == 1) {
            $wordifiedPath = 'Group'.$wordifiedPath;
        }

        return ucfirst($verb.$wordifiedPath);
    }
158653
public function ExecuteRequest($operation, $params = array())
	{
		$results = parent::ExecuteRequest($operation, $params);

		return $results->{$operation == 'getPersona' ? 'personaReturn' : 'return'};
	}
857552
function getHelpContentsForOperation(operation) {

    const sections = [];
    // params table is shown only if we have a single
    // operation with 1 or more params.
    if (operation) {
        let paramsHelp = { head: '', table: [] };
        if (operation.params) {
            const { params } = operation;
            paramsHelp = {
                head: `Command arguments are:`,
                table: params.map(param => [chalk.cyan.bold(`--${param.name} <${param.type}>${param.required ? ' (required)' : ''}`), param.description])
            };
            if (operation.entityName) {
                paramsHelp.table.unshift([chalk.cyan.bold('--in (required)'), `The object to send in the body of the request`],
                    ['', chalk.dim(getEntityTypeExample(operation.entityType))]);
            }
        } else if (operation.entityName) {
            paramsHelp = {
                head: `Command arguments are:`,
                table: [
                    [chalk.cyan.bold('--in (required)'), `The object to send in the body of the request`],
                    ['', chalk.dim(getEntityTypeExample(operation.entityType))]
                ]
            };
        }
        switch (operation.target[0]) {
        case 'application':
            switch (operation.methodAlias) {
            case 'add':
            case 'import':
            case "get":
                paramsHelp.table.push([chalk.cyan.bold(`--msbot`), `(OPTIONAL) Format the output as json for piping into msbot connect luis command`]);
                break;
            }
            break;
        }
        sections.push(paramsHelp);
    }
    sections.push(configSection);
    sections.push(globalArgs);
    return sections;
}
1134211
public function getWhereStatement()
    {
        if (empty($this->where)) {
            return false;
        }
        $this->where[0]['operation'] = null;
        $str = '';
        foreach ($this->where as $clause) {
            $str .= trim("{$clause['operation']} {$clause['condition']}");
            $str .= " ";
        }

        return trim($str);
    }
1330609
public function getCheckedOutDocs(OperationContextInterface $context = null)
    {
        $context = $this->ensureContext($context);
        $checkedOutDocs = $this->getBinding()->getNavigationService()->getCheckedOutDocs(
            $this->getRepositoryId(),
            $this->getId(),
            $context->getQueryFilterString(),
            $context->getOrderBy(),
            $context->isIncludeAllowableActions(),
            $context->getIncludeRelationships(),
            $context->getRenditionFilterString()
        );

        $result = [];
        $objectFactory = $this->getObjectFactory();
        foreach ($checkedOutDocs->getObjects() as $objectData) {
            $document = $objectFactory->convertObject($objectData, $context);
            if (!($document instanceof DocumentInterface)) {
                // should not happen but could happen if the repository is not implemented correctly ...
                continue;
            }

            $result[] = $document;
        }

        return $result;
    }
804161
public function getOperand($i)
    {
        return ($i < count($this->operands)) ? $this->operands[$i] : null;
    }
908469
protected function operatorName($operator)
    {
        if (isset($this->_operatorNames[$operator])) {
            return $this->_operatorNames[$operator];
        }
        return strtolower($operator);
    }
1321240
public function get($key = NULL)
    {
        if (is_null($key)) {
            return $this->operationQueue;
        } else {
            if (!isset($this->operationQueue[$key])) {
                throw new OperationStateException("\$key {$key} was not present in the OperationStateManager queue");
            } else {
                return $this->operationQueue[$key];
            }
        }
    }
876182
function getOperationData($operation){
		if ($this->endpointType == 'wsdl' && is_null($this->wsdl)) {
			$this->loadWSDL();
			if ($this->getError())
				return false;
		}
		if(isset($this->operations[$operation])){
			return $this->operations[$operation];
		}
		$this->debug("No data for operation: $operation");
	}
192691
protected function getOperationAsArray(FetcherOperation $operation)
    {
        $filters = array();

        if ($operation instanceof SimpleOperation) {
            $filters = $this->addSimpleOperation($operation);
        } else if ($operation instanceof ListOperation) {
            $operations = $operation->getOperations();

            if ($operation->getOperator() === Fetcher::OPERATOR_OR) {
                $filters['$or'] = array_map(
                    function (FetcherOperation $operation) {
                        return $this->getOperationAsArray($operation);
                    },
                    $operations
                );
            } else {
                foreach ($operations as $currentOperation) {
                    $currentFilters = $this->getOperationAsArray($currentOperation);
                    $filters = array_merge_recursive($filters, $currentFilters);
                }
            }
        } else {
            throw new \InvalidArgumentException('Given operation is not supported');
        }

        return $filters;
    }