places_scout 0.2.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f468cfc1af5525677fca6bc11d2b44f06b8efa48
-  data.tar.gz: 5e9d854364d7f21d466acf8c17e9c17d9b2073f1
+  metadata.gz: 27ecdc11ba39810414a4caefcc71c3f6fbc8d754
+  data.tar.gz: f45ffc2edb7af62378c639a724b30f65dad36696
 SHA512:
-  metadata.gz: 1afacba91e4525ecb062ddcd6ba3a5c6237d18bf054e8843c427cc7367397c0a6a536d9f54d4b50fc84d9742a9775f8b841d44f409d212e4361def11c39d173e
-  data.tar.gz: 6f85e09a03769e81d7bbcccdc598f86a2123d72625ac43eaef66d2458053f89f2ba3b4190c9d6756d8de9875fd55d732086599c88eaa0b0c85fc16ed51487bce
+  metadata.gz: 3c0943743624ace0f8eb41e9b418e007284b3f5800830e9d9280c5771ff1181c882cf1cab99b936795420bba3ffd2d773e1780ab42224c158e73d5ccb9317edc
+  data.tar.gz: f1166504a71bb71aa0267cedabfa81a8acdde20a312fd2b1e6331d0f218c645a9073a2b6d82cd3c069c01690341305745dcbeab1f83fa7849e9aecac4231ac2f

data/README.md

@@ -29,12 +29,19 @@ get_ranking_reports(:size => '5', page => '5') # Returns only the 5th page
 ```
 ### Connecting to the API
 ```ruby
-testcon = PlacesScout::Api.new("username", "password")
+opts = {}
+opts[:username] = "<username>"
+opts[:password] = "<password>"
+testcon = PlacesScout::Api.new(opts)
 ```
 ### Clients
 ```ruby
 testcon.get_clients()   # Grab all clients. 
+testcon.get_clients(:names_and_ids => true) # Just get names and ids
 testcon.get_clients(:clientid => 'client-id') #Grab specific client
+testcon.create_client(:Name => 'test company',:CustomClientId => 'XXX' , :PrimaryEmail => 'test@test.com', :Website => 'www.test.com')
+testcon.update_client(:clientid => 'client-id', :Name => 'test company',:CustomClientId => 'XXX' , :PrimaryEmail => 'test@test.com', :Website => 'www.test.com')
+testcon.delete_client(:clientid => 'client-id')
 ```
 ### Locations
 ```ruby
@@ -42,126 +49,227 @@ testcon.get_client_locations()   # Grab all client locations.
 testcon.get_client_locations(:clientid => 'client-id') #Grab locations for specific client
 testcon.get_client_locations(:locationid => 'location-id') #Grab by location id
 ```
+# Create client location
+opts[:clientid] 
+opts[:locationid] 
+opts[:BusinessName]
+opts[:LocationName]
+opts[:StreetAddress] 
+opts[:StreetAddress2] 
+opts[:City] 
+opts[:State] 
+opts[:Zip] 
+opts[:Country]
+opts[:Phone] 
+opts[:Email] 
+opts[:CustomLocationId] 
+opts[:Region] 
+opts[:StoreNumber]
+opts[:PlusLocalPageLink] 
+opts[:ListingSites] 
+opts[:YextApiKey] 
+opts[:YextCustomerId] 
+opts[:YextLocationId] 
+opts[:LocationGroupId] 
+```ruby
+opts = {}
+opts[:clientid] = '<client-id>'
+opts[:LocationName] = "Location Name"
+puts testcon.create_client_location(opts)
+```
+# Delete client location
+```ruby
+ opts = {}
+ opts[:LocationId] = '<location-id>'
+ puts testcon.delete_client_location(opts)
+```
 ### Folders
 ```ruby
 testcon.get_client_folders()#Grab all client folders.
 testcon.get_client_folders(:clientid => 'client-id') #Grab folder off client id
 ```
 ### Rank Reports
+# GET /rankingreports
+All rank reports, or for client or location
+```ruby
+opts = {}
+``` 
+  Optional
+  opts[:locationid] = '<location-id>' <-- Doesn't restrict results, might not be working on API end
+  opts[:clientid] = '<client-id>'
 ```ruby
