Create a resource group, defining the resources that sohuld be available to it

@param {String} groupName
@param {Array} resources
@param {Function} callback
@return {ImboCflient}
170326
function(groupName, resources, callback) {
        this.resourceGroupExists(groupName, function onGroupExistsResponse(err, exists) {
            if (err) {
                return callback(err);
            }

            if (exists) {
                return callback(new Error(
                    'Resource group `' + groupName + '` already exists'
                ));
            }

            this.editResourceGroup(groupName, resources, callback);
        }.bind(this));

        return this;
    }
381411
public void createGroup(String name, boolean isPrivate) {
		LinkedMultiValueMap<String, String> params = new LinkedMultiValueMap<String, String>();
		params.set("name",name);
		params.set("private", String.valueOf(isPrivate));
		restTemplate.postForEntity(buildUri("groups"), params, String.class);
	}
714468
public ApiResponse createGroup(String groupPath, String groupTitle) {
     return createGroup(groupPath, groupTitle, null);  
    }
450299
public ApiResponse createGroup(String groupPath, String groupTitle, String groupName){
        Map<String, Object> data = new HashMap<String, Object>();
        data.put("type", "group");
        data.put("path", groupPath);
        
        if (groupTitle != null) {
            data.put("title", groupTitle);
        }
        
        if(groupName != null){
            data.put("name", groupName);
        }
        
        return apiRequest(HttpMethod.POST, null, data,  organizationId, applicationId, "groups");
    }
27024
public Observable<Page<PublicIPPrefixInner>> listByResourceGroupAsync(final String resourceGroupName) {
        return listByResourceGroupWithServiceResponseAsync(resourceGroupName)
            .map(new Func1<ServiceResponse<Page<PublicIPPrefixInner>>, Page<PublicIPPrefixInner>>() {
                @Override
                public Page<PublicIPPrefixInner> call(ServiceResponse<Page<PublicIPPrefixInner>> response) {
                    return response.body();
                }
            });
    }
581984
def creategroup(self, name, path, **kwargs):
        
        data = {'name': name, 'path': path}

        if kwargs:
            data.update(kwargs)

        request = requests.post(
            self.groups_url, data=data, headers=self.headers,
            verify=self.verify_ssl, auth=self.auth, timeout=self.timeout)

        if request.status_code == 201:
            return request.json()
        else:
            msg = request.json()['message']
            raise exceptions.HttpError(msg)
1174492
@RequestMapping(value = "api/group", method = RequestMethod.POST)
    public
    @ResponseBody
    HashMap<String, Object> createNewGroup(Model model,
                                           @RequestParam(value = "name", required = true) String groupName) {
        logger.info("groupname={}", groupName);
        pathOverrideService.addGroup(groupName);
        return Utils.getJQGridJSON(pathOverrideService.findAllGroups(), "groups");
    }
1259960
def groups_with_resources(cls, instance):
        
        return instance.groups_dynamic.options(
            sa.orm.eagerload(cls.models_proxy.Group.resources)
        )
278181
public Observable<ResourceGroupInner> getAsync(String resourceGroupName) {
        return getWithServiceResponseAsync(resourceGroupName).map(new Func1<ServiceResponse<ResourceGroupInner>, ResourceGroupInner>() {
            @Override
            public ResourceGroupInner call(ServiceResponse<ResourceGroupInner> response) {
                return response.body();
            }
        });
    }
886175
function(callback){
        callback = callback || function(){};
        var res = [], _this = this, obj = null, callbackReturn;
        this._dataCache.forEach(function(item){
            if(item.type == 'group'){
                res.push({
                    type : item.type,
                    value : _this._map(item.value, callback),
                    parent : item.parent,
                    name : item.name
                });
            }else{
                obj = clone(item);
                callbackReturn = callback.call(obj, obj, item);
                if(callbackReturn != false){
                    res.push(obj);
                }
                obj = null;
            }
        });
        res = new HostAdmin()._loadJSON(res);
        return res;
    }
570003
protected function createResource($callback)
    {
        // Turn off error reporting while we try to initiate the request
        $level = error_reporting(0);
        $resource = call_user_func($callback);
        error_reporting($level);

        // If the resource could not be created, then grab the last error and throw an exception
        if (false === $resource) {
            $message = 'Error creating resource. ';
            foreach (error_get_last() as $key => $value) {
                $message .= "[{$key}] {$value} ";
            }
            throw new RuntimeException(trim($message));
        }

        return $resource;
    }
505735
public Observable<ClusterInner> getByResourceGroupAsync(String resourceGroupName, String clusterName) {
        return getByResourceGroupWithServiceResponseAsync(resourceGroupName, clusterName).map(new Func1<ServiceResponse<ClusterInner>, ClusterInner>() {
            @Override
            public ClusterInner call(ServiceResponse<ClusterInner> response) {
                return response.body();
            }
        });
    }
1231745
public Observable<Page<SnapshotInner>> listByResourceGroupAsync(final String resourceGroupName) {
        return listByResourceGroupWithServiceResponseAsync(resourceGroupName)
            .map(new Func1<ServiceResponse<Page<SnapshotInner>>, Page<SnapshotInner>>() {
                @Override
                public Page<SnapshotInner> call(ServiceResponse<Page<SnapshotInner>> response) {
                    return response.body();
                }
            });
    }
141280
function(rule, callback){
        var res = [];
        callback = callback || function(){};
        this.eachGroup(function(item){
            if(rule.group == item.name){
                callback.call(item, item);
                res.push(item);
            }
        });
        return res;
    }
228322
public Observable<Page<AvailabilitySetInner>> listByResourceGroupAsync(String resourceGroupName) {
        return listByResourceGroupWithServiceResponseAsync(resourceGroupName).map(new Func1<ServiceResponse<List<AvailabilitySetInner>>, Page<AvailabilitySetInner>>() {
            @Override
            public Page<AvailabilitySetInner> call(ServiceResponse<List<AvailabilitySetInner>> response) {
                PageImpl<AvailabilitySetInner> page = new PageImpl<>();
                page.setItems(response.body());
                return page;
            }
        });
    }
230610
public function createGroup(string $groupName, int $maxClients = -1)
    {
        if(!isset($this->groups[$groupName]))
        {
            $this->groups[$groupName] = RequestContext::getServerBean('ServerGroup', $this, $groupName, $maxClients);
        }
        return $this->groups[$groupName];
    }
889798
public function groupCall(string $groupName, string $methodName, ...$args)
    {
        return $this->createGroup($groupName)->$methodName(...$args);
    }