GET /mnoe/jpi/v1/marketplace/:id/app_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
1079387
def review(id)
      data = request("/review/show", id: id)
      Hashie::Mash.new(data["review"])
    end
1045832
def get_reviewable_hits(self, hit_type=None, status='Reviewable',
                            sort_by='Expiration', sort_direction='Ascending', 
                            page_size=10, page_number=1):
        
        params = {'Status' : status,
                  'SortProperty' : sort_by,
                  'SortDirection' : sort_direction,
                  'PageSize' : page_size,
                  'PageNumber' : page_number}

        # Handle optional hit_type argument
        if hit_type is not None:
            params.update({'HITTypeId': hit_type})

        return self._process_request('GetReviewableHITs', params, [('HIT', HIT),])
708990
function getAppsLists (callback) {
  return this.steam('getAppList').then(function (body) {
    var lists = Object.create(null);
    body.applist.apps.forEach(function (app) {
      var type = this.match(app.appid);
      if (!lists[type]) {
        lists[type] = [];
      }
      lists[type].push(app);
    }, this);
    return Promise.resolve(lists);
  }.bind(this)).nodeify(callback);
}
721443
def get_reviews(self, user_id):
    
    url = _REVIEWS_USER.format(c_api=_C_API_BEGINNING,
                                                api=_API_VERSION,
                                                user_id=user_id,
                                                at=self.access_token)
    return _get_request(url)
835409
def get(self, id):
        
        ctx = self.context.copy()
        ctx['active_test'] = False
        results = self.rpc_model.search_read(
            [('id', '=', id)],
            None, None, None, self.fields,
            context=ctx
        )
        return results and results[0] or None
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))
696883
public function getReviews($modelId)
    {
        $resource = 'model/' . $modelId . '/reviews.json';
        $response = $this->getServiceResponse($resource);

        $getReviewsResponse = new Models\ResponseModelReviewsGet($response);

        return $getReviewsResponse;
    }
458542
private function getReviewDataWithRating(ArrayCollection $reviews, ArrayCollection $ratings)
    {
        $reviewList = [];

        foreach ($reviews as $review) {
            $ratingAndReview = [
                'reviewId'      => $review->getId(),
                'text'          => $review->getText(),
                'createdAt'     => $review->getCreatedAt(),
                'objectId'      => $review->getObjectId(),
                'objectType'    => $review->getType(),
                'rating'        => false,
                'ratingId'      => false,
            ];

            foreach ($ratings as $rating) {
                if ($this->isReviewRating($review, $rating)) {
                    $ratingAndReview['rating'] = $rating->getRating();
                    $ratingAndReview['ratingId'] = $rating->getId();

                    break;
                }
            }

            $reviewList[] = $ratingAndReview;
        }

        return $reviewList;
    }
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)
133828
def get_appliance(self, appliance_id):
    
    url = "https://api.neur.io/v1/appliances/%s"%(appliance_id)

    headers = self.__gen_headers()
    headers["Content-Type"] = "application/json"

    r = requests.get(url, headers=headers)
    return r.json()
1102517
def __get_post_review(email_cnt, idx):
    '''
    
    '''
    for key in router_post:
        recent_posts = MPost.query_recent_edited(tools.timestamp() - TIME_LIMIT, kind=key)
        for recent_post in recent_posts:
            hist_rec = MPostHist.get_last(recent_post.uid)
            if hist_rec:
                foo_str = '''
                    <tr><td>{0}</td><td>{1}</td><td class="diff_chg">Edit</td><td>{2}</td>
                    <td><a href="{3}">{3}</a></td></tr>
                    '''.format(idx, recent_post.user_name, recent_post.title,
                               os.path.join(SITE_CFG['site_url'], router_post[key],
                                            recent_post.uid))
                email_cnt = email_cnt + foo_str
            else:
                foo_str = '''
                    <tr><td>{0}</td><td>{1}</td><td class="diff_add">New </td><td>{2}</td>
                    <td><a href="{3}">{3}</a></td></tr>
                    '''.format(idx, recent_post.user_name, recent_post.title,
                               os.path.join(SITE_CFG['site_url'], router_post[key],
                                            recent_post.uid))
                email_cnt = email_cnt + foo_str
            idx = idx + 1

    return email_cnt, idx
635940
public static MozuUrl getApplicationSummaryChildrenUrl(String appId)
	{
		UrlFormatter formatter = new UrlFormatter("/api/platform/appdev/apppackages/apps/{appId}/");
		formatter.formatUrl("appId", appId);
		return new MozuUrl(formatter.getResourceUrl(), MozuUrl.UrlLocation.TENANT_POD) ;
	}
604822
def get_review_comment(self, id):
        
        assert isinstance(id, (int, long)), id
        headers, data = self._requester.requestJsonAndCheck(
            "GET",
            self._parentUrl(self.url) + "/comments/" + str(id)
        )
        return github.PullRequestComment.PullRequestComment(self._requester, headers, data, completed=True)
1191415
def get_views(self, app_id, include_standard_views=False):
        
        include_standard = "true" if include_standard_views is True else "false"
        return self.transport.GET(url='/view/app/{}/?include_standard_views={}'.format(app_id, include_standard))
1016388
def get_first_category(app_uid):
        '''
        
        '''
        recs = MPost2Catalog.query_by_entity_uid(app_uid).objects()
        if recs.count() > 0:
            return recs.get()

        return None
584158
def recent_reviews(params = {})
      skip_cropped = params.delete(:skip_cropped) || false
      data = request("/review/recent_reviews", params)
      return unless data["reviews"] && data["reviews"].key?("review")
      reviews = data["reviews"]["review"].map { |r| Hashie::Mash.new(r) }
      reviews = reviews.select { |r| !r.body.include?(r.url) } if skip_cropped
      reviews
    end