Retrieve Twitter Hashtag Streams for a campaign

 param [Integer] campaign_id The ID of the campaign to fetch the twitter hashtag stream for.
 @param [Hash]  options
543731
def twitter_hashtag_streams(campaign_id, options={})
      response = connection.get do |req|
        req.url "campaigns/#{campaign_id}/twitter_hashtag_streams", options
      end
      return_error_or_body(response)
    end
1360071
def complete(self, campaign_id):
        

        return super(API, self).get(
            resource_id=campaign_id, resource_action='complete')
745397
def results(self, campaign_id):
        
        return super(API, self).get(
            resource_id=campaign_id,
            resource_action='results',
            resource_cls=CampaignResults)
583238
def applications_url(options = {})
      invalid_options = options.keys - VALID_OPTIONS
      if !invalid_options.empty?
        raise "Unexpected options used: #{invalid_options.join(',')}"
      end
      options[:street] = options[:street].join(",") if options[:street].respond_to?(:join)
      options[:suburb] = options[:suburb].join(",") if options[:suburb].respond_to?(:join)
      options[:postcode] = options[:postcode].join(",") if options[:postcode].respond_to?(:join)

      q = Feed.options_to_query(options)
      "#{base_url}/applications.json" + (q ? "?#{q}" : "")
    end
1189236
def history_ids(amount, before_id = nil, after_id = nil, around_id = nil)
      logs = API::Channel.messages(@bot.token, @id, amount, before_id, after_id, around_id)
      JSON.parse(logs).map { |message| message['id'].to_i }
    end
537136
def get_playlist(id)
      result = playlists.select { |p| p.id == id }
      result.nil? ? nil : result.first
    end
336442
def _get_inbound_stream(self, stream_id):
        
        if stream_id not in self._inbound_streams:
            self._inbound_streams[stream_id] = InboundStream()
        return self._inbound_streams[stream_id]
841179
def link(event_ids, stream_name:, expected_version: :any)
      repository.link_to_stream(event_ids, Stream.new(stream_name), ExpectedVersion.new(expected_version))
      self
    end
717906
def firehose(self, **params):
        
        url = 'https://stream.twitter.com/%s/statuses/firehose.json' \
              % self.streamer.api_version
        self.streamer._request(url, params=params)
786157
def _get_spark_app_ids(self, running_apps, requests_config, tags):
        
        spark_apps = {}
        for app_id, (app_name, tracking_url) in iteritems(running_apps):
            response = self._rest_request_to_json(
                tracking_url, SPARK_APPS_PATH, SPARK_SERVICE_CHECK, requests_config, tags
            )

            for app in response:
                app_id = app.get('id')
                app_name = app.get('name')

                if app_id and app_name:
                    spark_apps[app_id] = (app_name, tracking_url)

        return spark_apps
1087328
def public_search(*args)
      (args[0]).merge!(:campaign_id => self.id)
      results = ActionKitApi.connection.call("Event.public_search", *args)

      results.map do |r|
        Event.new(r)
      end

      results
    end
66955
def fetch_tag_shas_async(tags)
      i = 0
      threads = []
      print_in_same_line("Fetching SHAs for tags: #{i}/#{tags.count}\r") if @options[:verbose]

      tags.each_slice(MAX_THREAD_NUMBER) do |tags_slice|
        tags_slice.each do |tag|
          threads << Thread.new do
            # Use oldest commit because comparing two arbitrary tags may be diverged
            commits_in_tag = fetch_compare(oldest_commit["sha"], tag["name"])
            tag["shas_in_tag"] = commits_in_tag["commits"].collect { |commit| commit["sha"] }
            print_in_same_line("Fetching SHAs for tags: #{i + 1}/#{tags.count}") if @options[:verbose]
            i += 1
          end
        end
        threads.each(&:join)
        threads = []
      end

      # to clear line from prev print
      print_empty_line

      Helper.log.info "Fetching SHAs for tags: #{i}"
      nil
    end
1339545
def retweets(self, tweet_id):
        
        log.info("retrieving retweets of %s", tweet_id)
        url = "https://api.twitter.com/1.1/statuses/retweets/""{}.json".format(
                tweet_id)

        resp = self.get(url, params={"count": 100})
        for tweet in resp.json():
            yield tweet
823044
def retweet(self, id, delegate):
        
        parser = txml.Statuses(delegate)
        return self.__postPage('/statuses/retweet/%s.xml' % (id), parser)
1006474
public OvhFaxCampaign billingAccount_fax_serviceName_campaigns_id_GET(String billingAccount, String serviceName, Long id) throws IOException {
		String qPath = "/telephony/{billingAccount}/fax/{serviceName}/campaigns/{id}";
		StringBuilder sb = path(qPath, billingAccount, serviceName, id);
		String resp = exec(qPath, "GET", sb.toString(), null);
		return convertTo(resp, OvhFaxCampaign.class);
	}
1134314
def userstream(query_params = {}, &block)
      stream_params = {:host => 'userstream.twitter.com'}
      query_params.merge!(:extra_stream_parameters => stream_params)
      start('/1.1/user.json', query_params, &block)
    end
83943
function getTrendingTags(options, callback) {
    if (!options) options = {};

    return this._request({
      api: '/tags',
      endpoint: '/trending',
      method: 'GET'
    }, callback);
  }