-testcon.get_ranking_reports #Grab a list of all ranking reports. 
-testcon.get_ranking_reports(:all => true) #Grab all ranking report data. 
-testcon.get_ranking_reports(:clientid => 'client-id') #Grab Rank reports for a specific client
-testcon.get_ranking_reports(:clientid => 'client-id', :locationid=> 'location-id') # Grab specific location for specific client
-testcon.get_ranking_reports(:reportid => 'report-id') #Grab a specific ranking report
-testcon.get_ranking_reports(:reportid => 'report-id', :historical => true) #Return chart for average rankings over time 
-testcon.get_ranking_reports(:reportid => 'report-id', :historical => true, :keywords => true) #Return chart for keyword rankings over time
-testcon.get_ranking_reports(:reportid => 'report-id', :rundates => true) # Return run dates and ID's for a report
-testcon.get_ranking_reports(:reportid => 'report-id', :runs => true) #Grab the runs for a report
-testcon.get_ranking_reports(:reportid => 'report-id', :runs => true, :runid => 'run-id') #Grab a specific report run
-testcon.get_ranking_reports(:reportid => 'report-id', :runs => true, :runid => 'run-id', :keywordresults => true) #Grab a specific report run keyword results
-testcon.get_ranking_reports(:reportid => 'report-id', :runs => true, :runid => 'run-id', :keywordresults => true, :keywordresultsid => 'keyword-results-id') #Grab a specific keyword result for a specific report run 
-testcon.get_ranking_reports(:reportid => 'report-id', :runs => true, :runid => 'run-id', :keywordserpscreenshot => 'adhesion treatment' , :googlelocation => 'San Luis Obispo, CA') #Google Organic SERP Page
-testcon.get_ranking_reports(:reportid => 'report-id', :runs => true, :runid => 'run-id', :summary => true) # Grab summary metrics
-testcon.get_ranking_reports(:reportid => 'report-id', :runs => true, :newest => true) # Grab newest if :newest => true. Grab oldest if :newest => false
+puts testcon.get_ranking_reports(opts)
 ```
 
-### Status
+# GET /rankingreports/{clientId}/allbyclient
+All rank reports for client
 ```ruby
