fopost 0.1.0 → 0.3.0

data/lib/fopost/resources/contacts.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+module Fopost
+  module Resources
+    # `client.contacts` — the people behind the inbox, and the fields your
+    # workspace keeps about them.
+    #
+    # A contact is one human however many handles they write from. An inbound
+    # inbox item files its author, a reply files whoever you answered, and both
+    # fold into whatever is already on file. Every method needs the `inbox`
+    # scope, except {#conversation_analytics}, which needs `analytics`.
+    class Contacts < Base
+      # One page of contacts, most recently active first. The result is
+      # Enumerable over its items.
+      #
+      # Omit `workspace_id` to span every workspace the key can reach; each
+      # contact then carries `workspace_id`.
+      def list(workspace_id: nil, search: nil, platform: nil, source: nil, page: 1, per_page: 25)
+        body = http.get(
+          '/contacts',
+          {
+            'workspace_id' => workspace_id,
+            'search' => search,
+            'platform' => platform,
+            'source' => source,
+            'page' => page,
+            'per_page' => per_page
+          }
+        )
+        hash = as_hash(body)
+        raw_meta = hash['pagination']
+        Page.new(
+          items: parse_list(Contact, hash['data']),
+          meta: ContactPageMeta.new(raw_meta.is_a?(Hash) ? raw_meta : {})
+        )
+      end
+
+      def get(contact_id)
+        Contact.new(unwrap(http.get("/contacts/#{contact_id}")))
+      end
+
+      # Create a contact.
+      #
+      # Folds into the contact that already holds the first channel, so this
+      # cannot duplicate someone the inbox has already met.
+      def create(workspace_id:, channels:, display_name: nil, note: nil, fields: nil)
+        body = compact_nil(
+          'workspace_id' => workspace_id,
+          'channels' => channels,
+          'display_name' => display_name,
+          'note' => note,
+          'fields' => fields
+        )
+        Contact.new(unwrap(http.post('/contacts', body)))
+      end
+
+      # Partial update: only what you pass is sent. A custom field set to nil
+      # is cleared.
+      def update(contact_id, display_name: UNSET, channels: UNSET, note: UNSET, fields: UNSET)
+        body = compact_unset(
+          'display_name' => display_name,
+          'channels' => channels,
+          'note' => note,
+          'fields' => fields
+        )
+        Contact.new(unwrap(http.request(:patch, "/contacts/#{contact_id}", json: body)))
+      end
+
+      # Removes a contact. Their messages stay in the inbox and file them again.
+      def delete(contact_id)
+        http.delete("/contacts/#{contact_id}")
+        nil
+      end
+
+      # The threads this person appears in, newest first.
+      def conversations(contact_id, limit: nil)
+        parse_list(
+          ContactConversation,
+          unwrap(http.get("/contacts/#{contact_id}/conversations", { 'limit' => limit }))
+        )
+      end
+
+      # Import from CSV text.
+      #
+      # `platform` and `handle` are required columns. Any other column is read
+      # as a custom field key, and one matching no field comes back in
+      # `unknown_columns` rather than being stored.
+      def import(workspace_id:, csv:)
+        ContactImportResult.new(
+          unwrap(http.post('/contacts/import', { 'workspace_id' => workspace_id, 'csv' => csv }))
+        )
+      end
+
+      # The columns this workspace keeps about its contacts, in display order.
+      def list_fields(workspace_id)
+        parse_list(ContactField, unwrap(http.get('/contacts/fields', { 'workspace_id' => workspace_id })))
+      end
+
+      def create_field(workspace_id:, key:, name:, type: 'text', options: [])
+        ContactField.new(unwrap(http.request(
+                                  :post,
+                                  '/contacts/fields',
+                                  json: { 'key' => key, 'name' => name, 'type' => type, 'options' => options },
+                                  params: { 'workspace_id' => workspace_id }
+                                )))
+      end
+
+      # The key and the type are fixed once created; the name and options are not.
+      def update_field(field_id, name: UNSET, options: UNSET, position: UNSET)
+        body = compact_unset('name' => name, 'options' => options, 'position' => position)
+        ContactField.new(unwrap(http.request(:patch, "/contacts/fields/#{field_id}", json: body)))
+      end
+
+      # Removes the field and every answer to it.
+      def delete_field(field_id)
+        http.delete("/contacts/fields/#{field_id}")
+        nil
+      end
+
+      # Volume and median reply time per thread. Needs the `analytics` scope.
+      def conversation_analytics(workspace_id: nil, account_id: nil, days: nil, sort: nil, page: 1, per_page: 25)
+        ConversationAnalytics.new(unwrap(http.get(
+                                           '/analytics/inbox/conversations',
+                                           {
+                                             'workspace_id' => workspace_id,
+                                             'accountId' => account_id,
+                                             'days' => days,
+                                             'sort' => sort,
+                                             'page' => page,
+                                             'per_page' => per_page
+                                           }
+                                         )))
+      end
+    end
+  end
+end

