Returns the full workspace record for a single workspace.

        Parameters
        ----------
        workspace : {Id} Globally unique identifier for the workspace or organization.
        [params] : {Object} Parameters for the request
168807
def find_by_id(self, workspace, params={}, **options): 
        
        path = "/workspaces/%s" % (workspace)
        return self.client.get(path, params, **options)
886459
def space_acl(args):
    ''' '''
    r = fapi.get_workspace_acl(args.project, args.workspace)
    fapi._check_response_code(r, 200)
    result = dict()
    for user, info in sorted(r.json()['acl'].items()):
        result[user] = info['accessLevel']
    return result
106741
def get_instance(self, payload):
        
        return TaskInstance(self._version, payload, workspace_sid=self._solution['workspace_sid'], )
1162574
function activeWorkspaceReducer(state = null, action) {
  switch (action.type) {
    case SET_ACTIVE_WORKSPACE:
      return action.workspaceId;
    default:
      return state;
  }
}
1358641
public function getPersonalWorkspace()
    {
        $workspaceName = $this->getPersonalWorkspaceName();
        if ($workspaceName !== null) {
            return $this->workspaceRepository->findOneByName($this->getPersonalWorkspaceName());
        }
    }
310868
private function getMeta(Workspace $workspace, array $options)
    {
        $data = [
            'lang' => $workspace->getLang(),
            'forceLang' => (bool) $workspace->getLang(),
            'slug' => $workspace->getSlug(),
            'model' => $workspace->isModel(),
            'personal' => $workspace->isPersonal(),
            'description' => $workspace->getDescription(),
            'created' => DateNormalizer::normalize($workspace->getCreated()),
            'updated' => DateNormalizer::normalize($workspace->getCreated()), // todo implement
            'creator' => $workspace->getCreator() ? $this->userSerializer->serialize($workspace->getCreator(), [Options::SERIALIZE_MINIMAL]) : null,
        ];

        if (!in_array(Options::SERIALIZE_LIST, $options)) {
            // this query is very slow
            $data['totalUsers'] = $this->finder->fetch(
              User::class,
              ['workspace' => $workspace->getUuid()],
              null,
              0,
              -1,
              true
            );
            $data['totalResources'] = $this->workspaceManager->countResources($workspace);
            $data['usedStorage'] = $this->workspaceManager->getUsedStorage($workspace);
        }

        return $data;
    }
750259
private function getWorkspaceUsersIds(Workspace $workspace)
    {
        // Select all user(s) belonging to the target workspace (manager and collaborators)...
        $selectUsersIds = 'SELECT DISTINCT cur.user_id FROM claro_user_role cur JOIN claro_role cr ON cr.id = cur.role_id  WHERE cr.workspace_id = :wid';
        $idStmt = $this->em->getConnection()->prepare($selectUsersIds);
        $idStmt->bindValue('wid', $workspace->getId());
        $idStmt->execute();
        $idResults = $idStmt->fetchAll();
        foreach ($idResults as $result) {
            $ids[] = $result['user_id'];
        }

        return $ids;
    }
34701
def get_all_page_ids_from_space(confluence, space_key):
    
    limit = 500
    flag = True
    step = 0
    page_ids = []

    while flag:
        values = confluence.get_all_pages_from_space(space=space_key, start=limit * step, limit=limit)
        step += 1
        if len(values) == 0:
            flag = False
            print("Did not find any pages, please, check permissions")
        else:
            for value in values:
                print("Retrieve page with title: " + value['title'])
                page_ids.append((value['id']))
    print("Found in space {} pages {}".format(space_key, len(page_ids)))
    return page_ids
884406
def rpc_get_namespace_blockchain_record( self, namespace_id, **con_info ):
        
        if not check_namespace(namespace_id):
            return {'error': 'Invalid name or namespace', 'http_status': 400}

        db = get_db_state(self.working_dir)
        ns = db.get_namespace( namespace_id )
        if ns is None:
            # maybe revealed?
            ns = db.get_namespace_reveal( namespace_id )
            db.close()

            if ns is None:
                return {"error": "No such namespace", 'http_status': 404}

            assert 'opcode' in ns, 'BUG: missing opcode in {}'.format(json.dumps(ns, sort_keys=True))
            ns = self.sanitize_rec(ns)

            ns['ready'] = False
            return self.success_response( {'record': ns} )

        else:
            db.close()
            
            assert 'opcode' in ns, 'BUG: missing opcode in {}'.format(json.dumps(ns, sort_keys=True))
            ns = self.sanitize_rec(ns)

            ns['ready'] = True
            return self.success_response( {'record': ns} )
66218
function reservationsUrl(workspaceSid, workerSid, reservationSid) {
  return _.join(
    _.filter([workersUrl(workspaceSid, workerSid), 'Reservations', reservationSid], _.isString),
    '/'
  );
}
1356630
def list(self, page: int = None, pageSize: int = None, search: str = None, workspaceId: str = None) -> dict:
        
        return self.__client.request('get', '/forms', params={
            'page': page,
            'page_size': pageSize,
            'search': search,
            'workspace_id': workspaceId
        })
346219
public WorkspaceContainer getWorkspaceContainer(String workspaceName)
   {
      Object comp = getComponentInstance(workspaceName);
      return comp != null && comp instanceof WorkspaceContainer ? (WorkspaceContainer)comp : null;
   }
166086
def _resolve_workspace(self):
        
        if self.workspace is None:
            self.workspace = self.resolver.workspace_from_url(self.mets_url, baseurl=self.src_dir, download=self.download)
            self.mets = self.workspace.mets
1054220
def get(self, sid):
        
        return WorkflowContext(self._version, workspace_sid=self._solution['workspace_sid'], sid=sid, )
898622
def get_worksheet(self):
        
        url = self.build_url('')
        q = self.q().select('name').expand('worksheet')
        response = self.session.get(url, params=q.as_params())
        if not response:
            return None
        data = response.json()

        ws = data.get('worksheet')
        if ws is None:
            return None
        return WorkSheet(parent=self.parent, **{self._cloud_data_key: ws})
472180
def get_namespace( self, namespace_id, include_history=True ):
        

        cur = self.db.cursor()
        return namedb_get_namespace_ready( cur, namespace_id, include_history=include_history )
311852
def get_worker_build_info(workflow, platform):
    
    workspace = workflow.plugin_workspace[OrchestrateBuildPlugin.key]
    return workspace[WORKSPACE_KEY_BUILD_INFO][platform]