Returns all datas necessary to display the list of all workspaces visible for all users
that are open for self-registration.
504246
public function getDatasForSelfRegistrationWorkspaceList(User $user, $search = '')
    {
        $workspaceQueue =  $this->workspaceQueueRepo->findByUser($user);
        $listworkspacePending = array();

        foreach ($workspaceQueue as $w ) {
            $listworkspacePending[$w->getWorkspace()->getId()] = $w->getWorkspace()->getId();
        }

        if (empty($search)) {
            $workspaces = $this->workspaceRepo->findWorkspacesWithSelfRegistration($user);
        } else {
             $workspaces = $this->workspaceRepo
                 ->findWorkspacesWithSelfRegistrationBySearch($user, $search);
        }
        $tags = $this->getNonEmptyAdminTags();

        try {
            $relTagWorkspace = $this->getTagRelationsByAdminAndWorkspaces($workspaces);
        } catch (\InvalidArgumentException $e) {
            $relTagWorkspace = array();
        }

        $tagWorkspaces = array();

        // create an array: tagId => [associated_workspace_relation]
        foreach ($relTagWorkspace as $tagWs) {

            if (empty($tagWorkspaces[$tagWs['tag_id']])) {
                $tagWorkspaces[$tagWs['tag_id']] = array();
            }
            $tagWorkspaces[$tagWs['tag_id']][] = $tagWs['rel_ws_tag'];
        }

        $tagsHierarchy = $this->getAllAdminHierarchies();
        $rootTags = $this->getAdminRootTags();
        $hierarchy = array();

        // create an array : tagId => [direct_children_id]
        foreach ($tagsHierarchy as $tagHierarchy) {

            if ($tagHierarchy->getLevel() === 1) {

                if (!isset($hierarchy[$tagHierarchy->getParent()->getId()]) ||
                    !is_array($hierarchy[$tagHierarchy->getParent()->getId()])) {

                    $hierarchy[$tagHierarchy->getParent()->getId()] = array();
                }
                $hierarchy[$tagHierarchy->getParent()->getId()][] = $tagHierarchy->getTag();
            }
        }

        // create an array indicating which tag is displayable
        // a tag is displayable if it or one of his children contains is associated to a workspace
        $displayable = array();
        $allAdminTags = $this->getTagsByUser(null);

        foreach ($allAdminTags as $adminTag) {
            $adminTagId = $adminTag->getId();
            $displayable[$adminTagId] = $this->isTagDisplayable($adminTag, $tagWorkspaces, $hierarchy);
        }

        $tagWorkspacePager = array();

        foreach ($tagWorkspaces as $key => $content) {
            $tagWorkspacePager[$key] = $this->pagerFactory->createPagerFromArray($content, 1);
        }

        return array(
            'user' => $user,
            'workspaces' => $this->pagerFactory->createPagerFromArray($workspaces, 1),
            'tags' => $tags,
            'tagWorkspaces' => $tagWorkspacePager,
            'hierarchy' => $hierarchy,
            'rootTags' => $rootTags,
            'displayable' => $displayable,
            'listworkspacePending' => $listworkspacePending,
            'search' => $search
        );
    }
3103
def gatherNamespaces(self):
        '''
        '''
        if self.usedNamespaces is not None:
            return

        self.logger.debug('gatherNamespaces')
        self.usedNamespaces = {}
            
        # Add all schemas defined in wsdl
        # to used namespace and to the Alias dict
        for schema in self._wsdl.types.values():
            tns = schema.getTargetNamespace()
            self.logger.debug('Register schema(%s) -- TNS(%s)'\
                %(_get_idstr(schema), tns),)
            if self.usedNamespaces.has_key(tns) is False:
                self.usedNamespaces[tns] = []
            self.usedNamespaces[tns].append(schema)
            NAD.add(tns)
            
        # Add all xsd:import schema instances
        # to used namespace and to the Alias dict
        for k,v in SchemaReader.namespaceToSchema.items():
            self.logger.debug('Register schema(%s) -- TNS(%s)'\
                %(_get_idstr(v), k),)
            if self.usedNamespaces.has_key(k) is False:
                self.usedNamespaces[k] = []
            self.usedNamespaces[k].append(v)
            NAD.add(k)