data/lib/fopost/resources/google_ads.rb

@@ -0,0 +1,346 @@
+# frozen_string_literal: true
+
+module Fopost
+  module Resources
+    # `client.ads.google` — the Google Ads surface no other network has.
+    #
+    # Campaigns, ad groups, ads, audiences and insights are on `client.ads`
+    # and dispatch by connection. What is here — keywords, assets, Performance
+    # Max asset groups, Local Services leads, conversions and raw GAQL — is
+    # Google only, and a connection on another network answers 400.
+    #
+    # Every method needs the `ads` scope; anything that changes what a live
+    # account serves or bids also needs `publish`. `customer_id` is digits only
+    # and has to name an account the connection's grant reaches.
+    class GoogleAds < Base
+      # ── Keywords ──
+
+      # Keywords on the account, or on one ad group.
+      def keywords(connection_id:, customer_id:, workspace_id: nil, ad_group_id: nil)
+        parse_list(GoogleKeyword, unwrap(http.get(
+                                           '/ads/google/keywords',
+                                           params(connection_id, customer_id, workspace_id,
+                                                  'ad_group_id' => ad_group_id)
+                                         )))
+      end
+
+      # The new keyword's id. Needs `publish` as well as `ads`.
+      def create_keyword(workspace_id:, connection_id:, customer_id:, ad_group_id:, text:, match_type:,
+                         cpc_bid_minor: nil)
+        body = scope(workspace_id, connection_id, customer_id).merge(compact_nil(
+                                                                       'adGroupId' => ad_group_id,
+                                                                       'text' => text,
+                                                                       'matchType' => match_type,
+                                                                       'cpcBidMinor' => cpc_bid_minor
+                                                                     ))
+        id_of(http.post('/ads/google/keywords', body))
+      end
+
+      # `status` is "active" or "paused". Needs `publish` as well as `ads`.
+      def update_keyword(keyword_id, workspace_id:, connection_id:, customer_id:, status: nil, cpc_bid_minor: nil)
+        body = scope(workspace_id, connection_id, customer_id).merge(compact_nil(
+                                                                       'status' => status,
+                                                                       'cpcBidMinor' => cpc_bid_minor
+                                                                     ))
+        id_of(http.request(:patch, "/ads/google/keywords/#{keyword_id}", json: body))
+      end
+
+      # Needs `publish` as well as `ads`.
+      def delete_keyword(keyword_id, workspace_id:, connection_id:, customer_id:)
+        http.request(:delete, "/ads/google/keywords/#{keyword_id}",
+                     json: scope(workspace_id, connection_id, customer_id))
+        nil
+      end
+
+      # Ideas from seed keywords, a landing page, or both.
+      def keyword_ideas(workspace_id:, connection_id:, customer_id:, seeds: nil, url: nil, language_id: nil,
+                        geo_target_ids: nil)
+        body = scope(workspace_id, connection_id, customer_id).merge(compact_nil(
+                                                                       'seeds' => seeds,
+                                                                       'url' => url,
+                                                                       'languageId' => language_id,
+                                                                       'geoTargetIds' => geo_target_ids
+                                                                     ))
+        parse_list(GoogleKeywordIdea, unwrap(http.post('/ads/google/keyword-ideas', body)))
+      end
+
+      def keyword_metrics(workspace_id:, connection_id:, customer_id:, keywords:)
+        body = scope(workspace_id, connection_id, customer_id).merge('keywords' => keywords)
+        parse_list(GoogleKeywordIdea, unwrap(http.post('/ads/google/keyword-metrics', body)))
+      end
+
+      # What people actually searched, with the metrics each term earned.
+      def search_terms(connection_id:, customer_id:, since:, until_date:, workspace_id: nil)
+        parse_list(GoogleSearchTerm, unwrap(http.get(
+                                              '/ads/google/search-terms',
+                                              params(connection_id, customer_id, workspace_id,
+                                                     'since' => since, 'until' => until_date)
+                                            )))
+      end
+
+      # ── Bid strategies and ad schedule ──
+
+      def bid_strategies(connection_id:, customer_id:, workspace_id: nil)
+        parse_list(GoogleBidStrategy, unwrap(http.get(
+                                               '/ads/google/bid-strategies',
+                                               params(connection_id, customer_id, workspace_id)
+                                             )))
+      end
+
+      # Needs `publish` as well as `ads`.
+      def create_bid_strategy(workspace_id:, connection_id:, customer_id:, name:, type:, target_minor: nil)
+        body = scope(workspace_id, connection_id, customer_id).merge(compact_nil(
+                                                                       'name' => name,
+                                                                       'type' => type,
+                                                                       'targetMinor' => target_minor
+                                                                     ))
+        id_of(http.post('/ads/google/bid-strategies', body))
+      end
+
+      def ad_schedule(connection_id:, customer_id:, campaign_id:, workspace_id: nil)
+        parse_list(GoogleAdScheduleSlot, unwrap(http.get(
+                                                  '/ads/google/ad-schedule',
+                                                  params(connection_id, customer_id, workspace_id,
+                                                         'campaign_id' => campaign_id)
+                                                )))
+      end
+
+      # Replaces every slot on the campaign: Google has no partial edit for a
+      # schedule. Needs `publish` as well as `ads`.
+      def set_ad_schedule(workspace_id:, connection_id:, customer_id:, campaign_id:, slots:)
+        body = scope(workspace_id, connection_id, customer_id).merge('campaignId' => campaign_id, 'slots' => slots)
+        result = unwrap(http.request(:put, '/ads/google/ad-schedule', json: body))
+        result.is_a?(Hash) ? result['slots'].to_i : 0
+      end
+
+      # ── Negative keyword lists ──
+
+      def negative_keyword_lists(connection_id:, customer_id:, workspace_id: nil)
+        parse_list(GoogleSharedSet, unwrap(http.get(
+                                             '/ads/google/negative-keywords',
+                                             params(connection_id, customer_id, workspace_id)
+                                           )))
+      end
+
+      # Needs `publish` as well as `ads`.
+      def create_negative_keyword_list(workspace_id:, connection_id:, customer_id:, name:)
+        body = scope(workspace_id, connection_id, customer_id).merge('name' => name)
+        id_of(http.post('/ads/google/negative-keywords', body))
+      end
+
+      # How many were added. Needs `publish` as well as `ads`.
+      def add_negative_keywords(workspace_id:, connection_id:, customer_id:, shared_set_id:, keywords:)
+        body = scope(workspace_id, connection_id, customer_id).merge(
+          'sharedSetId' => shared_set_id, 'keywords' => keywords
+        )
+        result = unwrap(http.post('/ads/google/negative-keywords/keywords', body))
+        result.is_a?(Hash) ? result['added'].to_i : 0
+      end
+
+      # Needs `publish` as well as `ads`.
+      def attach_negative_keyword_list(workspace_id:, connection_id:, customer_id:, shared_set_id:, campaign_id:)
+        body = scope(workspace_id, connection_id, customer_id).merge(
+          'sharedSetId' => shared_set_id, 'campaignId' => campaign_id
+        )
+        http.post('/ads/google/negative-keywords/attach', body)
+        nil
+      end
+
+      # ── Assets ──
+
+      # Returns `{ assets: [...], links: [...] }`; an asset with no links is in
+      # the library and serving nowhere.
+      def assets(connection_id:, customer_id:, workspace_id: nil)
+        result = unwrap(http.get('/ads/google/assets', params(connection_id, customer_id, workspace_id)))
+        result = {} unless result.is_a?(Hash)
+        {
+          assets: parse_list(GoogleAsset, result['assets']),
+          links: parse_list(GoogleAssetLink, result['links'])
+        }
+      end
+
+      # `spec` is a sitelink, callout or snippet. Needs `publish` as well as `ads`.
+      def create_asset(workspace_id:, connection_id:, customer_id:, spec:)
+        body = scope(workspace_id, connection_id, customer_id).merge('spec' => spec)
+        id_of(http.post('/ads/google/assets', body))
+      end
+
+      # Attaches to the account when `campaign_id` is left out. Needs `publish`.
+      def attach_asset(workspace_id:, connection_id:, customer_id:, asset_id:, field_type:, campaign_id: nil)
+        body = scope(workspace_id, connection_id, customer_id).merge(compact_nil(
+                                                                       'assetId' => asset_id,
+                                                                       'fieldType' => field_type,
+                                                                       'campaignId' => campaign_id
+                                                                     ))
+        http.post('/ads/google/assets/attach', body)
+        nil
+      end
+
+      # Removes the links that put it under an ad; on Google the asset itself
+      # is permanent. Needs `publish` as well as `ads`.
+      def delete_asset(asset_id, workspace_id:, connection_id:, customer_id:)
+        http.request(:delete, "/ads/google/assets/#{asset_id}",
+                     json: scope(workspace_id, connection_id, customer_id))
+        nil
+      end
+
+      # ── Performance Max asset groups ──
+
+      def asset_groups(connection_id:, customer_id:, workspace_id: nil, campaign_id: nil)
+        parse_list(GoogleAssetGroup, unwrap(http.get(
+                                              '/ads/google/asset-groups',
+                                              params(connection_id, customer_id, workspace_id,
+                                                     'campaign_id' => campaign_id)
+                                            )))
+      end
+
+      # Starts paused unless `status` says otherwise. Needs `publish`.
+      def create_asset_group(workspace_id:, connection_id:, customer_id:, campaign_id:, name:, final_urls:,
+                             status: nil)
+        body = scope(workspace_id, connection_id, customer_id).merge(compact_nil(
+                                                                       'campaignId' => campaign_id,
+                                                                       'name' => name,
+                                                                       'finalUrls' => final_urls,
+                                                                       'status' => status
+                                                                     ))
+        id_of(http.post('/ads/google/asset-groups', body))
+      end
+
+      # Needs `publish` as well as `ads`.
+      def update_asset_group(asset_group_id, workspace_id:, connection_id:, customer_id:, name: nil, status: nil)
+        body = scope(workspace_id, connection_id, customer_id).merge(compact_nil(
+                                                                       'name' => name,
+                                                                       'status' => status
+                                                                     ))
+        id_of(http.request(:patch, "/ads/google/asset-groups/#{asset_group_id}", json: body))
+      end
+
+      # Needs `publish` as well as `ads`.
+      def delete_asset_group(asset_group_id, workspace_id:, connection_id:, customer_id:)
+        http.request(:delete, "/ads/google/asset-groups/#{asset_group_id}",
+                     json: scope(workspace_id, connection_id, customer_id))
+        nil
+      end
+
+      # ── Local Services leads ──
+
+      # Read live on every call and never stored by FoPost.
+      def local_services_leads(connection_id:, customer_id:, since:, until_date:, workspace_id: nil)
+        parse_list(GoogleLocalServicesLead, unwrap(http.get(
+                                                     '/ads/google/local-services',
+                                                     params(connection_id, customer_id, workspace_id,
+                                                            'since' => since, 'until' => until_date)
+                                                   )))
+      end
+
+      # ── Conversions ──
+
+      def conversion_actions(connection_id:, customer_id:, workspace_id: nil)
+        parse_list(GoogleConversionAction, unwrap(http.get(
+                                                    '/ads/google/conversions',
+                                                    params(connection_id, customer_id, workspace_id)
+                                                  )))
+      end
+
+      # Needs `publish` as well as `ads`.
+      def create_conversion_action(workspace_id:, connection_id:, customer_id:, name:, category:, value_minor: nil,
+                                   counting_type: nil)
+        body = scope(workspace_id, connection_id, customer_id).merge(compact_nil(
+                                                                       'name' => name,
+                                                                       'category' => category,
+                                                                       'valueMinor' => value_minor,
+                                                                       'countingType' => counting_type
+                                                                     ))
+        id_of(http.post('/ads/google/conversions', body))
+      end
+
+      # Offline conversions, matched to a click. Needs `publish` as well as `ads`.
+      def upload_conversions(workspace_id:, connection_id:, customer_id:, conversions:)
+        body = scope(workspace_id, connection_id, customer_id).merge('conversions' => conversions)
+        uploaded(http.post('/ads/google/conversions/upload', body))
+      end
+
+      # Needs `publish` as well as `ads`.
+      def upload_conversion_adjustments(workspace_id:, connection_id:, customer_id:, adjustments:)
+        body = scope(workspace_id, connection_id, customer_id).merge('adjustments' => adjustments)
+        uploaded(http.post('/ads/google/conversions/adjustments', body))
+      end
+
+      # ── Recommendations ──
+
+      # Google's own read on what the account should change next. `types`
+      # narrows to those recommendation types.
+      def recommendations(connection_id:, customer_id:, types: nil, workspace_id: nil)
+        extra = types.nil? || types.empty? ? {} : { 'types' => Array(types).join(',') }
+        parse_list(GoogleRecommendation, unwrap(http.get(
+                                                  '/ads/google/recommendations',
+                                                  params(connection_id, customer_id, workspace_id, extra)
+                                                )))
+      end
+
+      # The account's score and weight, and the score of each live campaign.
+      def optimization_score(connection_id:, customer_id:, workspace_id: nil)
+        GoogleOptimizationScore.new(unwrap(http.get(
+                                             '/ads/google/optimization-score',
+                                             params(connection_id, customer_id, workspace_id)
+                                           )))
+      end
+
+      # Applies each one, which changes what the live account serves or bids.
+      # Needs `publish` as well as `ads`.
+      def apply_recommendations(workspace_id:, connection_id:, customer_id:, ids:)
+        body = scope(workspace_id, connection_id, customer_id).merge('ids' => Array(ids))
+        counted(http.post('/ads/google/recommendations/apply', body), 'applied')
+      end
+
+      # Hides each one so Google stops surfacing it. Needs `publish` as well as `ads`.
+      def dismiss_recommendations(workspace_id:, connection_id:, customer_id:, ids:)
+        body = scope(workspace_id, connection_id, customer_id).merge('ids' => Array(ids))
+        counted(http.post('/ads/google/recommendations/dismiss', body), 'dismissed')
+      end
+
+      # ── GAQL ──
+
+      # A read-only GAQL SELECT; rows come back exactly as Google returns them.
+      def query(connection_id:, customer_id:, query:, workspace_id: nil)
+        body = compact_nil(
+          'workspaceId' => workspace_id,
+          'connectionId' => connection_id,
+          'customerId' => customer_id,
+          'query' => query
+        )
+        result = unwrap(http.post('/ads/insights/query', body))
+        rows = result.is_a?(Hash) ? result['rows'] : nil
+        rows.is_a?(Array) ? rows : []
+      end
+
+      private
+
+      def scope(workspace_id, connection_id, customer_id)
+        { 'workspaceId' => workspace_id, 'connectionId' => connection_id, 'customerId' => customer_id }
+      end
+
+      def params(connection_id, customer_id, workspace_id, extra = {})
+        compact_nil({
+          'workspace_id' => workspace_id,
+          'connection_id' => connection_id,
+          'customer_id' => customer_id
+        }.merge(extra))
+      end
+
+      def id_of(body)
+        result = unwrap(body)
+        result.is_a?(Hash) && result['id'] ? result['id'].to_s : ''
+      end
+
+      def uploaded(body)
+        counted(body, 'uploaded')
+      end
+
+      def counted(body, key)
+        result = unwrap(body)
+        result.is_a?(Hash) ? result[key].to_i : 0
+      end
+    end
+  end
+end

