Only return true when no open track exists

@param \Gems\Agenda\AppointmentFilterInterface $filter
@param \Gems_Tracker_RespondentTrack $respTrack

@return boolean
766378
public function createNoOpen($filter, $respTrack)
    {
        // If an open track of this type exists: do not create a new one
        $createTrack = !$respTrack->isOpen();

        if ($createTrack) {
            $createTrack = $this->createWhenNotInThisTrack($filter, $respTrack);
        }

        return $createTrack;
    }
1040533
public function createWhenNotInThisTrack($filter, $respTrack)
    {
        $createTrack = true;

        $data = $respTrack->getFieldData();
        if (isset($data[$filter->getFieldId()]) &&
                ($this->getId() == $data[$filter->getFieldId()])) {
            $createTrack = false;
        }

        return $createTrack;
    }
171930
public function checkTokensFromStart(\Gems_Tracker_RespondentTrack $respTrack, $userId)
    {
        $token = $respTrack->getFirstToken();
        if ($token instanceof \Gems_Tracker_Token) {
            return $this->checkTokensFrom($respTrack, $respTrack->getFirstToken(), $userId);
        } else {
            return 0;
        }
    }
971168
public static function findFirst(Filter ...$filters)
    {
        $results = static::find(...$filters);

        if (sizeof($results) == 0) {
            throw new RecordNotFoundException(get_called_class(), 0);
        }

        return $results[0];
    }
239668
synchronized public boolean isBlacklisted(String trackerID) {
    TaskTrackerStatus status = getTaskTrackerStatus(trackerID);
    if (status != null) {
      return faultyTrackers.isBlacklisted(status.getHost());
    }
    return false;
  }
479700
private static boolean isRunnable(FilterTargetData targetData, String[] filters) {
		if (filters == null || filters.length == 0) {
			return true;
		}
		
		for (String filter : filters) {
			String[] filterSplitted = filter.split(":");

			// We must evaluate all the filters and return only when there is a valid match
			if (
				(filterSplitted.length == 1 && targetData.anyMatch(filterSplitted[0])) || // Any filter
				("key".equalsIgnoreCase(filterSplitted[0]) && targetData.keyMatch(filterSplitted[1])) || // Key filter
				("name".equalsIgnoreCase(filterSplitted[0]) && targetData.nameMatch(filterSplitted[1])) || // Name filter
				("tag".equalsIgnoreCase(filterSplitted[0]) && targetData.tagMatch(filterSplitted[1])) || // Tag filter
				("ticket".equalsIgnoreCase(filterSplitted[0]) && targetData.ticketMatch(filterSplitted[1])) // Ticket filter
			) {
				return true;
			}
		}

		return false;
	}
782719
public function track_open()
    {
        $oUri     = Factory::service('Uri');
        $oEmailer = Factory::service('Emailer', 'nails/module-email');

        $sRef  = $oUri->segment(3);
        $sGuid = $oUri->segment(4);
        $sHash = $oUri->segment(5);

        // --------------------------------------------------------------------------

        if (!$sRef || !$oEmailer->validateHash($sRef, $sGuid, $sHash)) {
            show404();
        }

        // --------------------------------------------------------------------------

        //  Fetch the email
        $oEmailer->trackOpen($sRef);

        // --------------------------------------------------------------------------

        /**
         * Render out a tiny, tiny image
         * Thanks http://probablyprogramming.com/2009/03/15/the-tiniest-gif-ever
         */

        header('Content-Type: image/gif');
        header('Expires: Mon, 26 Jul 1997 05:00:00 GMT');
        header('Last-Modified: " . gmdate("D, d M Y H:i:s") . " GMT');
        header('Cache-Control: no-store, no-cache, must-revalidate');
        header('Cache-Control: post-check=0, pre-check=0', false);
        header('Pragma: no-cache');

        echo base64_decode('R0lGODlhAQABAIABAP///wAAACH5BAEKAAEALAAAAAABAAEAAAICTAEAOw==');

        // --------------------------------------------------------------------------

        /**
         * Kill script, th, th, that's all folks. Stop the output class from hijacking
         * our headers and setting an incorrect Content-Type
         */

        exit(0);
    }
580480
private void checkExistingTracks() {
        SwingUtilities.invokeLater(new Runnable() {
            @Override
            public void run() {
                for (Map.Entry<DeckReference, TrackMetadata> entry : MetadataFinder.getInstance().getLoadedTracks().entrySet()) {
                    if (entry.getKey().hotCue == 0) {  // The track is currently loaded in a main player deck
                        checkIfSignatureReady(entry.getKey().player);
                    }
                }
            }
        });
    }
1223355
function filterStats(result, track, outbound) {
  var streamStatsType = outbound ? 'outbound-rtp' : 'inbound-rtp';
  var filteredResult = new Map();
  if (track === null) {
    return filteredResult;
  }
  var trackStats = [];
  result.forEach(function(value) {
    if (value.type === 'track' &&
        value.trackIdentifier === track.id) {
      trackStats.push(value);
    }
  });
  trackStats.forEach(function(trackStat) {
    result.forEach(function(stats) {
      if (stats.type === streamStatsType && stats.trackId === trackStat.id) {
        walkStats(result, stats, filteredResult);
      }
    });
  });
  return filteredResult;
}
1176387
private static Filter createFilter(final BundleContext bundleContext, final Class<?> trackedClass) {
		final String filter = "(" + Constants.OBJECTCLASS + "=" + trackedClass.getName() + ")";
		try {
			return bundleContext.createFilter(filter);
		} catch (InvalidSyntaxException e) {
			throw new IllegalArgumentException("Unexpected InvalidSyntaxException: " + e.getMessage());
		}
	}