-testcon.get_status #Grab the status of all reports
+opts = {}
+opts[:clientid] = '<client-id>'
+puts testcon.get_ranking_reports(opts)
 ```
-## Sample Code
-```ruby
-clients = get_clients_and_ids(testcon) #Grab all clients
-add_report_ids(clients, testcon) #Grab report ID's per client
-add_report_run_ids(clients, testcon) # Grab run  per report
-get_run_rankings(clients, testcon) # Grab results per run
-puts clients[0][:reports][0][:runs][0][:rankings][0] # Return first client, report, run, keyword ranks
-
-
-def get_clients_and_ids(testcon)
-    clients = []
-    results = testcon.get_clients()  
-
-    results.each do |result|
-        result['items'].each do |item|
-          clients.push(:name => item['name'], :id => item['id'])
-        end
-    end
-
-    return clients
-end
-
-def add_report_ids(clients, testcon)
-    clients.each do |client|
-        report_ids = []
-        rankings = testcon.get_ranking_reports(:clientid => client[:id])
-        rankings.each do |rank|
-            rank['items'].each do |item|
-                report_ids.push(:id => item['rankingReport']['id']) 
-            end
-        end
-        client[:reports] = report_ids
-    end
-    return clients
-end
-
-def add_report_run_ids(clients, testcon)
-    clients.each do |client|
-        run_id_date = []
-        client[:reports].each do |report|
-            report_runs = testcon.get_ranking_reports(:reportid => report[:id], :rundates => true)
-                report_runs.each do |runs|
-                    runs['items'].each do |run|
-                        run_id_date.push(:runID => run['runId'], :runDate => parse_date(run['runDate']))
-                    end
-                end
-             report[:runs] = run_id_date
-        end
-    end
-end
-
-def get_run_rankings(clients, testcon)
-    clients.each do |client|
-        client[:reports].each do |report|            
-            report[:runs].each do |run|
-            keyword_rankings = []
-                report_runs = testcon.get_ranking_reports(:reportid => report[:id], :runs => true, :runid => run[:runID])
-                    report_runs.each do |report_run|
-                        report_run['keywordRankingResults'].each do |results|
-                            results[1].each do |result|
-                                google_rankings = []
-                                bing_rankings = []
-                                result['keywordSearch']['keyword']
-
-                                result['googleOrganicRankings'].each do |g_rank|
-                                    google_rankings.push(g_rank['rank'])
-                                end
-
-                                result['bingOrganicRankings'].each do |b_rank|
-                                    bing_rankings.push(b_rank['rank'])
-                                end
-
-                                keyword_rankings.push(:keyword => result['keywordSearch']['keyword'], :google_rank => google_rankings, :bing_rank => bing_rankings)
-
-                            end
-                        end
-                    end
-                run[:rankings] = keyword_rankings
-            end
-        end
-    end
-end
-
-
-def parse_date(datestring)
-  seconds_since_epoch = datestring.scan(/[0-9]+/)[0].to_i / 1000.0
-  return Time.at(seconds_since_epoch)
-end
-
+# GET /rankingreports/{ReportId}
+Returns the ranking report configuration data for the given RankingReportId
+```ruby
+opts = {}
+opts[:ReportId] = '<report-id>'
+puts testcon.get_ranking_reports(opts)
+```
+# GET /rankingreports/{ReportId}/historical
+Returns historical data that can be used to display charts over time for the given RankingReportId
+```ruby
+opts = {}
+opts[:ReportId] = '<report-id>'
+opts[:historical] = true
+puts testcon.get_ranking_reports(opts)
+```
+# GET /rankingreports/{ReportId}/historical/keywords
+Returns historical data for each keyword search that can be used to display charts over time for the given RankingReportId
+```ruby
+opts = {}
+opts[:ReportId] = '<report-id>'
+opts[:historical] = true
+opts[:keywords] = true
+puts testcon.get_ranking_reports(opts)
+```
+# GET /rankingreports/{ReportId}/rundatesandids
+Returns report run ids and dates
+```ruby
+opts = {}
+opts[:ReportId] = '<report-id>'
+opts[:rundatesandids] = true
+puts testcon.get_ranking_reports(opts)
+```
+# GET /rankingreports/{ReportId}/runs
+Returns all runs of a report
+```ruby
+opts = {}
+opts[:ReportId] = '<report-id>'
+opts[:runs] = true
+puts testcon.get_ranking_reports(opts)
+```
+# GET /rankingreports/{ReportId}/runs/{reportRunId}
+Returns a ranking report run based on the passed ReportRunId
+```ruby
+opts = {}
+opts[:ReportId] = '<report-id>'
+opts[:reportRunId] = '<report-run-id>'
+puts testcon.get_ranking_reports(opts)
+```
+# GET /rankingreports/{ReportId}/runs/{reportRunId}/keywordsearchresults
+Returns a list of all keyword search results for a given ranking report run
+```ruby
+opts = {}
+opts[:ReportId] = '<report-id>'
+opts[:reportRunId] = '<report-run-id>'
+opts[:keywordsearchresults] = true
+puts testcon.get_ranking_reports(opts)
+```
+# GET /rankingreports/{ReportId}/runs/{reportRunId}/keywordsearchresults/{keywordSearchResultsId}
+Returns a list of all keyword search results for a given ranking report run
+```ruby
+opts = {}
+opts[:ReportId] = '<report-id>'
+opts[:reportRunId] = '<report-run-id>'
+opts[:keywordsearchresults] = true
+opts[:KeywordSearchResultsId] = '<report-run-id>-surgery-for-adhesions-san-luis-obispo-ca'
+puts testcon.get_ranking_reports(opts)
+```
+# GET /rankingreports/{ReportId}/runs/{reportRunId}/keywordserpscreenshot
+Returns a byte array of image data for the first Google Organic SERP Page for the provided ReportId, reportRunId, keyword, and location setting if the ranking report is configured to gather screenshots
+```ruby
+opts = {}
+opts[:ReportId] = '<report-id>'
+opts[:reportRunId] = '<report-run-id>'
+opts[:keywordsearchresults] = true
+opts[:GoogleLocation] = ''
+puts testcon.get_ranking_reports(opts)
+```
+# GET /rankingreports/{ReportId}/runs/{reportRunId}/summarymetrics
+Returns the ranking summary metrics for the passed ReportRunId
+```ruby
+opts = {}
+opts[:ReportId] = '<report-id>'
+opts[:reportRunId] = '<report-run-id>'
+opts[:summarymetrics] = true
+puts testcon.get_ranking_reports(opts)
+```
+# GET /rankingreports/{ReportId}/runs/newest
+Returns the newest runs of a report
+```ruby
+opts = {}
+opts[:ReportId] = '<report-id>'
+opts[:age] = "oldest" || "newest"
+puts testcon.get_ranking_reports(opts)
+```
+# GET /rankingreports/all
+Retrieving all ranking report data
+```ruby
+opts = {}
+opts[:all] = true
+puts testcon.get_ranking_reports(opts)
+```
+# POST /rankingreports/{ReportId}/runreport
+Run a ranking report
+```ruby
+opts = {}
+opts[:ReportId] = '<report-id>'
+puts testcon.run_ranking_report(opts)
 ```
 
