Enable the NodePublicationFilter when not in the backoffice..
5518
public function onKernelRequest()
    {
        $token = $this->tokenStorage->getToken();
        if (!$token) {
            return;
        }

        if (!$token instanceof UsernamePasswordToken) {
            return;
        }

        if ($token->getProviderKey() != 'backoffice') {
            return;
        }

        /** @var NodePublicationFilter $filter */
        $filter = $this->entityManager->getFilters()->enable('node_publication_filter');
        $filter->setApplyPublication(false);
    }
1068929
protected void applyFilter (SiteNode node) {
    	if (filter != null) {
    		boolean filtered = this.setFilter(filter, node);
    		SiteNode parent = node.getParent();
    		if (parent != null && ! filtered && parent.isFiltered()) {
    			// This node is no longer filtered but its parent is, unfilter the parent so it becomes visible
    			this.clearParentFilter(parent);
    		}
    	} else {
    		node.setFiltered(false);
    	}
	}
1021653
function onAfterUnpublish() {
        if (\Config::inst()->get('ElasticSearch', 'disabled')) {
            return;
        }
        
		$this->service->remove($this->owner, 'Live');
        $this->service->index($this->owner, 'Stage');
	}
141300
private void stopPublicationByProviderId(String providerParticipantId) {
        for (PublicationInformation publicationInformation : subscriptionId2PublicationInformation.values()) {
            if (publicationInformation.getProviderParticipantId().equals(providerParticipantId)) {
                removePublication(publicationInformation.getSubscriptionId());
            }
        }

        if (providerParticipantId != null && queuedSubscriptionRequests.containsKey(providerParticipantId)) {
            queuedSubscriptionRequests.removeAll(providerParticipantId);
        }
    }
337606
def enable(self):
        """"""
        with self._lock:
            if self.filter is None:
                self.filter = self._filter_type(self)
1243415
protected void viaEmbeddedFilter(HttpServletRequest request, HttpServletResponse response, FilterChain chain)
            throws IOException, ServletException {
        loggingFilter.doFilter(request, response, (argreq, argres) -> {
            enableAccessLogIfNeeds();
            toNextChain(argreq, argres, chain); // #to_action
        });
    }
143946
private void blacklist(String nodeName, ResourceType type) {
    List<ResourceType> blacklistedResourceTypes =
      blacklistedNodes.get(nodeName);
    if (blacklistedResourceTypes == null) {
      blacklistedResourceTypes = new ArrayList<ResourceType>();
      blacklistedNodes.put(nodeName, blacklistedResourceTypes);
    }
    synchronized (blacklistedResourceTypes) {
      if (!blacklistedResourceTypes.contains(type)) {
        blacklistedResourceTypes.add(type);
      }
    }
  }
785635
function onPublish( $contentObjectAttribute, $contentObject, $publishedNodes )
    {
        eZDebug::writeDebug( 'Start', __METHOD__ );
        $paex = $contentObjectAttribute->content();
        if ( !$paex instanceof eZPaEx )
        {
            return true;
        }

        // Update empty paex data from parent paex
        // NOTE: if the current user don't have permission to edit paex data, and is
        // creating a new object (publishing version 1), force paex object update
        // to get values set in parent
        if ( !$paex->canEdit() && $contentObject->attribute( 'current_version' ) == 1 )
            $paex->updateFromParent( true );
        else
            $paex->updateFromParent();

        eZDebug::writeDebug( 'End', __METHOD__ );
        return true;
    }
