Checks if enable was toggled on group config and
    deletes groups if necessary.
540706
def pre_save_config(sender, instance, *args, **kwargs):
    
    logger.debug("Received pre_save from {}".format(instance))
    if not instance.pk:
        # new model being created
        return
    try:
        old_instance = AutogroupsConfig.objects.get(pk=instance.pk)

        # Check if enable was toggled, delete groups?
        if old_instance.alliance_groups is True and instance.alliance_groups is False:
            instance.delete_alliance_managed_groups()

        if old_instance.corp_groups is True and instance.corp_groups is False:
            instance.delete_corp_managed_groups()
    except AutogroupsConfig.DoesNotExist:
        pass
755726
public void enableDefaultButtons(boolean enabled) {

        if (enabled) {
            m_itemsRight.addComponent(m_contextMenu, 0);
            m_itemsRight.addComponent(m_favButton, 1);
            m_itemsRight.addComponent(m_quickLaunchDropDown, 2);
        } else {
            m_itemsRight.removeComponent(m_contextMenu);
            m_itemsRight.removeComponent(m_favButton);
            m_itemsRight.removeComponent(m_quickLaunchDropDown);
        }
        updateFoldingThreshhold();
    }
962929
def delete_group(self, name):
        
        self.service.delete_group(
            name, self.url_prefix, self.auth, self.session,
            self.session_send_opts)
1399
def group_remove(name, **kwargs):
    
    ctx = Context(**kwargs)
    ctx.execute_action('group:remove', **{
        'storage': ctx.repo.create_secure_service('storage'),
        'name': name,
    })
519089
public void setClearButtonEnabled(boolean enabled) {

        if (enabled) {
            m_clearButton.enable();
        } else {
            m_clearButton.disable(Messages.get().key(Messages.GUI_DISABLE_CLEAR_LIST_0));
        }
    }
185832
def enter_unlinking_mode(self, group):
        
        msg = StandardSend(self._address,
                           COMMAND_ENTER_UNLINKING_MODE_0X0A_NONE,
                           cmd2=group)
        self._send_msg(msg)
1001224
def remove_from_group(server_context, user_ids, group_id, container_path=None):
    
    return __make_security_group_api_request(server_context, 'removeGroupMember.api', user_ids,
                                             group_id, container_path)
152872
function enable (context, loc, group, rules) {
  if (rules.length === 0) {
    context.report({ loc, message: '++ {{group}}', data: { group }})
  } else {
    context.report({ loc, message: '+ {{group}} {{rules}}', data: { group, rules: rules.join(' ') }})
  }
}
637973
function resetGroup(groupName) {

    var vivalidGroup = groupNameToVivalidGroup[groupName];

    if (vivalidGroup) {
        vivalidGroup.reset();
    } else {
        console.log('could not find group named ' + groupName);
    }

}
872676
def servicegroup_delete(sg_name, **connection_args):
    '''
    
    '''
    ret = True
    sg = _servicegroup_get(sg_name, **connection_args)
    if sg is None:
        return False
    nitro = _connect(**connection_args)
    if nitro is None:
        return False
    try:
        NSServiceGroup.delete(nitro, sg)
    except NSNitroError as error:
        log.debug('netscaler module error - NSServiceGroup.delete() failed: %s', error)
        ret = False
    _disconnect(nitro)
    return ret
733430
public function isEnabled()
    {
        return isset($this->config->enable->value) && $this->config->enable->value;
    }
1308370
public function reset()
    {
        $this->exclusionStrategyGroups = $this->options['exclusionStrategyGroups'];
        $this->exclusionStrategyVersion = $this->options['exclusionStrategyVersion'];
        $this->serializeNullStrategy = $this->options['serializeNullStrategy'];
    }
1005773
protected function configure()
    {
        $configureSettingGroup = $this->cliHelper->confirmAction('Would you like to change the settings?');
        if (!$configureSettingGroup) {
            return;
        }
        
        $this->configureSettings($this->configurationManager->getSettings());
    }
607599
def remove_from_group(self, devices):
        """"""
        ids = {d.id for d in self.devices_in_group()}
        ids.difference_update(self._device_ids(devices))
        self._set_group(ids)
672514
def group_toggle(self, addr, use_cache=True):
        
        data = self.group_read(addr, use_cache)
        if len(data) != 1:
            problem = "Can't toggle a {}-octet group address {}".format(
                len(data), addr)
            logging.error(problem)
            raise KNXException(problem)

        if data[0] == 0:
            self.group_write(addr, [1])
        elif data[0] == 1:
            self.group_write(addr, [0])
        else:
            problem = "Can't toggle group address {} as value is {}".format(
                addr, data[0])
            logging.error(problem)
            raise KNXException(problem)
590071
def GroupsDelete(self, group_id):
        
        if self.__SenseApiCall__('/groups/{0}.json'.format(group_id), 'DELETE'):
            return True
        else:
            self.__error__ = "api call unsuccessful"
            return False
998949
def delete(options = {})
      options = options.merge(
        auto_scaling_group_name: @group_name,
        topic_arn: @topic_arn
      )
      resp = @client.delete_notification_configuration(options)
      resp.data
    end