Disable the check.
494378
public function disable()
    {
        $updatedCheck = $this->ohDear->disableCheck($this->id);

        $this->enabled = $updatedCheck->enabled;
    }
45339
def stop_playback(self):
        """"""
        self._sink.flush()
        self._sink.stop()
        self._playing = False
117522
def stop(check, env):
    """"""
    all_checks = check == 'all'
    checks = get_configured_checks() if all_checks else [check]

    if all_checks:
        env_indent = DEFAULT_INDENT
        status_indent = DEFAULT_INDENT * 2
    else:
        env_indent = None
        status_indent = DEFAULT_INDENT

    for check in checks:
        if all_checks:
            envs = get_configured_envs(check)
            if envs:
                echo_success('{}:'.format(check))
        else:
            envs = [env] if env else get_configured_envs(check)

        for env in envs:
            echo_info('{}:'.format(env), indent=env_indent)
            environment = create_interface(check, env)

            echo_waiting('Stopping the Agent... ', nl=False, indent=status_indent)
            environment.stop_agent()
            echo_success('success!')

            echo_waiting('Removing configuration files... ', nl=False, indent=status_indent)
            environment.remove_config()
            echo_success('success!')

            echo_waiting('Stopping the environment... ', nl=False, indent=status_indent)
            _, _, error = stop_environment(check, env, metadata=environment.metadata)
            if error:
                echo_failure('failed!')
                abort(error)
            echo_success('success!')
1329450
def uncheck_all_local(self):
        """"""
        for buttons in self.event['local'].values():
            if not buttons[0].get_value():
                self.event['global']['all_local'].setChecked(False)
            if buttons[1].isEnabled() and not buttons[1].get_value():
                self.event['global']['all_local_prep'].setChecked(False)
1184924
def stop(self):
        
        if event.contains(self.field, 'set', self.__validate):
            event.remove(self.field, 'set', self.__validate)
808611
def _disable(self):
        
        self.total_time += time() - self.enabled_start
        self.enabled_start = None
        del self.stack
20514
def disable_radio_button(self):
        """"""
        checked = self.default_input_button_group.checkedButton()
        if checked:
            self.default_input_button_group.setExclusive(False)
            checked.setChecked(False)
            self.default_input_button_group.setExclusive(True)
        for button in self.default_input_button_group.buttons():
            button.setDisabled(True)
        self.custom_value.setDisabled(True)
673900
def stop(self):
        
        self._lock.acquire()
        try:
            # Stop the timer
            if self._timer != None:
                self._timer.stop()
                self._timer = None
            
            # Unset started flag
            self.started = False
        finally:
            self._lock.release()
256677
def disable(self):
        """"""
        core_napps_manager = CoreNAppsManager(base_path=self._enabled)
        core_napps_manager.disable(self.user, self.napp)
952897
def stop_executing_host_checks(self):
        
        if self.my_conf.execute_host_checks:
            self.my_conf.modified_attributes |= DICT_MODATTR["MODATTR_ACTIVE_CHECKS_ENABLED"].value
            self.my_conf.execute_host_checks = False
            self.my_conf.explode_global_conf()
            self.daemon.update_program_status()
122465
def restrictCheckers(self, allowedMessages):
        
        uselessCheckers = self.findUselessCheckers(allowedMessages)
        # Unregister these checkers
        for checker in uselessCheckers:
            self.unregisterChecker(checker)
1042614
def checkbox_uncheck(self, force_check=False):
        
        if self.get_attribute('checked'):
            self.click(force_click=force_check)
1267963
def stop(self):
        """"""
        self.StopTask()
        self.ClearTask()
        if self.clock:
            self.clock.StopTask()
            self.clock.ClearTask()
620039
def _disable_encryption(self):
        # () -> None
        """"""
        self.encrypt = self._disabled_encrypt
        self.decrypt = self._disabled_decrypt
820863
def disable(self):
        
        w.ActButton.disable(self)
        g = get_root(self).globals
        if self._expert:
            self.config(bg=g.COL['start'])
        else:
            self.config(bg=g.COL['startD'])
354113
def disable_host_check(self, host):
        
        if host.active_checks_enabled:
            host.modified_attributes |= DICT_MODATTR["MODATTR_ACTIVE_CHECKS_ENABLED"].value
            host.disable_active_checks(self.daemon.checks)
            self.send_an_element(host.get_update_status_brok())
1127492
public static function disable()
    {

        if (self::isEnabled()) {
            // stop any timers still on stack (those might be stopped after calculation otherwise)
            $stackCopy = self::$stack;
            while ($timerName = array_pop($stackCopy)) {
                self::stop($timerName);
            }
        }
        self::$_enabled = false;

        self::calculate();
    }