Updates or creates config of that group. Requires tree bound to db.
554773
def update_config(self):
        
        dataset = self._top._config.dataset
        session = object_session(self._top._config)
        logger.debug(
            'Updating group config. dataset: {}, type: {}, key: {}'.format(dataset.vid, self._top._type, self._key))

        self._config, created = _get_config_instance(
            self, session,
            parent_id=self._parent._config.id, d_vid=dataset.vid,
            group=self._key, key=self._key, type=self._top._type, dataset = dataset)
        if created:
            self._top._cached_configs[self._get_path()] = self._config
        self._top._add_valid(self._config)

        if created:
            logger.debug(
                'New group config created and linked. config: {}'.format(self._config))
        else:
            logger.debug(
                'Existing group config linked. config: {}'.format(self._config))
819062
def update(self):
        
        with open(os.path.join(self.config_dir, CONFIG_FILE_NAME), 'w') as config_file:
            self.config.write(config_file)
1129998
def update_config(config):
    

    # Update the default config with whatever is in the passed config
    update(bigchaindb.config, update_types(config, bigchaindb.config))
    bigchaindb.config['CONFIGURED'] = True
146325
public OperationFuture<Group> create(GroupConfig groupConfig) {
        checkNotNull(groupConfig, "GroupConfig must be not null");
        checkNotNull(groupConfig.getName(), "Name of GroupConfig must be not null");
        checkNotNull(groupConfig.getParentGroup(), "ParentGroup of GroupConfig must be not null");

        GroupMetadata group = client.createGroup(
                converter.createGroupRequest(groupConfig, idByRef(groupConfig.getParentGroup()),
                    groupConfig.getCustomFields() == null || groupConfig.getCustomFields().size() == 0 ?
                        null : client.getCustomFields()
                ));

        return new OperationFuture<>(
            Group.refById(group.getId()),
            new NoWaitingJobFuture()
        );
    }
588956
public void updateGroup(long groupId, String name, boolean isPrivate) {
		LinkedMultiValueMap<String, String> params = new LinkedMultiValueMap<String, String>();
		params.set("name",name);
		params.set("private", String.valueOf(isPrivate));
		restTemplate.put(buildUri("groups/"+groupId), params);
	}
906724
def create(config, name, group, type):
        """"""
        if type not in ('user', 'service'):
            raise click.BadOptionUsage("--type must be 'user' or 'service'")
        client = Client()
        client.prepare_connection()
        user_api = API(client)
        group_api = GroupApi(client)
        user_api.create(name[0], name[1], group, type, group_api)
740757
def update_group(self, group_id, trigger):
        
        data = self._serialize_object(trigger)
        self._put(self._service_url(['triggers', 'groups', group_id]), data, parse_json=False)
74578
public void updateGroupName(String newGroupName, int id) {
        PreparedStatement statement = null;

        try (Connection sqlConnection = sqlService.getConnection()) {
            statement = sqlConnection.prepareStatement(
                "UPDATE " + Constants.DB_TABLE_GROUPS +
                    " SET " + Constants.GROUPS_GROUP_NAME + " = ? " +
                    " WHERE " + Constants.GENERIC_ID + " = ?"
            );
            statement.setString(1, newGroupName);
            statement.setInt(2, id);
            statement.executeUpdate();
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            try {
                if (statement != null) {
                    statement.close();
                }
            } catch (Exception e) {
            }
        }
    }
994697
def _init_groups(self):
        
        for group_id, conf in self.group_conf.items():
            self.parent_input_dict[group_id] = Queue(conf.get('input_max_size', 0))
            self.parent_output_dict[group_id] = Queue(conf.get('output_max_size', 0))
1103504
def add_group(self, group_attribs=None, parent=None):
        """"""
        if parent is None:
            parent = self.tree.getroot()
        elif not self.contains_group(parent):
            warnings.warn('The requested group {0} does not belong to '
                          'this Document'.format(parent))

        if group_attribs is None:
            group_attribs = {}
        else:
            group_attribs = group_attribs.copy()

        return SubElement(parent, '{{{0}}}g'.format(
            SVG_NAMESPACE['svg']), group_attribs)
919693
public function editBlockConfiguration(Tree $tree, int $block_id): void
    {
        $sendmail = $this->getBlockSetting($block_id, 'sendmail', '1');
        $days     = $this->getBlockSetting($block_id, 'days', '1');

        echo view('modules/review_changes/config', [
            'days'     => $days,
            'sendmail' => $sendmail,
        ]);
    }
190263
def update(self, group_id, new_group_name, session):
        ''''''
        request = TOPRequest('taobao.crm.group.update')
        request['group_id'] = group_id
        request['new_group_name'] = new_group_name
        self.create(self.execute(request, session), fields=['is_success',])
        return self.is_success
1163562
private void addAttributes(ConfiguratorRegistration configuratorRegistration, String group) {
        // if group == null; group = "DEFAULT_GROUP"
        if (StringUtils.isNotEmpty(group)) {
            configuratorRegistration.setGroup(group);
        }

    }
1295135
def update_resourcegroup(group,**kwargs):
    

    group_i                 = _get_group(group.id)
    group_i.name            = group.name
    group_i.description     = group.description
    group_i.status          = group.status

    db.DBSession.flush()

    return group_i
584616
@Override
    public boolean setGroup(Node node) throws Exception {
        LdapGroup newLdapGroup = (LdapGroup) node;
        newLdapGroup = updateGroupMembers(newLdapGroup);
        LdapGroup oldLdapGroup = (LdapGroup) getGroup(newLdapGroup.getCn());
        if (oldLdapGroup.isEmpty()) {
            creationCount++;
            Logger.info(LOG_BIND + getOuForNode(newLdapGroup));
            ctx.bind(getOuForNode(newLdapGroup), null, newLdapGroup.getAttributes());
            return true;
        } else {
            ModificationItem[] mods = buildModificationsForGroup(newLdapGroup, oldLdapGroup);
            if (mods.length > 0) {
                modificationCount++;
                Logger.info(LOG_MODIFY_ATTRIBUTES + getOuForNode(newLdapGroup));
                ctx.modifyAttributes(getOuForNode(newLdapGroup), mods);
                return true;
            }
        }
        return false;
    }
148260
def save_group(self, group):
        
        # If group already exists, take over existing group rather then error.
        try:
            lgroup = self._get_group(group.name)
            changes = changeset(lgroup, {})
        except ObjectDoesNotExist:
            lgroup = self._group_class()
            changes = changeset(lgroup, {
                'cn': group.name,
            })

        changes = changes.merge({
            'description': group.description
        })
        save(changes, database=self._database)
279232
def create_or_update_groups(self):
        

        for name in self.group_names:
            try:
                Group.objects.get(name=name)
            except ObjectDoesNotExist:
                Group.objects.create(name=name)
        Group.objects.exclude(name__in=self.group_names).delete()

        if self.verbose:
            names = [obj.name for obj in Group.objects.all().order_by("name")]
            sys.stdout.write(f"  Groups are: {', '.join(names)}\n")