data/lib/fopost/resources/google_business.rb

@@ -0,0 +1,166 @@
+# frozen_string_literal: true
+
+require 'fopost/resources/base'
+
+module Fopost
+  module Resources
+    # `client.google_business` — manage a connected Google Business Profile location.
+    #
+    # Google grants Business Profile API access per project. Until that grant
+    # lands on a deployment every call here raises a 503 configuration_error.
+    #
+    # Responses relay Google's own shape, field for field, so they come back as
+    # plain hashes rather than models we would have to keep chasing.
+    class GoogleBusiness < Base
+      # The set fetched when a caller names no metrics.
+      DEFAULT_DAILY_METRICS = %w[
+        BUSINESS_IMPRESSIONS_DESKTOP_MAPS
+        BUSINESS_IMPRESSIONS_DESKTOP_SEARCH
+        BUSINESS_IMPRESSIONS_MOBILE_MAPS
+        BUSINESS_IMPRESSIONS_MOBILE_SEARCH
+        CALL_CLICKS
+        WEBSITE_CLICKS
+        BUSINESS_DIRECTION_REQUESTS
+      ].freeze
+
+      def get_location(account_id)
+        as_hash(unwrap(http.get("/accounts/#{account_id}/gbp/location")))
+      end
+
+      # Patch the profile; an omitted keyword keeps a field, nil clears it.
+      def update_location(account_id, title: UNSET, description: UNSET, website_uri: UNSET,
+                          primary_phone: UNSET, additional_phones: UNSET, store_code: UNSET,
+                          regular_hours: UNSET)
+        body = compact_unset({
+                               'title' => title,
+                               'description' => description,
+                               'website_uri' => website_uri,
+                               'primary_phone' => primary_phone,
+                               'additional_phones' => additional_phones,
+                               'store_code' => store_code,
+                               'regular_hours' => regular_hours
+                             })
+        as_hash(unwrap(http.request(:patch, "/accounts/#{account_id}/gbp/location", json: body)))
+      end
+
+      # The attribute values set on the location, or what Google offers it.
+      def get_attributes(account_id, available: nil, category_name: nil, region_code: nil, language_code: nil)
+        params = compact_nil({
+                               'available' => available,
+                               'category_name' => category_name,
+                               'region_code' => region_code,
+                               'language_code' => language_code
+                             })
+        as_hash(unwrap(http.get("/accounts/#{account_id}/gbp/attributes", params)))
+      end
+
+      # Only the named attributes change; every other one is left alone.
+      def update_attributes(account_id, attributes)
+        body = { 'attributes' => attributes }
+        as_hash(unwrap(http.request(:patch, "/accounts/#{account_id}/gbp/attributes", json: body)))
+      end
+
+      def get_menus(account_id)
+        as_hash(unwrap(http.get("/accounts/#{account_id}/gbp/menus")))
+      end
+
+      # Google has no per-section patch, so the whole menu set is replaced.
+      def replace_menus(account_id, menus)
+        as_hash(unwrap(http.put("/accounts/#{account_id}/gbp/menus", { 'menus' => menus })))
+      end
+
+      def get_services(account_id)
+        as_hash(unwrap(http.get("/accounts/#{account_id}/gbp/services")))
+      end
+
+      def replace_services(account_id, service_items)
+        as_hash(unwrap(http.put("/accounts/#{account_id}/gbp/services", { 'service_items' => service_items })))
+      end
+
+      def list_media(account_id, page_size: nil, page_token: nil)
+        params = compact_nil({ 'page_size' => page_size, 'page_token' => page_token })
+        as_hash(unwrap(http.get("/accounts/#{account_id}/gbp/media", params)))
+      end
+
+      # Add a photo from the media library; JPEG or PNG, same workspace.
+      def add_media(account_id, media_id:, category: 'ADDITIONAL', description: nil)
+        body = compact_nil({ 'media_id' => media_id, 'category' => category, 'description' => description })
+        as_hash(unwrap(http.post("/accounts/#{account_id}/gbp/media", body)))
+      end
+
+      def delete_media(account_id, media_key)
+        as_hash(unwrap(http.delete("/accounts/#{account_id}/gbp/media/#{media_key}")))
+      end
+
+      def list_place_actions(account_id)
+        as_hash(unwrap(http.get("/accounts/#{account_id}/gbp/place-actions")))
+      end
+
+      def create_place_action(account_id, uri:, place_action_type:, is_preferred: nil)
+        body = compact_nil({ 'uri' => uri, 'place_action_type' => place_action_type,
+                             'is_preferred' => is_preferred })
+        as_hash(unwrap(http.post("/accounts/#{account_id}/gbp/place-actions", body)))
+      end
+
+      def update_place_action(account_id, link_id, uri: UNSET, is_preferred: UNSET)
+        body = compact_unset({ 'uri' => uri, 'is_preferred' => is_preferred })
+        as_hash(unwrap(http.request(:patch, "/accounts/#{account_id}/gbp/place-actions/#{link_id}", json: body)))
+      end
+
+      def delete_place_action(account_id, link_id)
+        as_hash(unwrap(http.delete("/accounts/#{account_id}/gbp/place-actions/#{link_id}")))
+      end
+
+      # The ways Google will let this location be verified.
+      def get_verification_options(account_id, language_code: nil)
+        params = compact_nil({ 'language_code' => language_code })
+        as_hash(unwrap(http.get("/accounts/#{account_id}/gbp/verification", params)))
+      end
+
+      # The response names the pending verification to complete with the PIN.
+      def start_verification(account_id, method:, language_code: nil, phone_number: nil,
+                             email_address: nil, mailer_contact_name: nil)
+        body = compact_nil({
+                             'method' => method,
+                             'language_code' => language_code,
+                             'phone_number' => phone_number,
+                             'email_address' => email_address,
+                             'mailer_contact_name' => mailer_contact_name
+                           })
+        as_hash(unwrap(http.post("/accounts/#{account_id}/gbp/verification/start", body)))
+      end
+
+      def complete_verification(account_id, verification_name:, pin:)
+        body = { 'verification_name' => verification_name, 'pin' => pin }
+        as_hash(unwrap(http.post("/accounts/#{account_id}/gbp/verification/complete", body)))
+      end
+
+      # Daily impressions, calls, direction requests and clicks for the range.
+      def get_performance(account_id, start_date:, end_date:, daily_metrics: nil)
+        params = compact_nil({
+                               'start_date' => start_date,
+                               'end_date' => end_date,
+                               'daily_metrics' => daily_metrics
+                             })
+        as_hash(unwrap(http.get("/accounts/#{account_id}/gbp/performance", params)))
+      end
+
+      # The search terms people used to find the listing, by month.
+      def get_search_keywords(account_id, start_date:, end_date:, page_token: nil)
+        params = compact_nil({
+                               'keywords' => true,
+                               'start_date' => start_date,
+                               'end_date' => end_date,
+                               'page_token' => page_token
+                             })
+        as_hash(unwrap(http.get("/accounts/#{account_id}/gbp/performance", params)))
+      end
+
+      # Hand the location to another workspace; the caller must own both.
+      def assign(account_id, workspace_id:)
+        AccountMove.new(unwrap(http.post("/accounts/#{account_id}/gbp/assign",
+                                         { 'workspace_id' => workspace_id })))
+      end
+    end
+  end
+end