+# DELETE /rankingreports/{ReportId}
+```ruby
+opts = {}
+opts[:ReportId] = '<report-id>'
+puts testcon.delete_ranking_report(opts)
+```
 
+###Reputation Reports
+ ```ruby
+ opts = {}
+ opts[:clientid] = '<client-id>'
+ opts[:ReportId] = '<report-id>'
+ opts[:reportRunId] = '<report-run-id>'
+ opts[:historical] = true
+ opts[:newreviews] = true
+ opts[:reviews] = true
+ opts[:source] = "Yelp"
+ opts[:rundatesandids] = true
+ opts[:runs] = true
+puts testcon.get_reputation_reports(opts)
+ ```
+
+## POST /reputationreports/{reportId}/runreport
+ Runs the passed reputation report, placing the request in the queue to run the report
+  ```ruby
+ opts = {}
+ opts[:ReportId] = '<report-id>'
+ opts[:FullScrape] = true
+ puts testcon.run_reputation_report(opts)
+ ```
+
+## Delete Reputation Report or Reputation Report Run
+ Pass a report id to delete the report and all runs, add a run id to only delete that run.
+  ```ruby
+ opts = {}
+ opts[:ReportId] = '<report-id>'
+ opts[:ReportRunId] = '<report-run-id>'
+ puts testcon.delete_reputation_report(opts)
+ ```
+
+
+###Combined Reports
+# GET /combinedclientreports
+ All rank reports, or for client or location
+```ruby
+opts = {}
+opts[:clientid] = '<client-id>' 
+puts testcon.get_combined_reports(opts)
+```
+### Status
+```ruby
+testcon.get_status #Grab the status of all reports
+```
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. You can also run `bin/console` for an interactive prompt that will allow you to experiment.

data/lib/places_scout.rb

@@ -11,125 +11,246 @@ module PlacesScout
   # RestClient.log = 'stdout' #Debugging API calls
     MAX_PAGE_SIZE = '100'
 
-    def initialize(u, p)
+    def initialize(opts = {})
       @url = 'https://apihost1.placesscout.com'
-      @auth = 'Basic ' + Base64.encode64(u + ':' + p).chomp      
+      @auth = 'Basic ' + Base64.encode64(opts[:username] + ':' + opts[:password]).chomp      
     end
 
     def parse_json(response)
-      body = JSON.parse(response.to_str) if response.code == 200
+      body = JSON.parse(response.to_str) if response.code == 200 || response.code == 201
       OpenStruct.new(code: response.code, body: body)
     end
 
