def replyToQuery(ctx, query, bool = None, min = 0, max = 10, justId = False, toH = False, filt = None):
    if query == None: return []
    if __onlyIn(query, ComputerManager().main):
        ComputerManager().main
        filt = __addCtxFilters(ctx, filt)
        filt['query'] = query
        return xmlrpcCleanup(ComputerManager().getRestrictedComputersList(ctx, min, max, filt, False, justId, toH))
    else:
        return xmlrpcCleanup(QueryManager().replyToQuery(ctx, query, bool, min, max))

def replyToQueryLen(ctx, query, bool = None, filt = None):
    if query == None: return 0
    if __onlyIn(query, ComputerManager().main):
        ComputerManager().main
        filt = __addCtxFilters(ctx, filt)
        filt['query'] = query
        return xmlrpcCleanup(ComputerManager().getRestrictedComputersListLen(ctx, filt))
    else:
        return xmlrpcCleanup(QueryManager().replyToQueryLen(ctx, query, bool))

 def get_group(self, id, ro=False, root_context=False):
     grp = DyngroupDatabase().get_group(self.getContext(), id)
     if grp.type == 2:
         _group_user = DyngroupDatabase()._get_group_user(grp.parent_id)
         ctx = self.getContext(user=_group_user)
     else:
         ctx = root_context and self.getContext() or self.currentContext
     grp = DyngroupDatabase().get_group(ctx, id, ro)
     if grp:
         return xmlrpcCleanup(grp.toH())
     return xmlrpcCleanup(False)

 def setbool_group(self, id, bool, type=0, parent_id=None):
     if type == 2 and parent_id is not None: # convergence group, get parent group's user context
         _group_user = DyngroupDatabase()._get_group_user(parent_id)
         ctx = self.getContext(user=_group_user)
     else:
         ctx = self.currentContext
     return xmlrpcCleanup(DyngroupDatabase().setbool_group(ctx, id, bool))

    def inventoryExists(self, uuid):
        ctx = self.currentContext
        if uuid == '':
            return False
#        if not ComputerLocationManager().doesUserHaveAccessToMachine(ctx.userid, uuid):
#            return False
        return xmlrpcCleanup(Inventory().inventoryExists(ctx, uuid))

 def delete_group(self, id):
     ctx = self.currentContext
     if self.isprofile(id):
         grp = DyngroupDatabase().get_group(ctx, id, True)
         profile_UUID = grp.getUUID()
         ComputerProfileManager().delProfile(profile_UUID)
     return xmlrpcCleanup(DyngroupDatabase().delete_group(ctx, id))

 def create_group(self, name, visibility, type=0, parent_id=None):
     if type == 2 and parent_id is not None: # convergence group, get parent group's user context
         _group_user = DyngroupDatabase()._get_group_user(parent_id)
         ctx = self.getContext(user=_group_user)
     else:
         ctx = self.currentContext
     return xmlrpcCleanup(DyngroupDatabase().create_group(ctx, name, visibility, type, parent_id))

    def get_pull_targets(self):
        """
        Returns list of Pull target UUIDs

        @return: list
        """
        return xmlrpcCleanup(MscDatabase().getPullTargets())

    def reload_group(self, id):
        ctx = self.currentContext
        ret = DyngroupDatabase().reload_group(ctx, id, queryManager)
        # WIP : call ComputerProfileManager to add machines