951024
def all(self):
        
        return [email for email, action in self._collaborators.items() if action in [RoleValue.Owner, RoleValue.User, ShareRequestValue.Add]]
1193058
def list():
    ''''''
    fields = [
        ('Name', 'name'),
        ('ID', 'id'),
        ('Owner', 'is_owner'),
        ('Permission', 'permission'),
    ]
    with Session() as session:
        try:
            resp = session.VFolder.list()
            if not resp:
                print('There is no virtual folders created yet.')
                return
            rows = (tuple(vf[key] for _, key in fields) for vf in resp)
            hdrs = (display_name for display_name, _ in fields)
            print(tabulate(rows, hdrs))
        except Exception as e:
            print_error(e)
            sys.exit(1)
296036
def events(self):
        
        if self._events is None:
            self._events = EventList(self._version, workspace_sid=self._solution['sid'], )
        return self._events
1208013
def reservations(self):
        
        if self._reservations is None:
            self._reservations = ReservationList(
                self._version,
                workspace_sid=self._solution['workspace_sid'],
                worker_sid=self._solution['sid'],
            )
        return self._reservations
1369630
def workspaces(self, index=None):
        """"""
        c = self.centralWidget()
        if index is None:
            return (c.widget(n) for n in range(c.count()))
        else:
            return c.widget(index)
1234794
def list(self):
        
        
        uri = URITemplate(self.baseuri + '/{owner}').expand(
            owner=self.username)
        return self.session.get(uri)
248136
public function getWorkspaces()
    {
        return $this->getCachedProperty(
            'workspaces',
            function () {
                $workspaces = [];
                $items = $this->getDomElement()->getElementsByTagNameNS($this->ns(), 'workspace');
                foreach ($items as $item) {
                    $workspaces[] = $this->getExtensions()->parseElement($this, $item);
                }

                return $workspaces;
            }
        );
    }
1133627
def all_display_panels(self) -> typing.List[DisplayPanel]:
        
        return [DisplayPanel(display_panel) for display_panel in self.__document_controller.workspace_controller.display_panels]
1201217
def all(self) -> List[Any]:
        
        values = []
        for name, value in self._entrypoints.items():
            if isinstance(value, EntryPoint):
                value = self._entrypoints[name] = value.load()

            values.append(value)

        return values
984185
public List<WorkUnit> getWorkUnits() {
    ImmutableList.Builder<WorkUnit> allWorkUnits = ImmutableList.builder();
    for (List<WorkUnit> workUnits : this.workUnitsMap.values()) {
      allWorkUnits.addAll(workUnits);
    }
    return allWorkUnits.build();
  }
712639
def get_worksheets(self):
        

        url = self.build_url(self._endpoints.get('get_worksheets'))
        response = self.session.get(url)

        if not response:
            return []

        data = response.json()

        return [self.worksheet_constructor(parent=self, **{self._cloud_data_key: ws})
                for ws in data.get('value', [])]
293545
def rpc_get_all_namespaces( self, **con_info ):
        
        db = get_db_state(self.working_dir)
        all_namespaces = db.get_all_namespace_ids()
        db.close()

        return self.success_response( {'namespaces': all_namespaces} )
1182222
def tasks(self):
        
        if self._tasks is None:
            self._tasks = TaskList(self._version, workspace_sid=self._solution['sid'], )
        return self._tasks
614302
public List<User> getAllUsers() {
        List<User> r = new ArrayList<User>();
        for (User u : User.getAll()) {
            if(u.getProperty(Details.class)!=null)
                r.add(u);
        }
        Collections.sort(r);
        return r;
    }
988434
public java.util.List<StartRequest> getStartWorkspaceRequests() {
        if (startWorkspaceRequests == null) {
            startWorkspaceRequests = new com.amazonaws.internal.SdkInternalList<StartRequest>();
        }
        return startWorkspaceRequests;
    }