+    def set_params(opts = {})
+      params = {}
+      #Result params
+        params[:size] = opts[:size] || MAX_PAGE_SIZE
+        params[:path] = opts[:path] if opts[:path]
+        params[:page] = opts[:page] || 1
+      #Client params
+        params[:Name] = opts[:Name] if opts[:Name]  #String
+        params[:CustomClientId] = opts[:CustomClientId] if opts[:CustomClientId] #String
+        params[:PrimaryEmail] = opts[:PrimaryEmail] if opts[:PrimaryEmail] #String
+        params[:Website] = opts[:Website] if opts[:Website] #String
+        params[:Industry] = opts[:Industry] if opts[:Industry]  #String
+        params[:Categories] = opts[:Categories] if opts[:Categories] #List
+        params[:ClientYextSettings] = opts[:ClientYextSettings] if opts[:ClientYextSettings]
+        params[:GoogleAccountId] = opts[:GoogleAccountId] if opts[:GoogleAccountId] #String
+        params[:GoogleWebPropertyId] = opts[:GoogleWebPropertyId] if opts[:GoogleWebPropertyId] #String
+        params[:GoogleProfileId] = opts[:GoogleProfileId] if opts[:GoogleProfileId]  #String
+        params[:GoogleAnalyticsReportSections] = opts[:GoogleAnalyticsReportSections] if opts[:GoogleAnalyticsReportSections] #List
+      #Location params
+        params[:clientid] = opts[:clientid] if opts[:clientid]
+        params[:locationid] = opts[:locationid] if opts[:locationid]
+        params[:BusinessName] = opts[:BusinessName] if opts[:BusinessName]
+        params[:LocationName] = opts[:LocationName] if opts[:LocationName]
+        params[:StreetAddress] = opts[:StreetAddress] if opts[:StreetAddress]
+        params[:StreetAddress2] = opts[:StreetAddress2] if opts[:StreetAddress]
+        params[:City] = opts[:City] if opts[:City]
+        params[:State] = opts[:State] if opts[:State]
+        params[:Zip] = opts[:Zip] if opts[:Zip]
+        params[:Country] = opts[:Country] if opts[:Country]
+        params[:Phone] = opts[:Phone] if opts[:Phone]
+        params[:Email] = opts[:Email] if opts[:Email]
+        params[:CustomLocationId] = opts[:CustomLocationId] if opts[:CustomLocationId]
+        params[:Region] = opts[:Region] if opts[:Region]
+        params[:StoreNumber] = opts[:StoreNumber] if opts[:StoreNumber]
+        params[:PlusLocalPageLink] = opts[:PlusLocalPageLink] if opts[:PlusLocalPageLink]
+        params[:ListingSites] = opts[:ListingSites] if opts[:ListingSites]
+        params[:YextApiKey] = opts[:YextApiKey] if opts[:YextApiKey]
+        params[:YextCustomerId] = opts[:YextCustomerId] if opts[:YextCustomerId]
+        params[:YextLocationId] = opts[:YextLocationId] if opts[:YextLocationId]
+        params[:LocationGroupId] = opts[:LocationGroupId] if opts[:LocationGroupId]
+      #Ranking Reports
+        params[:Keyword] = opts[:keywordserpscreenshot] if opts[:keywordserpscreenshot]
+        params[:GoogleLocation] = opts[:googlelocation] if opts[:googlelocation]
+      #Reputation Reports
+        params[:FullScrape] = opts[:FullScrape] if opts[:FullScrape]     
+
+      return params
+    end
+
+    def get_responses(opts = {})
+      responses = []
+      params = set_params(opts)
+      response = parse_json(RestClient.get(@url+opts[:path], params: params,:content_type => 'application/json', :accept => 'application/json', :Authorization => @auth)).body
+      
+      total_records = response["total"] || 1
+      size = response["size"] || 1
+      total_pages = (total_records.to_f/size).ceil || 1             
+
+      while total_pages > 0
+        response = (opts[:data]) ? response[opts[:data]] : response 
+        responses.push(response)
+        params[:page] += 1 unless opts[:page]
+        total_pages -= 1     
+        response = parse_json(RestClient.get(@url+params[:path], params: params,:content_type => 'application/json', :accept => 'application/json', :Authorization => @auth)).body unless total_pages < 1            
+      end
+
+      return responses.flatten! || responses
+    end
+
 # /clients
     def get_clients( opts = {})