#        if self.isprofile(id):
#            ComputerProfileManager().addComputersToProfile(ctx, [1, 2], id) # fake!
        return xmlrpcCleanup(ret)

    def addmembers_to_group(self, id, uuids):
        ctx = self.currentContext
        # remove all the computers that cant be added to a profile from the list
        didnt_work = []
        are_some_to_remove = False
        if self.isprofile(id):
            computers = []
            uuid2key = {}
            for c in uuids:
                computers.append(uuids[c]['uuid'])
                uuid2key[uuids[c]['uuid']] = c
            didnt_work = ComputerProfileManager().areForbiddebComputers(computers)

            if len(didnt_work) > 0:
                logging.getLogger().debug("Can't add the following computers in that profile %s : %s"%(str(id), str(didnt_work)))
                for i in didnt_work:
                    if uuid2key[i] in uuids:
                        are_some_to_remove = True
                        uuids.pop(uuid2key[i])

        if len(uuids) != 0:
            if self.isprofile(id):
                ComputerProfileManager().addComputersToProfile(ctx, uuids, id)
            else:
                ret = DyngroupDatabase().addmembers_to_group(ctx, id, uuids)
                return [ret]
        return xmlrpcCleanup([not are_some_to_remove, didnt_work])

 def delmembers_to_group(self, id, uuids):
     ctx = self.currentContext
     ret = DyngroupDatabase().delmembers_to_group(ctx, id, uuids)
     # WIP : call ComputerProfileManager to add machines
     if len(uuids) != 0 and self.isprofile(id):
         ComputerProfileManager().delComputersFromProfile(uuids, id)
     return xmlrpcCleanup(ret)

 def get_profile_imaging_server(self, gid):
     if gid == '':
         return False
     if not self.isprofile(gid):
         return False
     ret = DyngroupDatabase().getProfileImagingServer(gid)
     return xmlrpcCleanup(ret)

 def get_profile_entity(self, gid):
     if gid == '':
         return False
     if not self.isprofile(gid):
         return False
     ret = DyngroupDatabase().getProfileEntity(gid)
     return xmlrpcCleanup(ret)

 def getMachinesByDict(self, table, params):
     ctx = self.currentContext
     return xmlrpcCleanup(
         map(
             lambda m: ComputerLocationManager().doesUserHaveAccessToMachine(ctx.userid, m[0]),
             Inventory().getMachinesByDict(ctx, table, params),
         )
     )

 def establish_vnc_proxy(self, scheduler, uuid, requestor_ip):
     ctx = self.currentContext
     computer = ComputerManager().getComputer(ctx, {'uuid': uuid})
     try: # FIXME: dirty bugfix, should be factorized upstream
         computer[1]['fullname']
     except KeyError:
         computer[1]['fullname'] = computer[1]['cn'][0]
     return xmlrpcCleanup(mmc.plugins.msc.client.scheduler.tcp_sproxy(scheduler, computer, requestor_ip, MscConfig().web_vnc_port))

    def is_pull_target(self, uuid):
        """
        Returns True if the machine is a known pull client

        @param uuid: computer UUID
        @type uuid: str

        @return: bool
        """
        return xmlrpcCleanup(MscDatabase().isPullTarget(uuid))

 def getPossiblesValuesForCriterionInModuleFuzzyWhere(self, moduleName, criterion, value1, value2 = ''): # not used anymore ?
     ctx = self.currentContext
     if not isDynamicEnable():
         return False
     result = queryManager.getPossiblesValuesForCriterionInModule(ctx, moduleName, criterion, unescape(value1), unescape(value2))
     ret = result[1]
     # Only returns the 100 first results
     # FIXME: maybe the range limitation could be done on the queryManager ?
     ret = ret[:100]
     return xmlrpcCleanup(ret)

    def update_target_ip(self, uuid, ip):
        """
        Updates IP address of all records according to UUID.

        @param uuid: UUID of machine
        @type uuid: str

        @param ip: actualized IP address of machine
        @type ip: str
        """
        return xmlrpcCleanup(MscDatabase().updateTargetIP(uuid, ip))

    def remove_pull_targets(self, uuids):
        """
        remove pull targets
        @param uuids: a list of uuids to remove
        @type uuids: list or str

        @return: True or False :-)
        """
        if isinstance(uuids, basestring):
            uuids = [uuids]
        return xmlrpcCleanup(MscDatabase().removePullTargets(uuids))

    def checkLightPullCommands(self, uuid):
        """
        Returns all coh ids te re-execute.

        @param uuid: uuid of checked computer
        @type uuid: str

        @return: coh ids to start
        @rtype: list
        """
        return xmlrpcCleanup(MscDatabase().checkLightPullCommands(uuid))