The same as calling ``client.getReviews(build.setID)``.

        :returns: A list of :class:`brickfront.review.Review` objects.
        :rtype: list
13660
def getReviews(self):
        '''
        
        '''

        self._reviews = self._client.getReviews(self.setID)
        return self._reviews
295423
def get_rating_metadata(self):
        
        # Implemented from template for osid.resource.ResourceForm.get_group_metadata_template
        metadata = dict(self._mdata['rating'])
        metadata.update({'existing_id_values': self._my_map['ratingId']})
        return Metadata(**metadata)
170559
def reviews(params = {})
      data = request("/review/list", params.merge(v: "2"))
      reviews = data["reviews"]["review"]
      if reviews.present?
        reviews.map { |review| Hashie::Mash.new(review) }
      else
        []
      end
    end
1067803
public List<ItemRevision> getItemRevisions(int itemId) {
		return getResourceFactory().getApiResource(
				"/item/" + itemId + "/revision/").get(
				new GenericType<List<ItemRevision>>() {
				});
	}
1373637
def get_review_id(self, id_):
    
    return _get_request(_REVIEW_ID.format(c_api=_C_API_BEGINNING,
                                                              api=_API_VERSION,
                                                              id_=id_,
                                                              at=self.access_token))
663220
public function getReviews()
    {
        $oReview = oxNew(\OxidEsales\Eshop\Application\Model\Review::class);
        $oRevs = $oReview->loadList('oxrecommlist', $this->getId());
        //if no review found, return null
        if ($oRevs->count() < 1) {
            return null;
        }

        return $oRevs;
    }
440515
@XmlElementWrapper(name="revisions")
    @XmlElement(name="rev", type=Rev.class)
    public List<Rev> getRevisions() {
        return revisions;
    }
1339494
public static ReviewCollection list(Map<String, Object> params) throws StripeException {
    return list(params, (RequestOptions) null);
  }
1287921
def uniprot_reviewed_checker(uniprot_id):
    

    query_string = 'id:' + uniprot_id

    uni_rev_raw = StringIO(bsup.search(query_string, columns='id,reviewed', frmt='tab'))
    uni_rev_df = pd.read_table(uni_rev_raw, sep='\t', index_col=0)
    uni_rev_df = uni_rev_df.fillna(False)
    uni_rev_df = uni_rev_df[pd.notnull(uni_rev_df.Status)]

    uni_rev_df = uni_rev_df.replace(to_replace="reviewed", value=True)
    uni_rev_df = uni_rev_df.replace(to_replace="unreviewed", value=False)
    uni_rev_dict_adder = uni_rev_df.to_dict()['Status']

    return uni_rev_dict_adder[uniprot_id]
1197798
def get_backreferences_for(self, instance):
        
        rc = api.get_tool("reference_catalog")
        backreferences = rc.getReferences(instance, self.relationship)
        return map(lambda ref: ref.targetUID, backreferences)
565068
async def update_review(self, **params):
		
		if params.get("message"):
			params = json.loads(params.get("message", "{}"))
		
		if not params:
			return {"error":400, "reason":"Missed required fields"}
		
		# Check if required fields exists
		txid = params.get("txid")
		coinid = params.get("coinid").upper()

		try:
			coinid = coinid.replace("TEST", "")
		except:
			pass

		# Try to find offer with account id and cid
		database = client[coinid]
		collection = database[settings.REVIEW]
		review = await collection.find_one({"txid":txid})
		if not review:
			return {"error":404, 
					"reason":"Review with txid %s not found" % txid }
		
		# Update review
		await collection.find_one_and_update(
							{"txid":txid}, {"$set":{"confirmed":1}})
		
		# Get updated offer
		updated = await collection.find_one({"txid":txid})

		return {i:updated[i] for i in updated if i != "_id"}
874934
public function getVoteCollectionByReview($reviewId)
    {
        $votesCollection = $this->voteCollection->create()
            ->setReviewFilter($reviewId);

        $votesCollection->getSelect()->join(
            ['rating' => $this->getTable('rating')],
            'rating.rating_id = main_table.rating_id',
            ['rating_code' => 'rating.rating_code']
        );

        return $votesCollection;
    }
942785
def get_minions():
    '''
    
    '''
    options = _get_options(ret=None)

    # Make sure the views are valid, which includes the minions..
    if not ensure_views():
        return []

    # Make the request for the view..
    _response = _request("GET",
                         options['url'] +
                                 options['db'] +
                                 "/_design/salt/_view/minions?group=true")

    # Verify that we got a response back.
    if 'rows' not in _response:
        log.error('Unable to get available minions: %s', _response)
        return []

    # Iterate over the rows to build up a list return it.
    _ret = []
    for row in _response['rows']:
        _ret.append(row['key'])
    return _ret
923353
async def get(self, cid, coinid):
		
		if settings.SIGNATURE_VERIFICATION:
			super().verify()

		if coinid in settings.bridges.keys():
			self.account.blockchain.setendpoint(settings.bridges[coinid])


		reviews = await self.account.blockchain.getreviews(cid=cid)
		if isinstance(reviews, dict):
			if "error" in reviews:
				self.set_status(500)
				self.write(reviews)
				raise tornado.web.Finish

		for review in reviews:
			review["confirmed"] = 1

		storage_reviews = await self.account.getreviews(coinid=coinid, cid=cid)

		if isinstance(reviews, dict):
			if "error" in reviews.keys():
				self.set_status(reviews["error"])
				self.write(reviews)
				raise tornado.web.Finish
		
		self.write(json.dumps(reviews + storage_reviews))
504282
def index
      @app_reviews = review_klass.approved
      @app_reviews = @app_reviews.limit(params[:limit]) if params[:limit]
      @app_reviews = @app_reviews.skip(params[:offset]) if params[:offset]
      @app_reviews = @app_reviews.order_by(params[:order_by]) if params[:order_by]
      @app_reviews = @app_reviews.where(params[:where]) if params[:where]

      @app_reviews = scope_app_reviews

      @app_reviews = @app_reviews.all.fetch
      response.headers['X-Total-Count'] = @app_reviews.metadata[:pagination][:count]
    end
1358686
def rating(self):
        
        if self._rating == '' and self.details != None and 'rating' in self.details:
            self._rating = self.details['rating']
        return self._rating
279486
def user_has_reviewed(obj, user):
    """"""
    ctype = ContentType.objects.get_for_model(obj)
    try:
        models.Review.objects.get(user=user, content_type=ctype,
                                  object_id=obj.id)
    except models.Review.DoesNotExist:
        return False
    return True