+        opts[:path] = "/clients/#{opts[:clientid] || ((opts[:names_and_ids]) ? "namesandids" : "")}"
+        opts[:data] = "items" unless opts[:clientid]       
+        return get_responses(opts) 
+    end
+
+    def create_client( opts = {})
+        params = set_params(opts)
+        path = "/clients"
+        response = parse_json(RestClient.post(@url+path, params ,:content_type => 'application/json', :accept => 'application/json', :Authorization => @auth))
+        return response 
+    end
+
+    def update_client( opts = {})
+        params = set_params(opts)
         path = "/clients/#{opts[:clientid]}"
-        results = []
-        params = {}
-        params[:page] = opts[:page] || 1
-        params[:size] = opts[:size] || MAX_PAGE_SIZE
-        total_size = parse_json(RestClient.get(@url+path, params: params, :content_type => 'application/json', :accept => 'application/json', :Authorization => @auth)).body['total'] || 1
-        total_pages = (opts[:page]) ? 1 : (total_size/params[:size].to_f).ceil  
-    
-        while total_pages > 0      
-          response = parse_json(RestClient.get(@url+path, params: params, :content_type => 'application/json', :accept => 'application/json', :Authorization => @auth)).body
-          results.push(response)
-          params[:page] += 1 unless opts[:page]
-          total_pages -= 1
-        end
+        return parse_json(RestClient.put(@url+path, params,:content_type => 'application/json', :accept => 'application/json', :Authorization => @auth)).body 
+    end
 
-        return results
+    def delete_client ( opts = {} )
+      if opts[:clientid]
+        path = "/clients/#{opts[:clientid]}"
+        return RestClient.delete(@url+path, :Authorization => @auth)
+      else
+        return "Must pass client id"
+      end
     end
 
 # Client Locations
     def get_client_locations( opts = {})
-      path = "/clientlocations/#{opts[:locationid]}"
-      results = []
-      params = {}
-      params[:page] = opts[:page] || 1
-      params[:size] = opts[:size] || MAX_PAGE_SIZE
-      params[:clientid] = opts[:clientid]
-      location = opts[:locationid]
-      total_size = parse_json(RestClient.get(@url+path, params: params, :content_type => 'application/json', :accept => 'application/json', :Authorization => @auth)).body['total'] || 1
-      total_pages = (opts[:page]) ? 1 : (total_size/params[:size].to_f).ceil  
+      opts[:path] = "/clientlocations/#{opts[:locationid]}"
+      opts[:data] = "items" unless opts[:locationid]   
+      return get_responses(opts) 
+    end
 
-      while total_pages > 0
-        response = parse_json(RestClient.get(@url+path, params: params, :content_type => 'application/json', :accept => 'application/json', :Authorization => @auth)).body
-        results.push(response)
-        params[:page] += 1 unless opts[:page]
-        total_pages -= 1
+    def create_client_location( opts = {})
+      params = set_params(opts)
+      path = "/clientlocations"
+      response = parse_json(RestClient.post(@url+path, params ,:content_type => 'application/json', :accept => 'application/json', :Authorization => @auth))
+      return response 
+    end
+
+    def delete_client_location ( opts = {} )
+      if opts[:LocationId]
+        path = "/clientlocations/#{opts[:LocationId]}"
+        return RestClient.delete(@url+path, :Authorization => @auth)
+      else
+        return "Must pass location id"
       end
-      return results
     end
 
 # /folders
-    def get_client_folders( opts = {})
-        results = []
-        params = {}
-        params[:page] = opts[:page] || 1
-        params[:size] = opts[:size] || MAX_PAGE_SIZE
-        params[:clientid] = opts[:clientid] 
-        path =  "/clientfolders"
-        total_size = parse_json(RestClient.get(@url+path, params: params, :content_type => 'application/json', :accept => 'application/json', :Authorization => @auth)).body['total'] || 1
-        total_pages = (opts[:page]) ? 1 : (total_size/params[:size].to_f).ceil  
-
-        while total_pages > 0      
-          response = parse_json(RestClient.get(@url+path, params: params, :content_type => 'application/json', :accept => 'application/json', :Authorization => @auth)).body 
-          results.push(response)
-          params[:page] += 1 unless opts[:page]
-          total_pages -= 1
-        end
-        return results
+    def get_client_folders( opts = {})  
+      opts[:path] =  "/clientfolders"
+      opts[:data] = "items"
+      return get_responses(opts) 
     end
 