303226
private function isMatch(FeatureNode $feature, $filterString)
    {
        if (false !== strpos($filterString, '@')) {
            return $this->isMatchTagFilter($feature, $filterString);
        }

        if (!empty($filterString)) {
            return $this->isMatchNameFilter($feature, $filterString);
        }

        return false;
    }
1232581
public boolean performTracking(  PyramidKltFeature feature ) {

		KltTrackFault result = tracker.track(feature);

		if( result != KltTrackFault.SUCCESS ) {
			return false;
		} else {
			tracker.setDescription(feature);
			return true;
		}
	}
1187259
public function find($filter = NULL, array $options = NULL, $ttl = 0) {
		$sort=false;
		if ($this->dbsType!='sql') {
			// see if reordering is needed
			foreach($this->countFields?:[] as $counter) {
				if ($options && isset($options['order']) &&
					preg_match('/count_'.$counter.'\h+(asc|desc)/i',$options['order'],$match))
					$sort=true;
			}
			if ($sort) {
				// backup slice settings
				if (isset($options['limit'])) {
					$limit = $options['limit'];
					unset($options['limit']);
				}
				if (isset($options['offset'])) {
					$offset = $options['offset'];
					unset($options['offset']);
				}
			}
		}
		$this->_ttl=$ttl?:$this->rel_ttl;
		$result = $this->filteredFind($filter,$options,$ttl);
		if (empty($result))
			return false;
		foreach($result as &$record) {
			$record = $this->factory($record);
			unset($record);
		}
		// add counter for NoSQL engines
		foreach($this->countFields?:[] as $counter)
			foreach($result as &$mapper) {
				$cr=$mapper->get($counter);
				$mapper->virtual('count_'.$counter,$cr?count($cr):null);
				unset($mapper);
			}
		$cc = new CortexCollection();
		$cc->setModels($result);
		if($sort) {
			$cc->orderBy($options['order']);
			$cc->slice(isset($offset)?$offset:0,isset($limit)?$limit:NULL);
		}
		$this->clearFilter();
		return $cc;
	}
734700
@Override
    public FetchStatus checkFilter(URI uri) {
        if (uri == null) {
            return FetchStatus.OUT_OF_SCOPE;
        }

        String otherScheme = normalisedScheme(uri.getRawScheme());
        if (port != normalisedPort(otherScheme, uri.getPort())) {
            return FetchStatus.OUT_OF_SCOPE;
        }

        if (!scheme.equals(otherScheme)) {
            return FetchStatus.OUT_OF_SCOPE;
        }

        if (!hasSameHost(uri)) {
            return FetchStatus.OUT_OF_SCOPE;
        }

        if (!startsWith(uri.getRawPath(), path)) {
            return FetchStatus.OUT_OF_SCOPE;
        }

        return FetchStatus.VALID;
    }
239852
public boolean dropTrack( CombinedTrack<TD> track ) {
		if( !tracksPureKlt.remove(track) )
			if( !tracksReactivated.remove(track) )
				if( !tracksDormant.remove(track) )
					return false;

		tracksUnused.add(track);
		return true;
	}
731517
def getTracksInCollection(user=nil,start=nil,count=nil,sort=nil,query=nil,extras=nil)
      method = 'getTracksInCollection'
      type = Track
      args = {}
      args[:user] = user if user
      args[:start] = start if start
      args[:count] = count if count
      args[:sort] = sort if sort
      args[:query] = query if query
      args[:extras] = extras if extras
      return_object type,method,args
    end
648468
public function processChangedRespondent(\Gems_Tracker_Respondent $respondent)
    {
        $changes    = 0;
        $tracker    = $this->loader->getTracker();
        $respTracks = $tracker->getRespondentTracks($respondent->getId(), $respondent->getOrganizationId());
        $userId     = $this->currentUser->getUserId();

        $tracksData = $this->db->fetchAll("SELECT * FROM gems__tracks
            WHERE gtr_active = 1 AND
                CONCAT(' ', gtr_code, ' ') LIKE '% " . $this->trackCode . " %' AND
                gtr_organizations LIKE '%|" . $respondent->getOrganizationId() . "|%'
            ORDER BY gtr_track_name");

        // \MUtil_Echo::track($tracksData);

        $changes = false;

        foreach ($tracksData as $trackData) {
            $trackEngine = $tracker->getTrackEngine($trackData);
            if ($trackEngine instanceof \Gems_Tracker_Engine_TrackEngineInterface) {
                // \MUtil_Echo::track($trackEngine->getTrackCode(), count($respTracks));

                $create = true;
                foreach($respTracks as $respondentTrack) {
                    if (($respondentTrack instanceof \Gems_Tracker_RespondentTrack) &&
                            ($respondentTrack->getTrackId() == $trackEngine->getTrackId())) {
                        $create = false;
                        break;
                    }
                }

                // \MUtil_Echo::track($create);
                if ($create) {
                    $changes = true;
                    $tracker->createRespondentTrack(
                            $respondent->getId(),
                            $respondent->getOrganizationId(),
                            $trackEngine->getTrackId(),
                            $userId
                            );
                }
            }
        }

        return $changes;
    }