Get all groups from your current team
435220
def get_groups(self, limit=100, offset=0):
        
        url = self.TEAM_GROUPS_URL + "?limit=%s&offset=%s" % (limit, offset)

        connection = Connection(self.token)
        connection.set_url(self.production, url)

        return connection.get_request()
1055843
def get_members(self, offset=None, limit=None):
        
        extra = {
            'resource': self.__class__.__name__,
            'query': {'id': self.id}
        }
        logger.info('Get team members', extra=extra)
        response = self._api.get(
            url=self._URL['members_query'].format(id=self.id),
            params={'offset': offset, 'limit': limit}
        )
        data = response.json()
        total = response.headers['x-total-matching-query']
        members = [TeamMember(api=self._api, **member) for member in
                   data['items']]
        links = [Link(**link) for link in data['links']]
        href = data['href']
        return Collection(resource=TeamMember, href=href, total=total,
                          items=members, links=links, api=self._api)
303719
def get_group(self, name, default=NoGroupError):
        '''
        
        '''

        if name in self.groups:
            return self.groups[name]

        if default is NoGroupError:
            raise NoGroupError('No such group: {0}'.format(name))

        return default
444193
function readTeam ({ id, organizationId }, cb) {
      const job = {
        team: {}
      }

      let promise = null
      if (typeof cb !== 'function') [promise, cb] = asyncify()

      async.applyEachSeries([
        (job, next) => {
          Joi.validate({ id, organizationId }, validationRules.readTeam, (err) => {
            if (err) return next(Boom.badRequest(err))
            next()
          })
        },
        (job, next) => {
          job.client = db
          job.id = id
          job.organizationId = organizationId
          next()
        },
        loadTeams,
        loadTeamUsers,
        loadTeamPolicies
      ], job, (err) => {
        if (err) return cb(err)
        return cb(null, job.team)
      })

      return promise
    }
329371
public function showTeamView()
    {
        $team = User::all();

        return View::make('dashboard.team.index')
            ->withPageTitle(trans('dashboard.team.team').' - '.trans('dashboard.dashboard'))
            ->withTeamMembers($team);
    }
322452
public JSONObject getByTeamFull(String company, String team, HashMap<String, String> params) throws JSONException {
        return _getByType(company, team, null, params, false);
    }
1182892
public function getTeam()
    {
        $response = $this->rest->get(
            static::TEAM_PATH
        );

        $this->checkResponse($response);

        return new Team($response);
    }
738359
def get_team_players(self, team):
        
        team_id = self.team_names.get(team, None)
        try:
            req = self._get('teams/{}/'.format(team_id))
            team_players = req.json()['squad']
            if not team_players:
                click.secho("No players found for this team", fg="red", bold=True)
            else:
                self.writer.team_players(team_players)
        except APIErrorException:
            click.secho("No data for the team. Please check the team code.",
                        fg="red", bold=True)
768343
@SuppressWarnings("unchecked")
    public List<MappedLdapGroup> getMappedLdapGroups(final Team team) {
        final Query query = pm.newQuery(MappedLdapGroup.class, "team == :team");
        return (List<MappedLdapGroup>) query.execute(team);
    }
1251152
def team_players(self, team):
        """"""
        keys = 'shirtNumber name position nationality dateOfBirth'.split()
        data = [{key: player[key] for key in keys} for player in team]
        self.generate_output({'players': data})
1046279
@Override
    public Iterable<Team> getAllTeams() {
        // Get all available teams
        Iterable<Team> teams = teamRepository.findAll();

        for (Team team : teams) {
            Collector collector = collectorRepository
                    .findOne(team.getCollectorId());
            team.setCollector(collector);
        }

        return teams;
    }
679667
def getGroups(self, proteinId):
        """"""
        return [self.groups[gId] for gId in self._proteinToGroupIds[proteinId]]
45702
def team(self, team, simple=False):
        
        return Team(self._get('team/%s%s' % (self.team_key(team), '/simple' if simple else '')))
581189
def map_team_id(code):
    """"""
    for team in TEAM_DATA:
        if team["code"] == code:
            click.secho(team["name"], fg="green")
            break
    else:
        click.secho("No team found for this code", fg="red", bold=True)
964192
def team(self, team_id):
        
        json = None
        if int(team_id) > 0:
            url = self._build_url('teams', str(team_id))
            json = self._json(self._get(url), 200)
        return Team(json, self._session) if json else None
175804
function findAssociated(id, next){

	var model;
	var checked = 0;

	app.models.Match.findById(id).exec(function afterFound(err, models) {
		if(!err) return afterFindMatch(models);
		next(err, null);
	});


	// Called after match is fetched. Associate with Group and Teams
	function afterFindMatch(models){
		if(models.length != 1) return next(404);

		model = models[0];

		// Fetch Both Teams
		app.models.Team.findById(model.teamAId).exec(function(err, models){
			model.teamA = models.length ? models[0] : null;
			checkFetch();
		});

		app.models.Team.findById(model.teamBId).exec(function(err, models){
			model.teamB = models.length ? models[0] : null;
			checkFetch();
		});

		// Fetch Group
		app.models.Group.findById(model.groupId).exec(function(err, models){
			model.group = models.length ? models[0] : null;
			checkFetch();
		});
	}

	function checkFetch(){
		if(++checked == 3) return next(null, model);
	}
}
109204
public Future<Map<String, RankedTeam>> getTeams(String... teamIds) {
        return new ApiFuture<>(() -> handler.getTeams(teamIds));
    }