+# /combinedreports
+def get_combined_reports( opts = {})
+  opts[:path] =  "/combinedclientreports"
+  opts[:data] = "items"
+  return get_responses(opts) 
+end
+
 # /rankingreports
       def get_ranking_reports( opts = {})
-        results = []
-        params = {}
-        reportid = "/#{opts[:reportid]}" || ""
-        params[:locationid] = opts[:locationid] || ""
-        params[:clientid] = opts[:clientid] || ""
-        all = (opts[:all]) ? "/all" : ""
-        historical = (opts[:historical] && opts[:reportid] && all == "") ? "/historical" : ""
-        keywords = (opts[:historical] && opts[:reportid] && opts[:keywords] && all == "") ? "/keywords" : ""
-        rundates = (opts[:rundates] && opts[:reportid] && all == "") ? "/rundatesandids" : ""
-        runs = (opts[:runs] && opts[:reportid] && rundates == "" && all == "") ? "/runs" : ""
-        runid = (opts[:runid] && opts[:runs] && rundates == "" && all == "") ? "/#{opts[:runid]}" : ""
-        summary = (opts[:summary] && opts[:runid] && opts[:runs] && rundates == "" && all == "") ? "/summarymetrics" : ""
-        keywordresults = (opts[:keywordresults] && opts[:runid] && opts[:runs] && opts[:reportid] && rundates =="" && summary == "" && all == "") ? "/keywordsearchresults" : ""
-        keywordresultsid = (opts[:keywordresultsid] && opts[:keywordresults] && opts[:runid] && opts[:runs] && opts[:reportid] && rundates =="" && summary == "" && all == "") ? "/#{opts[:keywordresultsid]}" : ""
-        keywordserpscreenshot = (opts[:runid] && opts[:runs] && opts[:reportid] && opts[:googlelocation] && rundates == "" && keywordresults == "" && keywordresultsid == "" && summary == "" && all == "") ? "/keywordserpscreenshot" : ""
-        
-        newest = case opts[:newest]
-                  when opts[:newest] = true  
-                      "/newest"
-                  when opts[:newest] = false
-                      "/oldest"
-                  else
-                      ""
-                 end
-
-        path = (opts[:clientid] && params[:locationid] == "" && all == "") ? "/rankingreports/#{opts[:clientid]}/allbyclient" : "/rankingreports#{all}#{reportid}#{rundates}#{runs}#{newest}#{runid}#{summary}#{historical}#{keywords}#{keywordresults}#{keywordresultsid}#{keywordserpscreenshot}"     
-        params[:Keyword] = opts[:keywordserpscreenshot] if opts[:keywordserpscreenshot]
-        params[:GoogleLocation] = opts[:googlelocation] if opts[:googlelocation]
-        params[:page] = opts[:page] || 1
-        params[:size] = opts[:size] || MAX_PAGE_SIZE
-        total_size = parse_json(RestClient.get(@url+path, params: params, :content_type => 'application/json', :accept => 'application/json', :Authorization => @auth)).body['total'] || 1
-        total_pages = (opts[:page] || opts[:locationid]) ? 1 : (total_size/params[:size].to_f).ceil        
-        
-        while total_pages > 0  
-          response = parse_json(RestClient.get(@url+path, params: params, :content_type => 'application/json', :accept => 'application/json', :Authorization => @auth)).body
-          results.push(response)
-          params[:page] += 1 unless opts[:page]
-          total_pages -= 1
+
+        opts[:path] = "/rankingreports/"
+
+        if opts[:clientid]
+          opts[:path] += "#{opts[:clientid]}/allbyclient"
+        elsif opts[:ReportId]
+          opts[:path] += "#{opts[:ReportId]}/"
+            if opts[:historical]
+              opts[:path] += "historical"
+              opts[:path] += "/keywords" if opts[:keywords]
+            elsif  opts[:rundatesandids]
+              opts[:path] += "rundatesandids"
+            elsif opts[:runs] || opts[:reportRunId]
+              opts[:path] += "runs/#{opts[:age]}"
+              if opts[:reportRunId] && opts[:age].nil?
+                opts[:path] += "/#{opts[:reportRunId]}"
+                opts[:path] += "/keywordsearchresults" if opts[:keywordsearchresults]
+                opts[:path] += "/#{opts[:KeywordSearchResultsId]}" if opts[:KeywordSearchResultsId]
+                opts[:path] += "/summarymetrics" if opts[:summarymetrics]
+              end
+            end 
+        elsif opts[:all]
+          opts[:path] += "all"
         end
