Args:
            service : The service being updated by the mutation
        Returns:
            (list) : a list of all of the fields availible for the service. Pk
                is a required field in order to filter the results
193143
def update_mutation_inputs(service):
    
    # grab the default list of field summaries
    inputs = _service_mutation_summaries(service)

    # visit each field
    for field in inputs:
        # if we're looking at the id field
        if field['name'] == 'id':
            # make sure its required
            field['required'] = True
        # but no other field
        else:
            # is required
            field['required'] = False

    # return the final list
    return inputs
579416
def get_all_services(self, view = None):
    
    return services.get_all_services(self._get_resource_root(), self.name, view)
229091
def get_all():
    '''
    
    '''
    services = _get_services()

    ret = set()
    for service in services:
        ret.add(service['ServiceName'])

    return sorted(ret)
1108214
public Map<String, OperationResult<ModelService>> getChangedServices(Map<String, ModelService> services){
        String body = _serialize(services);
        HttpResponse result = invoker.invoke("/service/changing" , body, HttpMethod.POST);

        if (result.getHttpCode() != HTTP_OK) {
            throw new ServiceException(ErrorCode.REMOTE_DIRECTORY_SERVER_ERROR,
                    "HTTP Code is not OK, code=%s", result.getHttpCode());
        }

        Map<String, OperationResult<ModelService>> changedServices = _deserialize(
                    result.getRetBody(), new TypeReference<Map<String, OperationResult<ModelService>>>(){});

        return changedServices;
    }
1273458
def delete_mutation_inputs(service):
    
    from nautilus.api.util import summarize_mutation_io

    # the only input for delete events is the pk of the service record
    return [summarize_mutation_io(name='pk', type='ID', required=True)]
340147
def any(self, typ, service, binding=None):
        
        res = {}
        for ent in self.keys():
            bind = self.service(ent, typ, service, binding)
            if bind:
                res[ent] = bind

        return res
987807
def createService(self, service):
        
        url = self._url + "/createService"
        params = {
            "f" : "json"
        }
        if isinstance(service, str):
            params['service'] = service
        elif isinstance(service, dict):
            params['service'] = json.dumps(service)
        return self._post(url=url,
                             param_dict=params,
                             securityHandler=self._securityHandler,
                             proxy_url=self._proxy_url,
                             proxy_port=self._proxy_port)
140881
def services(self, *args, **kwargs):
        
        return self._client.services(*args, scope=self.id, **kwargs)
928841
def get_services(cls, request=None):
        
        return {service['name']: reverse(service['list_view'], request=request)
                for service in cls._registry.values()}
1321086
def field_pklist_from_json(self, data):
        
        model = get_model(data['app'], data['model'])
        return PkOnlyQueryset(self, model, data['pks'])
149940
def service(self, service):
        
        if service is None:
            raise ValueError("Invalid value for `service`, must not be `None`")
        allowed_values = ["lwm2m", "bootstrap"]
        if service not in allowed_values:
            raise ValueError(
                "Invalid value for `service` ({0}), must be one of {1}"
                .format(service, allowed_values)
            )

        self._service = service
943901
def service_per_endpoint(self, context=None):
        
        endps = self.getattr("endpoints", context)
        res = {}
        for service, specs in endps.items():
            for endp, binding in specs:
                res[endp] = (service, binding)
        return res
1254734
def _combined_services(cls):  # pylint: disable=no-self-argument
        
        # The class declares what services it desires. To deal with subclasses,
        # especially mixins, properly, we have to walk up the inheritance
        # hierarchy, and combine all the declared services into one dictionary.
        combined = {}
        for parent in reversed(cls.mro()):
            combined.update(getattr(parent, "_services_requested", {}))
        return combined
626383
def unget_service(self, service):
        # type: (Any) -> bool
        
        return self.__registry.unget_service(
            self.__bundle, self.__reference, service
        )
914282
def process_form(self, instance, field, form, empty_marker=None,
                     emptyReturnsMarker=False):
        

        # selected services
        service_uids = form.get("uids", [])
        # hidden services
        hidden_services = form.get("Hidden", {})

        # get the service objects
        services = map(api.get_object_by_uid, service_uids)
        # get dependencies
        dependencies = map(lambda s: s.getServiceDependencies(), services)
        dependencies = list(itertools.chain.from_iterable(dependencies))
        # Merge dependencies and services
        services = set(services + dependencies)

        as_settings = []
        for service in services:
            service_uid = api.get_uid(service)
            hidden = hidden_services.get(service_uid, "") == "on"
            as_settings.append({"uid": service_uid, "hidden": hidden})

        # set the analysis services settings
        instance.setAnalysisServicesSettings(as_settings)

        return map(api.get_uid, services), {}
1259547
def service_record(self, service_name):
    
    if not self.services().has_key(service_name):
      return None
    return self.services()[service_name]
73896
def wants(cls, *service_names):
        """"""
        def _decorator(cls_):                                # pylint: disable=missing-docstring
            for service_name in service_names:
                cls_._services_requested[service_name] = "want"  # pylint: disable=protected-access
            return cls_
        return _decorator