Check if TrackedObject with $resourceID
is registered

@param   string    $trackID
@return  bool
558615
public function has($trackID)
    {
        $absPath = realpath((string)$trackID);
        if(is_dir($absPath) || is_file($absPath)){
            $trackID = PathUtil::createPathID($absPath);
        }
        return isset($this->map[$trackID]) ? true:false;
    }
1031203
protected function unregisterChildProcess(string $workerId) : bool
    {
        // check if there is a client waiting for reply
        if (isset($this->workerJobMap[$workerId])) {
            $jobId = $this->workerJobMap[$workerId];
            $jobType = $this->jobTypes[$jobId];
            $clientAddress = $this->jobAddresses[$jobId];
            if ($jobType === 'normal') {
                $this->respondToClient($clientAddress, 'internal error');
            }
        }

        // unset references
        unset(
            $this->workerStates[$workerId],
            $this->workerJobCapabilities[$workerId],
            $this->workerStats[$workerId],
            $this->workerJobMap[$workerId]
        );
        return true;
    }
831711
private function getSourceById($sourceId = null)
    {
        if (null === $sourceId) {
            $sourceId = $this->getSourceId();
        }
        return $this->loader->getTracker()->getSource($sourceId);
    }
540120
public function getActiveRoundToken($roundId, \Gems_Tracker_Token $token = null)
    {
        if ((null !== $token) && $token->hasSuccesCode()) {
            // Cache the token
            //
            // WARNING: This may cause bugs for tracks where two tokens exists
            // with this roundId and a success reception code, but this does speed
            // this function with track engines where that should not occur.
            $this->_activeTokens[$token->getRoundId()] = $token;
        }

        // Nothing to find
        if (! $roundId) {
            return null;
        }

        // Use array_key_exists since there may not be a valid round
        if (! array_key_exists($roundId, $this->_activeTokens)) {
            $tokenSelect = $this->tracker->getTokenSelect();
            $tokenSelect->andReceptionCodes()
                    ->forRespondentTrack($this->_respTrackId)
                    ->forRound($roundId)
                    ->onlySucces();

            // \MUtil_Echo::track($tokenSelect->__toString());

            if ($tokenData = $tokenSelect->fetchRow()) {
                $this->_activeTokens[$roundId] = $this->tracker->getToken($tokenData);
            } else {
                $this->_activeTokens[$roundId] = null;
            }
        }

        return $this->_activeTokens[$roundId];
    }
399511
protected function isAllowed($resourceId, $privilege)
    {
        $rcmUserService = $this->getRcmUserService();

        return $rcmUserService->isAllowed(
            $resourceId,
            $privilege
        );
    }
822580
public function track(TrackableInterface $trackable)
    {
        if ($trackable instanceof Collection) {
            $this->trackCollection($trackable);
        }

        if ($trackable instanceof PageController) {
            $this->trackCollection($trackable->getPageObject());
        }

        if ($trackable instanceof Controller) {
            $this->trackBlocks($trackable->getCollectionObject(), [$trackable]);
        }
    }
55505
protected function isDeviceExist($deviceId)
    {
        $ids = array_values($this->userAgentsWithDeviceID);

        if (in_array($deviceId, $ids)) {
            return true;
        }

        return false;
    }
857660
public function execute($trackId = null, $exportOrganizations = false)
    {
        $versions = $this->loader->getVersions();

        $data = array(
            'gems_version'    => $versions->getGemsVersion(),
            'project'         => $this->project->getName(),
            'project_env'     => APPLICATION_ENV,
            'project_url'     => $this->util->getCurrentURI(), 
            'project_version' => $versions->getProjectVersion(),
        );

        // Main version data
        $this->exportTypeHeader('version', false);
        $this->exportFieldHeaders($data);
        $this->exportFieldData($data);
        $this->exportFlush();
    }
295583
public function followResource($userId, $resourceId, $resourceClass)
    {
        $followerResource = new FollowerResource();
        $followerResource->setFollowerId($userId);
        $followerResource->setResourceId($resourceId);
        $followerResource->setHash($this->getHash($resourceId, $resourceClass));
        $followerResource->setResourceClass($resourceClass);

        $this->getEntityManager()->persist($followerResource);
        $this->getEntityManager()->flush();

        return $followerResource;
    }
787796
public function has($entityId, $id) {
        /** @var IdEntity $idEntry */
        $idEntry = $this->manager->find(IdEntity::class, ['entityId' => $entityId, 'id' => $id]);
        if (null == $idEntry) {
            return false;
        }
        if ($idEntry->getExpiry() < $this->timeProvider->getDateTime()) {
            return false;
        }

        return true;
    }
10369
def _parse_track_id(self,sdp):
        ''''''
        m = re.search(r'a=control:(?P<trackid>[\w=\d]+)',sdp,re.S)
        return (m and m.group('trackid')) or ''
480274
public function handleTrackCalculation($userId)
    {
        // Process any events
        $trackEngine = $this->getTrackEngine();

        // Places here instead of only in handle field update so it will run on new tracks too
        $this->assignTokensToRelations();

        if ($event = $trackEngine->getTrackCalculationEvent()) {
            return $event->processTrackCalculation($this, $userId);
        }

        return 0;
    }
557425
public boolean canTrackerBeUsed(
      String taskTracker, String trackerHost, TaskInProgress tip) {
    synchronized (lockObject) {
      return !tip.hasFailedOnMachine(trackerHost);
    }
  }
1261042
public function getRegistrationById($registrationId)
    {
        /** @var Registration $registration */
        foreach ($this->registrations as $registration) {
            if ($registration->getId() === $registrationId) {
                return $registration;
            }
        }

        return false;
    }
722746
protected function hasWriteAccess($resourceId)
    {
        $user = $this->getSession()->getUser();
        return (new DataAccessControl())->hasPrivileges($user, array($resourceId => 'WRITE'));
    }
1247387
synchronized public TaskTrackerStatus getTaskTrackerStatus(String trackerID) {
    TaskTracker taskTracker;
    synchronized (taskTrackers) {
      taskTracker = taskTrackers.get(trackerID);
    }
    return (taskTracker == null) ? null : taskTracker.getStatus();
  }
605514
public function trackDownload($rcID = null)
    {
        $u = new User();
        $uID = intval($u->getUserID());
        $fv = $this->getApprovedVersion();
        $fvID = $fv->getFileVersionID();
        if (!isset($rcID) || !is_numeric($rcID)) {
            $rcID = 0;
        }

        $fve = new \Concrete\Core\File\Event\FileAccess($fv);
        Events::dispatch('on_file_download', $fve);

        $config = Core::make('config');
        if ($config->get('concrete.statistics.track_downloads')) {
            $db = Loader::db();
            $db->Execute(
                'insert into DownloadStatistics (fID, fvID, uID, rcID) values (?, ?, ?, ?)',
                [$this->fID, intval($fvID), $uID, $rcID]
            );
        }
    }