-        return results     
+  
+        opts[:data] = "items" unless (opts[:ReportId] && opts[:runs].nil? && opts[:rundatesandids].nil? && opts[:keywordsearchresults].nil?) || opts[:KeywordSearchResultsId]
+
+        return get_responses(opts)            
+    end
+
+    def run_ranking_report( opts = {})
+      path = "/rankingreports/#{opts[:ReportId]}/runreport"
+      params = {:ReportId => opts[:ReportId]}
+      response = RestClient.post(@url+path, params ,:content_type => 'application/json', :accept => 'application/json', :Authorization => @auth)
+      return response 
+    end
+
+    def delete_ranking_report ( opts = {} )
+      path = "/rankingreports/#{opts[:ReportId]}"
+      path += "/runs/#{opts[:reportRunId]}" if opts[:reportRunId]
+      return RestClient.delete(@url+path, :Authorization => @auth)   
+    end
+
+    #Reputation Reports
+
+    def get_reputation_reports ( opts = {})
+      opts[:path] = "/reputationreports/"
+
+      if opts[:clientid]
+       opts[:path] += "#{opts[:clientid]}/allbyclient"
+      elsif opts[:ReportId]
+        opts[:path] += "#{opts[:ReportId]}/"
+          if opts[:historical]
+            opts[:path] += "historical"
+          elsif opts[:newreviews]
+            opts[:path] += "newreviews" 
+          elsif opts[:reviews] || opts[:source] 
+            opts[:path] += "reviews" 
+            opts[:path] += "/#{opts[:source]}"if opts[:source] 
+          elsif  opts[:rundatesandids]
+            opts[:path] += "rundatesandids" 
+          elsif opts[:runs] || opts[:reportRunId]
+            opts[:path] += "runs"
+            opts[:path] += "/#{opts[:reportRunId]}" if opts[:reportRunId]
+            opts[:path] += "/newest" if opts[:newest]
+            opts[:path] += "/oldest" if opts[:oldest]
+          end
+
+      else
+        opts[:path] += "all"
+      end
+
+      opts[:data] = "items" unless (opts[:ReportId] && opts[:reviews].nil? && opts[:rundatesandids].nil?)
+      return get_responses(opts) 
+
+    end
+
+    def run_reputation_report( opts = {})
+      path = "/reputationreports/#{opts[:ReportId]}/runreport"
+      params = set_params(opts)
+      response = RestClient.post(@url+path, params ,:content_type => 'application/json', :accept => 'application/json', :Authorization => @auth)
+      return response 
+    end
+
+    def delete_reputation_report ( opts = {} )
+      path = "/reputationreports/#{opts[:ReportId]}"
+      path += "/runs/#{opts[:reportRunId]}" if opts[:reportRunId]
+      return RestClient.delete(@url+path, :Authorization => @auth)   
     end
 
     def get_status( opts = {})
       results = []
       params = {}
-      reportid = "/#{opts[:reportid]}" || ""
       path = "/status/getreportstatus"
       response = parse_json(RestClient.get(@url+path, params: params, :content_type => 'application/json', :accept => 'application/json', :Authorization => @auth)).body
     end

data/lib/places_scout/version.rb

@@ -1,3 +1,3 @@
 module PlacesScout
-  VERSION = "0.2.0"
+  VERSION = "1.0.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: places_scout
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 1.0.0
 platform: ruby
 authors:
 - Michael Hoskison
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-12-27 00:00:00.000000000 Z
+date: 2018-02-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -104,7 +104,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.1
+rubygems_version: 2.6.8
 signing_key: 
 specification_version: 4
 summary: Used to access the Places Scout api