204040
function filter( node ) {
	var isNullable;
	var isOptional;
	var type;
	var desc;
	var val;

	if ( node.type ) {
		if ( node.type.names.length === 1 ) {
			type = node.type.names[ 0 ];
		} else {
			type = node.type.names;
		}
	} else {
		type = '';
	}
	desc = node.description || '';
	if ( hasOwn.call( node, 'defaultvalue' ) ) {
		val = node.defaultvalue;
	} else {
		val = '';
	}
	if ( typeof node.optional === 'boolean' ) {
		isOptional = node.optional;
	} else {
		isOptional = '';
	}
	if ( typeof node.nullable === 'boolean' ) {
		isNullable = node.nullable;
	} else {
		isNullable = '';
	}
	return {
		'name': node.name,
		'type': type,
		'description': desc,
		'default': val,
		'optional': isOptional,
		'nullable': isNullable
	};
}
685544
function nodeGlobalRequire(file) {
  vm.runInThisContext.call(global, fs.readFileSync(file), file);
}
78454
public function enableVerboseOutput()
    {
        $this->verboseFileHandle = tmpfile();
        $this->setOpt(CURLOPT_VERBOSE, true);
        $this->setOpt(CURLOPT_STDERR, $this->verboseFileHandle);
    }
605367
public Node filter(NodeFilter nodeFilter) {
        Validate.notNull(nodeFilter);
        NodeTraversor.filter(nodeFilter, this);
        return this;
    }
141797
function (sTopicId) {
				this._bIncludeDeprecated = true; // Switch internal flag
				this.byId("includeDeprecated").setSelected(true); // Update checkbox UI
				this.buildAndApplyFilters(); // Apply filters
				this._expandTreeToNode(sTopicId, this.getModel("treeData")); // Select the searched entity
			}
613549
function (isGlobal, server, err, msg, session, resp, opts, cb) {
  let fm;
  if (isGlobal) {
    fm = server.globalFilterService;
  } else {
    fm = server.filterService;
  }
  if (fm) {
    if (isGlobal) {
      fm.afterFilter(err, msg, session, resp, function () {
        // do nothing
      });
    } else {
      fm.afterFilter(err, msg, session, resp, function (err) {
        cb(err, resp, opts);
      });
    }
  }
}
504845
private void attachGroovydocAnnotation(ASTNode node, String docCommentNodeText) {
        if (!runtimeGroovydocEnabled) {
            return;
        }

        if (!(node instanceof AnnotatedNode)) {
            return;
        }

        if (!docCommentNodeText.startsWith(RUNTIME_GROOVYDOC_PREFIX)) {
            return;
        }

        AnnotatedNode annotatedNode = (AnnotatedNode) node;
        AnnotationNode annotationNode = new AnnotationNode(ClassHelper.make(Groovydoc.class));
        annotationNode.addMember(VALUE, new ConstantExpression(docCommentNodeText));
        annotatedNode.addAnnotation(annotationNode);
    }
823909
function processFilter(feed,filter,filterName) {
	if (warnReleaseStatus(filter.release_status)) {
		console.log('Warning: filter '+filterName+' is '+filter.release_status+deprecationInfo(feed,filter.name,'filter',filter.deprecated_since));
	}
	if (seen.indexOf(filterName)<0) {
		if (!filter.type) {
			console.log('+ typeless filter: '+filterName);
		}
		if (exportFilter(feed,filter,filterName)==0) {
			seen.push(filterName);
		}
	}
	else {
		console.log('* Skipping filter '+filterName+' as duplicate name');
	}
}
931177
function filterCroppedNodes(node) {
  if (!node.boxObject) {
    return domUtils.DOMWalker.FILTER_SKIP;
  } else {
    if (!node.disabled && !node.collapsed && !node.hidden) {
      // Code specific to the preferences panes to reject out not visible nodes
      // in the panes.
      if (node.parentNode && (node.parentNode.localName == "prefwindow" &&
                              node.parentNode.currentPane.id != node.id) ||
          ((node.parentNode.localName == "tabpanels" ||
            node.parentNode.localName == "deck") &&
           node.parentNode.selectedPanel.id != node.id)) {
        return domUtils.DOMWalker.FILTER_REJECT;
        // end of the specific code
      } else {
        return domUtils.DOMWalker.FILTER_ACCEPT;
      }
    } else {
      // we don't want to test not visible elements
      return domUtils.DOMWalker.FILTER_REJECT;
    }
  }
}