diff --git a/app/controllers/api/v1/accounts/google_play/authorizations_controller.rb b/app/controllers/api/v1/accounts/google_play/authorizations_controller.rb new file mode 100644 index 000000000..f9588d5bb --- /dev/null +++ b/app/controllers/api/v1/accounts/google_play/authorizations_controller.rb @@ -0,0 +1,34 @@ +class Api::V1::Accounts::GooglePlay::AuthorizationsController < Api::V1::Accounts::OauthAuthorizationController + include GooglePlayOauthConcern + + def create + redirect_url = google_client.auth_code.authorize_url( + redirect_uri: google_play_callback_url, + scope: scope, + response_type: 'code', + prompt: 'consent', # forces Google to return a refresh token + access_type: 'offline', + state: google_play_oauth_state, + client_id: GlobalConfigService.load('GOOGLE_OAUTH_CLIENT_ID', nil) + ) + + if redirect_url + render json: { success: true, url: redirect_url } + else + render json: { success: false }, status: :unprocessable_entity + end + end + + private + + def google_play_oauth_state + google_play_verifier.generate( + { + account_id: Current.account.id, + app_id: params[:app_id], + inbox_name: params[:inbox_name] + }, + expires_in: 15.minutes + ) + end +end diff --git a/app/controllers/api/v1/accounts/inboxes_controller.rb b/app/controllers/api/v1/accounts/inboxes_controller.rb index 7d93af25a..1bdb56c2f 100644 --- a/app/controllers/api/v1/accounts/inboxes_controller.rb +++ b/app/controllers/api/v1/accounts/inboxes_controller.rb @@ -99,7 +99,7 @@ class Api::V1::Accounts::InboxesController < Api::V1::Accounts::BaseController end def allowed_channel_types - %w[web_widget api email line telegram whatsapp sms app_store] + %w[web_widget api email line telegram whatsapp sms app_store google_play] end def app_store_channel_requested? @@ -190,7 +190,8 @@ class Api::V1::Accounts::InboxesController < Api::V1::Accounts::BaseController 'telegram' => Channel::Telegram, 'whatsapp' => Channel::Whatsapp, 'sms' => Channel::Sms, - 'app_store' => Channel::AppStore + 'app_store' => Channel::AppStore, + 'google_play' => Channel::GooglePlay }[permitted_params[:channel][:type]] end diff --git a/app/controllers/concerns/google_play_oauth_concern.rb b/app/controllers/concerns/google_play_oauth_concern.rb new file mode 100644 index 000000000..9562a23ec --- /dev/null +++ b/app/controllers/concerns/google_play_oauth_concern.rb @@ -0,0 +1,26 @@ +module GooglePlayOauthConcern + extend ActiveSupport::Concern + include GoogleConcern + + GOOGLE_PLAY_SCOPE = 'https://www.googleapis.com/auth/androidpublisher'.freeze + + private + + # Overrides the Gmail scope from GoogleConcern with the Play Developer API scope + def scope + GOOGLE_PLAY_SCOPE + end + + # Carries the account and channel details through the OAuth round trip + def google_play_verifier + Rails.application.message_verifier('google_play_oauth') + end + + def google_play_callback_url + "#{base_url}/google_play/callback" + end + + def base_url + ENV.fetch('FRONTEND_URL', 'http://localhost:3000') + end +end diff --git a/app/controllers/google_play/callbacks_controller.rb b/app/controllers/google_play/callbacks_controller.rb new file mode 100644 index 000000000..83a28355d --- /dev/null +++ b/app/controllers/google_play/callbacks_controller.rb @@ -0,0 +1,57 @@ +class GooglePlay::CallbacksController < ApplicationController + include GooglePlayOauthConcern + + def show + return redirect_with_error(params[:error]) if params[:error].present? + + token = google_client.auth_code.get_token(params[:code], redirect_uri: google_play_callback_url) + inbox = create_channel_with_inbox(token) + + redirect_to app_google_play_inbox_agents_url(account_id: account.id, inbox_id: inbox.id) + rescue StandardError => e + ChatwootExceptionTracker.new(e).capture_exception + redirect_with_error(e.message) + end + + private + + # Sends the user back to the inbox setup form with the error surfaced as a query param. + # Falls back to '/' only when we can't determine the account (e.g. tampered/missing state). + def redirect_with_error(error_message) + acc = safe_account + return redirect_to '/' unless acc + + redirect_to app_new_google_play_inbox_url(account_id: acc.id, error: error_message.to_s.truncate(300)) + end + + def safe_account + Account.find_by(id: state_payload[:account_id]) + rescue StandardError + nil + end + + def state_payload + @state_payload ||= google_play_verifier.verify(params[:state]).with_indifferent_access + end + + def account + @account ||= Account.find(state_payload[:account_id]) + end + + def create_channel_with_inbox(token) + ActiveRecord::Base.transaction do + channel = Channel::GooglePlay.create!( + account: account, + app_id: state_payload[:app_id], + provider_config: { + access_token: token.token, + refresh_token: token.refresh_token, + expires_on: (Time.current.utc + 1.hour).to_s + } + ) + # Return the newly created inbox directly — `channel.inbox` is unreliable here because the polymorphic + # has_one cache is not always populated by `account.inboxes.create!`. + account.inboxes.create!(account: account, channel: channel, name: state_payload[:inbox_name]) + end + end +end diff --git a/app/helpers/api/v1/inboxes_helper.rb b/app/helpers/api/v1/inboxes_helper.rb index 3920ecfa4..18de50984 100644 --- a/app/helpers/api/v1/inboxes_helper.rb +++ b/app/helpers/api/v1/inboxes_helper.rb @@ -112,7 +112,8 @@ module Api::V1::InboxesHelper 'telegram' => Current.account.telegram_channels, 'whatsapp' => Current.account.whatsapp_channels, 'sms' => Current.account.sms_channels, - 'app_store' => Current.account.app_store_channels + 'app_store' => Current.account.app_store_channels, + 'google_play' => Current.account.google_play_channels }[permitted_params[:channel][:type]] end diff --git a/app/javascript/dashboard/api/channel/googlePlayClient.js b/app/javascript/dashboard/api/channel/googlePlayClient.js new file mode 100644 index 000000000..7bf3b2501 --- /dev/null +++ b/app/javascript/dashboard/api/channel/googlePlayClient.js @@ -0,0 +1,14 @@ +/* global axios */ +import ApiClient from '../ApiClient'; + +class GooglePlayClient extends ApiClient { + constructor() { + super('google_play', { accountScoped: true }); + } + + generateAuthorization(payload) { + return axios.post(`${this.url}/authorization`, payload); + } +} + +export default new GooglePlayClient(); diff --git a/app/javascript/dashboard/components-next/icon/provider.js b/app/javascript/dashboard/components-next/icon/provider.js index ebb168f3d..36eb0377e 100644 --- a/app/javascript/dashboard/components-next/icon/provider.js +++ b/app/javascript/dashboard/components-next/icon/provider.js @@ -16,6 +16,7 @@ export function useChannelIcon(inbox) { 'Channel::Instagram': 'i-woot-instagram', 'Channel::Tiktok': 'i-woot-tiktok', 'Channel::AppStore': 'i-ri-app-store-fill', + 'Channel::GooglePlay': 'i-ri-google-play-line', }; const providerIconMap = { diff --git a/app/javascript/dashboard/components-next/message/MessageMeta.vue b/app/javascript/dashboard/components-next/message/MessageMeta.vue index e0c1f071e..f61bf4cc4 100644 --- a/app/javascript/dashboard/components-next/message/MessageMeta.vue +++ b/app/javascript/dashboard/components-next/message/MessageMeta.vue @@ -22,6 +22,7 @@ const { isAnInstagramChannel, isAnAppStoreChannel, isATiktokChannel, + isAGooglePlayChannel, } = useInbox(); const { @@ -64,7 +65,8 @@ const isSent = computed(() => { isATelegramChannel.value || isAnInstagramChannel.value || isATiktokChannel.value || - isAnAppStoreChannel.value + isAnAppStoreChannel.value || + isAGooglePlayChannel.value ) { return sourceId.value && status.value === MESSAGE_STATUS.SENT; } diff --git a/app/javascript/dashboard/components/widgets/ChannelItem.vue b/app/javascript/dashboard/components/widgets/ChannelItem.vue index a8327a466..6e215234b 100644 --- a/app/javascript/dashboard/components/widgets/ChannelItem.vue +++ b/app/javascript/dashboard/components/widgets/ChannelItem.vue @@ -71,6 +71,7 @@ const isActive = computed(() => { 'instagram', 'tiktok', 'voice', + 'google_play', ].includes(key); }); diff --git a/app/javascript/dashboard/components/widgets/conversation/ReplyBox.vue b/app/javascript/dashboard/components/widgets/conversation/ReplyBox.vue index 7f10190e6..ff9b07f3c 100644 --- a/app/javascript/dashboard/components/widgets/conversation/ReplyBox.vue +++ b/app/javascript/dashboard/components/widgets/conversation/ReplyBox.vue @@ -264,6 +264,9 @@ export default { if (this.isATiktokChannel) { return MESSAGE_MAX_LENGTH.TIKTOK; } + if (this.isAGooglePlayChannel) { + return MESSAGE_MAX_LENGTH.GOOGLE_PLAY; + } if (this.isATwilioWhatsAppChannel) { return MESSAGE_MAX_LENGTH.TWILIO_WHATSAPP; } diff --git a/app/javascript/dashboard/composables/spec/useInbox.spec.js b/app/javascript/dashboard/composables/spec/useInbox.spec.js index 1c01032d1..6b00400b4 100644 --- a/app/javascript/dashboard/composables/spec/useInbox.spec.js +++ b/app/javascript/dashboard/composables/spec/useInbox.spec.js @@ -53,6 +53,7 @@ const mockStore = createStore({ voice_enabled: true, }, 15: { id: 15, channel_type: INBOX_TYPES.TIKTOK }, + 16: { id: 16, channel_type: INBOX_TYPES.GOOGLE_PLAY }, }; return inboxes[id] || null; }, @@ -226,6 +227,12 @@ describe('useInbox', () => { global: { plugins: [mockStore] }, }); expect(wrapper.vm.isATiktokChannel).toBe(true); + + // Test Google Play + wrapper = mount(createTestComponent(16), { + global: { plugins: [mockStore] }, + }); + expect(wrapper.vm.isAGooglePlayChannel).toBe(true); }); }); @@ -278,6 +285,7 @@ describe('useInbox', () => { 'isAnEmailChannel', 'isAnInstagramChannel', 'isATiktokChannel', + 'isAGooglePlayChannel', 'voiceCallEnabled', 'voiceCallProvider', ]; diff --git a/app/javascript/dashboard/composables/useInbox.js b/app/javascript/dashboard/composables/useInbox.js index bb6a01374..cd5a3640d 100644 --- a/app/javascript/dashboard/composables/useInbox.js +++ b/app/javascript/dashboard/composables/useInbox.js @@ -144,6 +144,10 @@ export const useInbox = (inboxId = null) => { return channelType.value === INBOX_TYPES.APP_STORE; }); + const isAGooglePlayChannel = computed(() => { + return channelType.value === INBOX_TYPES.GOOGLE_PLAY; + }); + const voiceCallEnabled = computed(() => isVoiceCallEnabled(inbox.value)); const voiceCallProvider = computed(() => getVoiceCallProvider(inbox.value)); @@ -167,6 +171,7 @@ export const useInbox = (inboxId = null) => { isAnInstagramChannel, isATiktokChannel, isAnAppStoreChannel, + isAGooglePlayChannel, voiceCallEnabled, voiceCallProvider, }; diff --git a/app/javascript/dashboard/constants/editor.js b/app/javascript/dashboard/constants/editor.js index a89d197a9..4c50edd6b 100644 --- a/app/javascript/dashboard/constants/editor.js +++ b/app/javascript/dashboard/constants/editor.js @@ -119,6 +119,11 @@ export const FORMATTING = { nodes: [], menu: [], }, + 'Channel::GooglePlay': { + marks: [], + nodes: [], + menu: [], + }, // Special contexts (not actual channels) 'Context::PrivateNote': { marks: ['strong', 'em', 'code', 'link', 'strike'], diff --git a/app/javascript/dashboard/helper/inbox.js b/app/javascript/dashboard/helper/inbox.js index 65d04b2ca..32bca9d47 100644 --- a/app/javascript/dashboard/helper/inbox.js +++ b/app/javascript/dashboard/helper/inbox.js @@ -12,6 +12,7 @@ export const INBOX_TYPES = { INSTAGRAM: 'Channel::Instagram', TIKTOK: 'Channel::Tiktok', APP_STORE: 'Channel::AppStore', + GOOGLE_PLAY: 'Channel::GooglePlay', }; // Add providers here as they gain voice capability (e.g., WhatsApp Cloud, Twilio WhatsApp) @@ -52,6 +53,7 @@ const INBOX_ICON_MAP_FILL = { [INBOX_TYPES.INSTAGRAM]: 'i-ri-instagram-fill', [INBOX_TYPES.TIKTOK]: 'i-ri-tiktok-fill', [INBOX_TYPES.APP_STORE]: 'i-ri-app-store-fill', + [INBOX_TYPES.GOOGLE_PLAY]: 'i-ri-google-play-fill', }; const DEFAULT_ICON_FILL = 'i-ri-chat-1-fill'; @@ -68,6 +70,7 @@ const INBOX_ICON_MAP_LINE = { [INBOX_TYPES.INSTAGRAM]: 'i-woot-instagram', [INBOX_TYPES.TIKTOK]: 'i-woot-tiktok', [INBOX_TYPES.APP_STORE]: 'i-ri-app-store-line', + [INBOX_TYPES.GOOGLE_PLAY]: 'i-ri-google-play-line', }; const DEFAULT_ICON_LINE = 'i-ri-chat-1-line'; @@ -120,6 +123,9 @@ export const getReadableInboxByType = (type, phoneNumber) => { case INBOX_TYPES.APP_STORE: return 'app_store'; + case INBOX_TYPES.GOOGLE_PLAY: + return 'google_play'; + default: return 'chat'; } diff --git a/app/javascript/dashboard/i18n/locale/en/inboxMgmt.json b/app/javascript/dashboard/i18n/locale/en/inboxMgmt.json index 9b9df0fa2..de7c5bdf6 100644 --- a/app/javascript/dashboard/i18n/locale/en/inboxMgmt.json +++ b/app/javascript/dashboard/i18n/locale/en/inboxMgmt.json @@ -480,6 +480,24 @@ "ERROR_MESSAGE": "We were not able to save the telegram channel" } }, + "GOOGLE_PLAY": { + "TITLE": "Google Play Reviews", + "DESC": "Manage and reply to your Google Play Store app reviews from Chatwoot.", + "INBOX_NAME": { + "LABEL": "Inbox Name", + "PLACEHOLDER": "Please enter an inbox name", + "ERROR": "This field is required" + }, + "APP_ID": { + "LABEL": "App package name", + "PLACEHOLDER": "Please enter your app package name (eg: com.example.app)", + "ERROR": "Please enter a valid app package name" + }, + "CONNECT_BUTTON": "Connect with Google", + "API": { + "ERROR_MESSAGE": "We were not able to connect your Google Play Reviews channel" + } + }, "AUTH": { "TITLE": "Choose a channel", "DESC": "Chatwoot supports live-chat widgets, Facebook Messenger, WhatsApp, Emails, etc., as channels. If you want to build a custom channel, you can create it using the API channel. To get started, choose one of the channels below.", @@ -533,6 +551,10 @@ "VOICE": { "TITLE": "Voice", "DESCRIPTION": "Integrate with Twilio Voice" + }, + "GOOGLE_PLAY": { + "TITLE": "Google Play Reviews", + "DESCRIPTION": "Manage your Google Play Store app reviews" } } }, @@ -1203,6 +1225,7 @@ "INSTAGRAM": "Instagram", "TIKTOK": "TikTok", "APP_STORE": "App Store Reviews", + "GOOGLE_PLAY": "Google Play Reviews", "VOICE": "Voice" } } diff --git a/app/javascript/dashboard/routes/dashboard/settings/inbox/ChannelFactory.vue b/app/javascript/dashboard/routes/dashboard/settings/inbox/ChannelFactory.vue index fec8090a1..7d5b759b4 100644 --- a/app/javascript/dashboard/routes/dashboard/settings/inbox/ChannelFactory.vue +++ b/app/javascript/dashboard/routes/dashboard/settings/inbox/ChannelFactory.vue @@ -13,6 +13,7 @@ import Instagram from './channels/Instagram.vue'; import Tiktok from './channels/Tiktok.vue'; import Voice from './channels/Voice.vue'; import AppStore from './channels/AppStore.vue'; +import GooglePlay from './channels/GooglePlay.vue'; const channelViewList = { facebook: Facebook, @@ -28,6 +29,7 @@ const channelViewList = { tiktok: Tiktok, app_store: AppStore, voice: Voice, + google_play: GooglePlay, }; export default defineComponent({ diff --git a/app/javascript/dashboard/routes/dashboard/settings/inbox/ChannelList.vue b/app/javascript/dashboard/routes/dashboard/settings/inbox/ChannelList.vue index 0a7f191ff..c454443b4 100644 --- a/app/javascript/dashboard/routes/dashboard/settings/inbox/ChannelList.vue +++ b/app/javascript/dashboard/routes/dashboard/settings/inbox/ChannelList.vue @@ -83,6 +83,12 @@ const channelList = computed(() => { description: t('INBOX_MGMT.ADD.AUTH.CHANNEL.APP_STORE.DESCRIPTION'), icon: 'i-ri-app-store-line', }, + { + key: 'google_play', + title: t('INBOX_MGMT.ADD.AUTH.CHANNEL.GOOGLE_PLAY.TITLE'), + description: t('INBOX_MGMT.ADD.AUTH.CHANNEL.GOOGLE_PLAY.DESCRIPTION'), + icon: 'i-ri-google-play-line', + }, ]; if (hasTiktokConfigured.value) { diff --git a/app/javascript/dashboard/routes/dashboard/settings/inbox/Settings.vue b/app/javascript/dashboard/routes/dashboard/settings/inbox/Settings.vue index 2e5e44724..bc3881ac2 100644 --- a/app/javascript/dashboard/routes/dashboard/settings/inbox/Settings.vue +++ b/app/javascript/dashboard/routes/dashboard/settings/inbox/Settings.vue @@ -249,7 +249,7 @@ export default { ]; } - if (this.isAnAppStoreChannel) { + if (this.isAnAppStoreChannel || this.isAGooglePlayChannel) { const unsupportedKeys = ['business-hours', 'csat', 'bot-configuration']; visibleToAllChannelTabs = visibleToAllChannelTabs.filter( tab => !unsupportedKeys.includes(tab.key) @@ -289,7 +289,10 @@ export default { if (this.isAnEmailChannel) { return `${this.inbox.name} (${this.inbox.email})`; } - if (this.isAnAppStoreChannel && this.inbox.app_id) { + if ( + (this.isAnAppStoreChannel || this.isAGooglePlayChannel) && + this.inbox.app_id + ) { return `${this.inbox.name} (${this.inbox.app_id})`; } return this.inbox.name; @@ -840,7 +843,7 @@ export default { @@ -1140,7 +1143,7 @@ export default { diff --git a/app/javascript/dashboard/routes/dashboard/settings/inbox/channels/GooglePlay.vue b/app/javascript/dashboard/routes/dashboard/settings/inbox/channels/GooglePlay.vue new file mode 100644 index 000000000..031357e65 --- /dev/null +++ b/app/javascript/dashboard/routes/dashboard/settings/inbox/channels/GooglePlay.vue @@ -0,0 +1,109 @@ + + + diff --git a/app/javascript/dashboard/routes/dashboard/settings/inbox/components/ChannelName.vue b/app/javascript/dashboard/routes/dashboard/settings/inbox/components/ChannelName.vue index 3625d7601..fc1658e50 100644 --- a/app/javascript/dashboard/routes/dashboard/settings/inbox/components/ChannelName.vue +++ b/app/javascript/dashboard/routes/dashboard/settings/inbox/components/ChannelName.vue @@ -35,6 +35,7 @@ const i18nMap = { 'Channel::Instagram': 'INSTAGRAM', 'Channel::Tiktok': 'TIKTOK', 'Channel::AppStore': 'APP_STORE', + 'Channel::GooglePlay': 'GOOGLE_PLAY', }; const twilioChannelName = () => { diff --git a/app/javascript/shared/helpers/MessageTypeHelper.js b/app/javascript/shared/helpers/MessageTypeHelper.js index d2bc6f187..86e6d0c95 100644 --- a/app/javascript/shared/helpers/MessageTypeHelper.js +++ b/app/javascript/shared/helpers/MessageTypeHelper.js @@ -22,4 +22,6 @@ export const MESSAGE_MAX_LENGTH = { TELEGRAM: 4096, LINE: 2000, EMAIL: 25000, + // https://developers.google.com/android-publisher/reviews — developer replies are capped at 350 characters + GOOGLE_PLAY: 350, }; diff --git a/app/javascript/shared/mixins/inboxMixin.js b/app/javascript/shared/mixins/inboxMixin.js index ee32c782b..ebf88b26c 100644 --- a/app/javascript/shared/mixins/inboxMixin.js +++ b/app/javascript/shared/mixins/inboxMixin.js @@ -141,6 +141,9 @@ export default { isAnAppStoreChannel() { return this.channelType === INBOX_TYPES.APP_STORE; }, + isAGooglePlayChannel() { + return this.channelType === INBOX_TYPES.GOOGLE_PLAY; + }, }, methods: { inboxHasFeature(feature) { diff --git a/app/jobs/inboxes/fetch_google_play_review_inboxes_job.rb b/app/jobs/inboxes/fetch_google_play_review_inboxes_job.rb new file mode 100644 index 000000000..0575eefa4 --- /dev/null +++ b/app/jobs/inboxes/fetch_google_play_review_inboxes_job.rb @@ -0,0 +1,14 @@ +class Inboxes::FetchGooglePlayReviewInboxesJob < ApplicationJob + queue_as :scheduled_jobs + + # Runs every 15 minutes via cron. Each inbox syncs at most once per Channel::GooglePlay::SYNC_INTERVAL + # (one hour) — the extra cron ticks act as quick retries when a sync window is missed. + def perform + Inbox.where(channel_type: 'Channel::GooglePlay').find_each(batch_size: 100) do |inbox| + next if inbox.account.suspended? + next unless inbox.channel.sync_due? + + ::Inboxes::FetchGooglePlayReviewsJob.perform_later(inbox.channel) + end + end +end diff --git a/app/jobs/inboxes/fetch_google_play_reviews_job.rb b/app/jobs/inboxes/fetch_google_play_reviews_job.rb new file mode 100644 index 000000000..e54f07e9d --- /dev/null +++ b/app/jobs/inboxes/fetch_google_play_reviews_job.rb @@ -0,0 +1,16 @@ +class Inboxes::FetchGooglePlayReviewsJob < ApplicationJob + queue_as :scheduled_jobs + + def perform(channel) + channel.fetch_reviews.each do |review| + ::GooglePlay::ReviewBuilder.new(review: review, channel: channel).perform + rescue StandardError => e + ChatwootExceptionTracker.new(e, account: channel.account).capture_exception + end + + # Stamp the channel so the orchestrator skips it until the sync interval elapses. + channel.update!(last_synced_at: Time.current) + rescue StandardError => e + ChatwootExceptionTracker.new(e, account: channel.account).capture_exception + end +end diff --git a/app/jobs/send_reply_job.rb b/app/jobs/send_reply_job.rb index 8df046883..945a15a0e 100644 --- a/app/jobs/send_reply_job.rb +++ b/app/jobs/send_reply_job.rb @@ -12,6 +12,7 @@ class SendReplyJob < ApplicationJob 'Channel::Tiktok' => ::Tiktok::SendOnTiktokService, 'Channel::AppStore' => ::AppStore::SendOnAppStoreService, 'Channel::Email' => ::Email::SendOnEmailService, + 'Channel::GooglePlay' => ::GooglePlay::SendOnGooglePlayService, 'Channel::WebWidget' => ::Messages::SendEmailNotificationService, 'Channel::Api' => ::Messages::SendEmailNotificationService }.freeze diff --git a/app/models/account.rb b/app/models/account.rb index 79f305c1f..89225da02 100644 --- a/app/models/account.rb +++ b/app/models/account.rb @@ -78,6 +78,7 @@ class Account < ApplicationRecord has_many :data_imports, dependent: :destroy_async has_many :email_channels, dependent: :destroy_async, class_name: '::Channel::Email' has_many :facebook_pages, dependent: :destroy_async, class_name: '::Channel::FacebookPage' + has_many :google_play_channels, dependent: :destroy_async, class_name: '::Channel::GooglePlay' has_many :instagram_channels, dependent: :destroy_async, class_name: '::Channel::Instagram' has_many :tiktok_channels, dependent: :destroy_async, class_name: '::Channel::Tiktok' has_many :hooks, dependent: :destroy_async, class_name: 'Integrations::Hook' diff --git a/app/models/channel/google_play.rb b/app/models/channel/google_play.rb new file mode 100644 index 000000000..ea517222d --- /dev/null +++ b/app/models/channel/google_play.rb @@ -0,0 +1,110 @@ +# == Schema Information +# +# Table name: channel_google_play +# +# id :bigint not null, primary key +# app_id :string not null +# provider_config :jsonb not null +# last_synced_at :datetime +# created_at :datetime not null +# updated_at :datetime not null +# account_id :bigint not null +# +# Indexes +# +# index_channel_google_play_on_account_id_and_app_id (account_id,app_id) UNIQUE +# + +class Channel::GooglePlay < ApplicationRecord + include Channelable + + self.table_name = 'channel_google_play' + EDITABLE_ATTRS = [:app_id, { provider_config: {} }].freeze + + API_BASE_URL = 'https://androidpublisher.googleapis.com/androidpublisher/v3'.freeze + # Google Play caps a developer reply at 350 characters + MAX_REPLY_LENGTH = 350 + REVIEWS_PAGE_SIZE = 100 + # Safety bound — at 100 per page this covers 5,000 reviews. The API only retains the last 7 + # days, so this is far above any realistic volume and just prevents runaway loops. + MAX_REVIEW_PAGES = 50 + # Each inbox is synced at most once per this window. The cron runs more frequently + # so a missed window retries on the next tick. + SYNC_INTERVAL = 1.hour + + validates :app_id, presence: true, uniqueness: { scope: :account_id } + + # Pull reviews on the agent's behalf the moment the inbox is wired up so they're not waiting + # for the next 15-minute poll. Runs after the surrounding transaction commits so the + # associated inbox is guaranteed to be visible. + after_create_commit :enqueue_initial_review_fetch + + def name + 'Google PlayStore' + end + + def sync_due? + last_synced_at.nil? || last_synced_at < SYNC_INTERVAL.ago + end + + # Google Play only retains reviews from the last 7 days, hence the channel is polled frequently. + # Pages through tokenPagination.nextPageToken until the API stops returning a cursor. + def fetch_reviews + reviews = [] + page_token = nil + + MAX_REVIEW_PAGES.times do + parsed = fetch_reviews_page(page_token) + reviews.concat(parsed['reviews'] || []) + + page_token = parsed.dig('tokenPagination', 'nextPageToken') + break if page_token.blank? + end + + reviews + end + + # Returns a stable source_id for the reply so the outgoing message can be marked as sent. + # Google Play has no separate reply id, so we combine the review id with the developer comment's + # lastEdited timestamp from the response. + def reply_to_review(review_id, reply_text) + response = HTTParty.post( + "#{API_BASE_URL}/applications/#{app_id}/reviews/#{review_id}:reply", + headers: authorization_headers.merge('Content-Type' => 'application/json'), + body: { replyText: reply_text.to_s.truncate(MAX_REPLY_LENGTH) }.to_json + ) + raise "Google Play reply failed (#{response.code}): #{response.body}" unless response.success? + + last_edited = response.parsed_response.dig('result', 'lastEdited', 'seconds') + "#{review_id}::reply::#{last_edited}" + end + + private + + def fetch_reviews_page(page_token) + query = { maxResults: REVIEWS_PAGE_SIZE } + query[:token] = page_token if page_token.present? + + response = HTTParty.get( + "#{API_BASE_URL}/applications/#{app_id}/reviews", + headers: authorization_headers, + query: query + ) + raise "Google Play reviews fetch failed (#{response.code}): #{response.body}" unless response.success? + + response.parsed_response + end + + def authorization_headers + { 'Authorization' => "Bearer #{access_token}" } + end + + # Channels are connected through the Google OAuth flow; tokens are refreshed on demand + def access_token + Google::RefreshOauthTokenService.new(channel: self).access_token + end + + def enqueue_initial_review_fetch + ::Inboxes::FetchGooglePlayReviewsJob.perform_later(self) + end +end diff --git a/app/models/inbox.rb b/app/models/inbox.rb index b34e8a5af..3ac13dec2 100644 --- a/app/models/inbox.rb +++ b/app/models/inbox.rb @@ -150,6 +150,10 @@ class Inbox < ApplicationRecord channel_type == 'Channel::Email' end + def google_play? + channel_type == 'Channel::GooglePlay' + end + def twilio? channel_type == 'Channel::TwilioSms' end diff --git a/app/services/conversations/message_window_service.rb b/app/services/conversations/message_window_service.rb index ee154125e..6b080f14a 100644 --- a/app/services/conversations/message_window_service.rb +++ b/app/services/conversations/message_window_service.rb @@ -14,7 +14,7 @@ class Conversations::MessageWindowService private - def messaging_window + def messaging_window # rubocop:disable Metrics/CyclomaticComplexity case @conversation.inbox.channel_type when 'Channel::Api' api_messaging_window @@ -28,6 +28,10 @@ class Conversations::MessageWindowService MESSAGING_WINDOW_24_HOURS when 'Channel::TwilioSms' twilio_messaging_window + when 'Channel::GooglePlay' + # Google Play API only allows replying to reviews left within the last 7 days. + # https://developers.google.com/android-publisher/reviews + MESSAGING_WINDOW_7_DAYS end end diff --git a/app/services/google_play/review_builder.rb b/app/services/google_play/review_builder.rb new file mode 100644 index 000000000..20f7f2330 --- /dev/null +++ b/app/services/google_play/review_builder.rb @@ -0,0 +1,157 @@ +# Builds a contact, conversation and messages from a single Google Play review. +# Each review maps to one conversation (keyed on the review id). When a reviewer edits +# their review, a fresh incoming message is appended to the same conversation. +# Developer replies (whether posted via Chatwoot or directly in Play Console) are mirrored +# as outgoing messages, with a source_id that matches what `SendOnGooglePlayService` +# produces so Chatwoot-originated replies are deduped on the next poll. +class GooglePlay::ReviewBuilder + pattr_initialize [:review!, :channel!] + + def perform + return if user_comment.blank? || review_text.blank? + + ActiveRecord::Base.transaction do + build_contact_inbox + build_conversation + build_user_message + build_developer_message if developer_comment.present? + end + end + + private + + def inbox + @inbox ||= channel.inbox + end + + def user_comment + @user_comment ||= comments_with_key('userComment').first + end + + def developer_comment + @developer_comment ||= comments_with_key('developerComment').first + end + + def comments_with_key(key) + Array(review['comments']).filter_map { |comment| comment[key] } + end + + def review_id + review['reviewId'] + end + + def review_text + @review_text ||= user_comment['text'].to_s.strip + end + + def star_rating + @star_rating ||= user_comment['starRating'].to_i + end + + # A new lastModified timestamp (edited review) yields a new message in the same conversation + def user_message_source_id + "#{review_id}::#{user_comment.dig('lastModified', 'seconds')}" + end + + # Must match the format `Channel::GooglePlay#reply_to_review` returns so replies sent through + # Chatwoot are not duplicated when the review is re-fetched. + def developer_message_source_id + "#{review_id}::reply::#{developer_comment.dig('lastModified', 'seconds')}" + end + + def build_contact_inbox + @contact_inbox = ::ContactInboxWithContactBuilder.new( + source_id: review_id, + inbox: inbox, + contact_attributes: { + name: review['authorName'].presence || 'Google Play User', + additional_attributes: { source_id: "google_play:#{review_id}" } + } + ).perform + end + + def build_conversation + @conversation = @contact_inbox.conversations.last || ::Conversation.create!( + account_id: inbox.account_id, + inbox_id: inbox.id, + contact_id: @contact_inbox.contact_id, + contact_inbox_id: @contact_inbox.id, + additional_attributes: { source: 'google_play', app_id: channel.app_id } + ) + end + + def build_user_message + return if @conversation.messages.exists?(source_id: user_message_source_id) + + @conversation.messages.create!( + account_id: inbox.account_id, + inbox_id: inbox.id, + sender: @conversation.contact, + message_type: :incoming, + source_id: user_message_source_id, + content: message_content, + content_attributes: review_metadata + ) + end + + def build_developer_message + text = developer_comment['text'].to_s.strip + return if text.blank? + return if @conversation.messages.exists?(source_id: developer_message_source_id) + + @conversation.messages.create!( + account_id: inbox.account_id, + inbox_id: inbox.id, + message_type: :outgoing, + source_id: developer_message_source_id, + content: text, + status: :sent + ) + end + + def message_content + stars = ('★' * star_rating) + ('☆' * (5 - star_rating)) + [ + "#{stars} (#{star_rating}/5)", + review_text, + review_footer + ].compact_blank.join("\n\n") + end + + # A compact line of context shown beneath the review text — device, app version, OS. + def review_footer + parts = [device_display, app_version_display, os_version_display].compact_blank + return nil if parts.empty? + + parts.join(' • ') + end + + def device_display + metadata = user_comment['deviceMetadata'] || {} + metadata['productName'].presence || user_comment['device'] + end + + def app_version_display + version = user_comment['appVersionName'] + version.present? ? "v#{version}" : nil + end + + def os_version_display + version = user_comment['androidOsVersion'] + version.present? ? "Android #{version}" : nil + end + + def review_metadata + metadata = user_comment['deviceMetadata'] || {} + { + google_play: { + star_rating: star_rating, + app_version: user_comment['appVersionName'], + device: device_display, + manufacturer: metadata['manufacturer'], + android_os_version: user_comment['androidOsVersion'], + reviewer_language: user_comment['reviewerLanguage'] + } + } + end +end diff --git a/app/services/google_play/send_on_google_play_service.rb b/app/services/google_play/send_on_google_play_service.rb new file mode 100644 index 000000000..391785136 --- /dev/null +++ b/app/services/google_play/send_on_google_play_service.rb @@ -0,0 +1,15 @@ +class GooglePlay::SendOnGooglePlayService < Base::SendOnChannelService + private + + def channel_class + Channel::GooglePlay + end + + def perform_reply + source_id = channel.reply_to_review(message.conversation.contact_inbox.source_id, message.content) + message.update!(source_id: source_id) if source_id.present? + rescue StandardError => e + ChatwootExceptionTracker.new(e, account: message.account).capture_exception + message.update!(status: :failed, external_error: e.message.to_s.truncate(255)) + end +end diff --git a/app/services/message_templates/hook_execution_service.rb b/app/services/message_templates/hook_execution_service.rb index 93f0447f3..2665b32a5 100644 --- a/app/services/message_templates/hook_execution_service.rb +++ b/app/services/message_templates/hook_execution_service.rb @@ -19,10 +19,12 @@ class MessageTemplates::HookExecutionService ::MessageTemplates::Template::EmailCollect.new(conversation: conversation).perform if inbox.enable_email_collect && should_send_email_collect? end - def should_send_out_of_office_message? + def should_send_out_of_office_message? # rubocop:disable Metrics/CyclomaticComplexity, Metrics/AbcSize return false if conversation.campaign.present? # should not send if its a tweet message return false if conversation.tweet? + # Google Play replies don't support out-of-office auto-replies; business hours don't apply to review responses + return false if inbox.google_play? # should not send for outbound messages return false unless message.incoming? # prevents sending out-of-office message if an agent has sent a message in last 5 minutes @@ -40,6 +42,8 @@ class MessageTemplates::HookExecutionService return false if conversation.campaign.present? # should not send if its a tweet message return false if conversation.tweet? + # Google Play replies are constrained — auto-greetings don't fit the one-shot review reply model + return false if inbox.google_play? first_message_from_contact? && inbox.greeting_enabled? && inbox.greeting_message.present? end diff --git a/app/views/api/v1/models/_inbox.json.jbuilder b/app/views/api/v1/models/_inbox.json.jbuilder index 40f833b5d..668c6d445 100644 --- a/app/views/api/v1/models/_inbox.json.jbuilder +++ b/app/views/api/v1/models/_inbox.json.jbuilder @@ -71,6 +71,12 @@ if resource.app_store? json.last_synced_at resource.channel.try(:last_synced_at) end +## Google Play Attributes +if resource.google_play? + json.app_id resource.channel.try(:app_id) + json.last_synced_at resource.channel.try(:last_synced_at) +end + ## Twilio Attributes json.messaging_service_sid resource.channel.try(:messaging_service_sid) json.phone_number resource.channel.try(:phone_number) diff --git a/config/routes.rb b/config/routes.rb index 3d2d68269..cd5549980 100644 --- a/config/routes.rb +++ b/config/routes.rb @@ -22,10 +22,12 @@ Rails.application.routes.draw do get '/app/accounts/:account_id/settings/inboxes/new/microsoft', to: 'dashboard#index', as: 'app_new_microsoft_inbox' get '/app/accounts/:account_id/settings/inboxes/new/instagram', to: 'dashboard#index', as: 'app_new_instagram_inbox' get '/app/accounts/:account_id/settings/inboxes/new/tiktok', to: 'dashboard#index', as: 'app_new_tiktok_inbox' + get '/app/accounts/:account_id/settings/inboxes/new/google_play', to: 'dashboard#index', as: 'app_new_google_play_inbox' get '/app/accounts/:account_id/settings/inboxes/new/:inbox_id/agents', to: 'dashboard#index', as: 'app_twitter_inbox_agents' get '/app/accounts/:account_id/settings/inboxes/new/:inbox_id/agents', to: 'dashboard#index', as: 'app_email_inbox_agents' get '/app/accounts/:account_id/settings/inboxes/new/:inbox_id/agents', to: 'dashboard#index', as: 'app_instagram_inbox_agents' get '/app/accounts/:account_id/settings/inboxes/new/:inbox_id/agents', to: 'dashboard#index', as: 'app_tiktok_inbox_agents' + get '/app/accounts/:account_id/settings/inboxes/new/:inbox_id/agents', to: 'dashboard#index', as: 'app_google_play_inbox_agents' get '/app/accounts/:account_id/settings/inboxes/:inbox_id', to: 'dashboard#index', as: 'app_instagram_inbox_settings' get '/app/accounts/:account_id/settings/inboxes/:inbox_id', to: 'dashboard#index', as: 'app_tiktok_inbox_settings' get '/app/accounts/:account_id/settings/inboxes/:inbox_id', to: 'dashboard#index', as: 'app_email_inbox_settings' @@ -319,6 +321,10 @@ Rails.application.routes.draw do resource :authorization, only: [:create] end + namespace :google_play do + resource :authorization, only: [:create] + end + namespace :instagram do resource :authorization, only: [:create] end @@ -643,6 +649,7 @@ Rails.application.routes.draw do get 'microsoft/callback', to: 'microsoft/callbacks#show' get 'google/callback', to: 'google/callbacks#show' + get 'google_play/callback', to: 'google_play/callbacks#show' get 'instagram/callback', to: 'instagram/callbacks#show' get 'tiktok/callback', to: 'tiktok/callbacks#show' get 'notion/callback', to: 'notion/callbacks#show' diff --git a/config/schedule.yml b/config/schedule.yml index 6f3d4e0cf..ee393929c 100644 --- a/config/schedule.yml +++ b/config/schedule.yml @@ -32,6 +32,12 @@ trigger_app_store_review_inboxes_job: class: 'Inboxes::FetchAppStoreReviewInboxesJob' queue: scheduled_jobs +# executed every 15 minutes to fetch Google Play Store app reviews +trigger_google_play_review_inboxes_job: + cron: '*/15 * * * *' + class: 'Inboxes::FetchGooglePlayReviewInboxesJob' + queue: scheduled_jobs + # executed daily at 2230 UTC # which is our lowest traffic time remove_stale_contact_inboxes_job.rb: diff --git a/db/migrate/20260519000000_create_channel_google_play.rb b/db/migrate/20260519000000_create_channel_google_play.rb new file mode 100644 index 000000000..3bbcdcba2 --- /dev/null +++ b/db/migrate/20260519000000_create_channel_google_play.rb @@ -0,0 +1,13 @@ +class CreateChannelGooglePlay < ActiveRecord::Migration[7.1] + def change + create_table :channel_google_play do |t| + t.bigint :account_id, null: false + t.string :app_id, null: false + t.jsonb :provider_config, null: false, default: {} + + t.timestamps + end + + add_index :channel_google_play, [:account_id, :app_id], unique: true + end +end diff --git a/db/migrate/20260519160000_add_last_synced_at_to_channel_google_play.rb b/db/migrate/20260519160000_add_last_synced_at_to_channel_google_play.rb new file mode 100644 index 000000000..adac40de4 --- /dev/null +++ b/db/migrate/20260519160000_add_last_synced_at_to_channel_google_play.rb @@ -0,0 +1,5 @@ +class AddLastSyncedAtToChannelGooglePlay < ActiveRecord::Migration[7.1] + def change + add_column :channel_google_play, :last_synced_at, :datetime + end +end diff --git a/db/schema.rb b/db/schema.rb index f3bae1192..c3932c8a4 100644 --- a/db/schema.rb +++ b/db/schema.rb @@ -506,6 +506,16 @@ ActiveRecord::Schema[7.1].define(version: 2026_05_22_080000) do t.index ["page_id"], name: "index_channel_facebook_pages_on_page_id" end + create_table "channel_google_play", force: :cascade do |t| + t.bigint "account_id", null: false + t.string "app_id", null: false + t.jsonb "provider_config", default: {}, null: false + t.datetime "created_at", null: false + t.datetime "updated_at", null: false + t.datetime "last_synced_at" + t.index ["account_id", "app_id"], name: "index_channel_google_play_on_account_id_and_app_id", unique: true + end + create_table "channel_instagram", force: :cascade do |t| t.string "access_token", null: false t.datetime "expires_at", null: false diff --git a/enterprise/app/models/captain/document.rb b/enterprise/app/models/captain/document.rb index 0fe14813b..d4fb400f5 100644 --- a/enterprise/app/models/captain/document.rb +++ b/enterprise/app/models/captain/document.rb @@ -4,10 +4,8 @@ # # id :bigint not null, primary key # content :text -# content_fingerprint :string # external_link :string not null # last_sync_attempted_at :datetime -# last_sync_error_code :string # last_synced_at :datetime # metadata :jsonb # name :string diff --git a/enterprise/app/models/company.rb b/enterprise/app/models/company.rb index c60e9423c..0af914cae 100644 --- a/enterprise/app/models/company.rb +++ b/enterprise/app/models/company.rb @@ -2,17 +2,17 @@ # # Table name: companies # +# id :bigint not null, primary key # additional_attributes :jsonb +# contacts_count :integer default(0), not null # custom_attributes :jsonb +# description :text +# domain :string # last_activity_at :datetime -# id :bigint not null, primary key -# contacts_count :integer -# description :text -# domain :string -# name :string not null -# created_at :datetime not null -# updated_at :datetime not null -# account_id :bigint not null +# name :string not null +# created_at :datetime not null +# updated_at :datetime not null +# account_id :bigint not null # # Indexes # diff --git a/spec/controllers/api/v1/accounts/google_play/authorizations_controller_spec.rb b/spec/controllers/api/v1/accounts/google_play/authorizations_controller_spec.rb new file mode 100644 index 000000000..ab06b68ef --- /dev/null +++ b/spec/controllers/api/v1/accounts/google_play/authorizations_controller_spec.rb @@ -0,0 +1,65 @@ +require 'rails_helper' + +RSpec.describe 'Google Play Authorization API', type: :request do + let(:account) { create(:account) } + let(:url) { "/api/v1/accounts/#{account.id}/google_play/authorization" } + + describe 'POST /api/v1/accounts/{account.id}/google_play/authorization' do + context 'when it is an unauthenticated user' do + it 'returns unauthorized' do + post url + expect(response).to have_http_status(:unauthorized) + end + end + + context 'when it is an authenticated agent' do + let(:agent) { create(:user, account: account, role: :agent) } + + it 'returns unauthorized' do + post url, headers: agent.create_new_auth_token, as: :json + expect(response).to have_http_status(:unauthorized) + end + end + + context 'when it is an authenticated administrator' do + let(:administrator) { create(:user, account: account, role: :administrator) } + + before do + # Stand-in OAuth credentials so the authorize URL is built. + create(:installation_config, name: 'GOOGLE_OAUTH_CLIENT_ID', value: 'client-id-123', locked: false) + create(:installation_config, name: 'GOOGLE_OAUTH_CLIENT_SECRET', value: 'client-secret', locked: false) + GlobalConfig.clear_cache + end + + it 'returns a redirect URL with the androidpublisher scope' do + post url, + params: { app_id: 'com.example.app', inbox_name: 'My App' }, + headers: administrator.create_new_auth_token, + as: :json + + expect(response).to have_http_status(:success) + body = response.parsed_body + expect(body['success']).to be true + expect(body['url']).to include('client_id=client-id-123') + expect(body['url']).to include('scope=https%3A%2F%2Fwww.googleapis.com%2Fauth%2Fandroidpublisher') + expect(body['url']).to include('access_type=offline') + expect(body['url']).to include('prompt=consent') + expect(body['url']).to include('google_play%2Fcallback') + end + + it 'signs the state with the app_id and inbox_name so the callback can decode them' do + post url, + params: { app_id: 'com.example.app', inbox_name: 'My App' }, + headers: administrator.create_new_auth_token, + as: :json + + state = CGI.parse(URI(response.parsed_body['url']).query)['state'].first + decoded = Rails.application.message_verifier('google_play_oauth').verify(state).with_indifferent_access + + expect(decoded[:account_id]).to eq(account.id) + expect(decoded[:app_id]).to eq('com.example.app') + expect(decoded[:inbox_name]).to eq('My App') + end + end + end +end diff --git a/spec/controllers/google_play/callbacks_controller_spec.rb b/spec/controllers/google_play/callbacks_controller_spec.rb new file mode 100644 index 000000000..1e0778617 --- /dev/null +++ b/spec/controllers/google_play/callbacks_controller_spec.rb @@ -0,0 +1,58 @@ +require 'rails_helper' + +RSpec.describe 'GooglePlay::CallbacksController', type: :request do + let(:account) { create(:account) } + let(:code) { SecureRandom.hex(10) } + let(:state_payload) { { account_id: account.id, app_id: 'com.example.app', inbox_name: 'My App' } } + let(:state) { Rails.application.message_verifier('google_play_oauth').generate(state_payload, expires_in: 15.minutes) } + let(:token_response) do + { access_token: 'play-access-token', refresh_token: 'play-refresh-token', token_type: 'Bearer', expires_in: 3599 } + end + + before do + create(:installation_config, name: 'GOOGLE_OAUTH_CLIENT_ID', value: 'client-id-123', locked: false) + create(:installation_config, name: 'GOOGLE_OAUTH_CLIENT_SECRET', value: 'client-secret', locked: false) + GlobalConfig.clear_cache + end + + describe 'GET /google_play/callback' do + it 'creates the channel + inbox and redirects to the agent assignment page' do + stub_request(:post, 'https://oauth2.googleapis.com/o/oauth2/token') + .to_return(status: 200, body: token_response.to_json, headers: { 'Content-Type' => 'application/json' }) + + expect do + get '/google_play/callback', params: { code: code, state: state } + end.to change(Channel::GooglePlay, :count).by(1) + .and change(Inbox, :count).by(1) + + inbox = Inbox.last + channel = inbox.channel + expect(channel.app_id).to eq('com.example.app') + expect(channel.provider_config).to include('access_token' => 'play-access-token', 'refresh_token' => 'play-refresh-token') + expect(inbox.name).to eq('My App') + expect(response).to redirect_to(app_google_play_inbox_agents_url(account_id: account.id, inbox_id: inbox.id)) + end + + it 'redirects to the inbox setup page surfacing the error when Google returns an error param' do + get '/google_play/callback', params: { error: 'access_denied', state: state } + + expect(Channel::GooglePlay.count).to eq(0) + expect(response).to redirect_to(app_new_google_play_inbox_url(account_id: account.id, error: 'access_denied')) + end + + it 'redirects to the inbox setup page with the error when token exchange fails' do + stub_request(:post, 'https://oauth2.googleapis.com/o/oauth2/token').to_return(status: 400, body: 'invalid') + + get '/google_play/callback', params: { code: code, state: state } + + expect(Channel::GooglePlay.count).to eq(0) + expect(response.location).to include("/app/accounts/#{account.id}/settings/inboxes/new/google_play") + expect(response.location).to include('error=') + end + + it 'falls back to / when the state cannot be decoded' do + get '/google_play/callback', params: { code: code, state: 'tampered' } + expect(response).to redirect_to('/') + end + end +end diff --git a/spec/factories/channel/channel_google_play.rb b/spec/factories/channel/channel_google_play.rb new file mode 100644 index 000000000..b7ca64167 --- /dev/null +++ b/spec/factories/channel/channel_google_play.rb @@ -0,0 +1,19 @@ +# frozen_string_literal: true + +FactoryBot.define do + factory :channel_google_play, class: 'Channel::GooglePlay' do + account + sequence(:app_id) { |n| "com.example.app#{n}" } + provider_config do + { + 'access_token' => SecureRandom.hex(16), + 'refresh_token' => SecureRandom.hex(16), + 'expires_on' => 1.hour.from_now.utc.to_s + } + end + + after(:create) do |channel| + create(:inbox, channel: channel, account: channel.account) + end + end +end diff --git a/spec/jobs/inboxes/fetch_google_play_review_inboxes_job_spec.rb b/spec/jobs/inboxes/fetch_google_play_review_inboxes_job_spec.rb new file mode 100644 index 000000000..73d046879 --- /dev/null +++ b/spec/jobs/inboxes/fetch_google_play_review_inboxes_job_spec.rb @@ -0,0 +1,29 @@ +require 'rails_helper' + +RSpec.describe Inboxes::FetchGooglePlayReviewInboxesJob do + include ActiveJob::TestHelper + + before { clear_enqueued_jobs } + + let!(:due_channel) { create(:channel_google_play, last_synced_at: 2.hours.ago) } + let!(:fresh_channel) { create(:channel_google_play, last_synced_at: 5.minutes.ago) } + let!(:never_synced_channel) { create(:channel_google_play, last_synced_at: nil) } + + before { clear_enqueued_jobs } # also clear the after_create_commit fetches from factory + + it 'enqueues a fetch job for channels whose sync interval has elapsed' do + described_class.perform_now + + expect(Inboxes::FetchGooglePlayReviewsJob).to have_been_enqueued.with(due_channel).once + expect(Inboxes::FetchGooglePlayReviewsJob).to have_been_enqueued.with(never_synced_channel).once + expect(Inboxes::FetchGooglePlayReviewsJob).not_to have_been_enqueued.with(fresh_channel) + end + + it 'skips inboxes belonging to suspended accounts' do + due_channel.account.update!(status: :suspended) + + described_class.perform_now + + expect(Inboxes::FetchGooglePlayReviewsJob).not_to have_been_enqueued.with(due_channel) + end +end diff --git a/spec/jobs/inboxes/fetch_google_play_reviews_job_spec.rb b/spec/jobs/inboxes/fetch_google_play_reviews_job_spec.rb new file mode 100644 index 000000000..61ee62120 --- /dev/null +++ b/spec/jobs/inboxes/fetch_google_play_reviews_job_spec.rb @@ -0,0 +1,39 @@ +require 'rails_helper' + +RSpec.describe Inboxes::FetchGooglePlayReviewsJob do + let(:channel) { create(:channel_google_play) } + let(:review) do + { + 'reviewId' => 'rev-1', + 'authorName' => 'Tester', + 'comments' => [{ 'userComment' => { 'text' => 'good', 'starRating' => 5, 'lastModified' => { 'seconds' => '1' } } }] + } + end + + before do + allow(channel).to receive(:fetch_reviews).and_return([review]) + end + + it 'invokes ReviewBuilder for each fetched review' do + builder = instance_double(GooglePlay::ReviewBuilder, perform: true) + allow(GooglePlay::ReviewBuilder).to receive(:new).with(review: review, channel: channel).and_return(builder) + + described_class.perform_now(channel) + + expect(builder).to have_received(:perform) + end + + it 'stamps last_synced_at after a successful pass' do + travel_to Time.zone.parse('2026-05-19 12:00') do + described_class.perform_now(channel) + expect(channel.reload.last_synced_at).to be_within(1.second).of(Time.current) + end + end + + it 'captures per-review errors without aborting the rest of the run' do + allow(GooglePlay::ReviewBuilder).to receive(:new).and_raise(StandardError, 'boom') + expect(ChatwootExceptionTracker).to receive(:new).and_call_original + + expect { described_class.perform_now(channel) }.not_to raise_error + end +end diff --git a/spec/models/channel/google_play_spec.rb b/spec/models/channel/google_play_spec.rb new file mode 100644 index 000000000..5b42165c4 --- /dev/null +++ b/spec/models/channel/google_play_spec.rb @@ -0,0 +1,136 @@ +require 'rails_helper' + +RSpec.describe Channel::GooglePlay do + include ActiveJob::TestHelper + + let(:account) { create(:account) } + let(:channel) { create(:channel_google_play, account: account) } + + describe 'validations' do + it 'requires app_id' do + record = described_class.new(account: account, provider_config: { 'access_token' => 'x' }) + expect(record).not_to be_valid + expect(record.errors[:app_id]).to include("can't be blank") + end + + it 'requires app_id to be unique per account' do + create(:channel_google_play, account: account, app_id: 'com.dup.app') + duplicate = build(:channel_google_play, account: account, app_id: 'com.dup.app') + expect(duplicate).not_to be_valid + end + + it 'allows the same app_id across different accounts' do + create(:channel_google_play, account: account, app_id: 'com.shared.app') + other = build(:channel_google_play, account: create(:account), app_id: 'com.shared.app') + expect(other).to be_valid + end + end + + describe '#name' do + it 'returns the human-readable channel name' do + expect(channel.name).to eq 'Google PlayStore' + end + end + + describe '#sync_due?' do + it 'is true when last_synced_at is nil' do + channel.update!(last_synced_at: nil) + expect(channel.sync_due?).to be true + end + + it 'is true when last_synced_at is older than the sync interval' do + channel.update!(last_synced_at: 2.hours.ago) + expect(channel.sync_due?).to be true + end + + it 'is false when last_synced_at is within the sync interval' do + channel.update!(last_synced_at: 10.minutes.ago) + expect(channel.sync_due?).to be false + end + end + + describe '#fetch_reviews' do + let(:base_url) { "#{described_class::API_BASE_URL}/applications/#{channel.app_id}/reviews" } + + before do + allow_any_instance_of(described_class).to receive(:access_token).and_return('test-token') + end + + it 'returns the reviews list for a single page' do + stub_request(:get, base_url) + .with(query: hash_including('maxResults' => '100')) + .to_return(status: 200, body: { reviews: [{ 'reviewId' => 'r-1' }] }.to_json, + headers: { 'Content-Type' => 'application/json' }) + + expect(channel.fetch_reviews).to eq([{ 'reviewId' => 'r-1' }]) + end + + it 'follows tokenPagination.nextPageToken across pages' do + stub_request(:get, base_url) + .with(query: hash_including('maxResults' => '100')) + .to_return( + { status: 200, + body: { reviews: [{ 'reviewId' => 'r-1' }], tokenPagination: { nextPageToken: 'PAGE2' } }.to_json, + headers: { 'Content-Type' => 'application/json' } }, + { status: 200, + body: { reviews: [{ 'reviewId' => 'r-2' }] }.to_json, + headers: { 'Content-Type' => 'application/json' } } + ) + + expect(channel.fetch_reviews.map { |r| r['reviewId'] }).to eq(%w[r-1 r-2]) + end + + it 'raises when the API responds with an error' do + stub_request(:get, base_url) + .with(query: hash_including('maxResults' => '100')) + .to_return(status: 403, body: 'forbidden') + + expect { channel.fetch_reviews }.to raise_error(/Google Play reviews fetch failed \(403\)/) + end + end + + describe '#reply_to_review' do + let(:url) { "#{described_class::API_BASE_URL}/applications/#{channel.app_id}/reviews/REV-1:reply" } + + before do + allow_any_instance_of(described_class).to receive(:access_token).and_return('test-token') + end + + it 'returns a source_id composed from the review id and lastEdited.seconds' do + stub_request(:post, url).to_return( + status: 200, + body: { result: { replyText: 'thanks', lastEdited: { seconds: '1779000000', nanos: 0 } } }.to_json, + headers: { 'Content-Type' => 'application/json' } + ) + + expect(channel.reply_to_review('REV-1', 'thanks')).to eq('REV-1::reply::1779000000') + end + + it 'truncates the reply text to MAX_REPLY_LENGTH' do + stub_request(:post, url).to_return(status: 200, + body: { result: { lastEdited: { seconds: '1' } } }.to_json, + headers: { 'Content-Type' => 'application/json' }) + + channel.reply_to_review('REV-1', 'a' * 500) + + expect(WebMock).to(have_requested(:post, url).with do |req| + JSON.parse(req.body)['replyText'].length <= described_class::MAX_REPLY_LENGTH + end) + end + + it 'raises when the API responds with an error' do + stub_request(:post, url).to_return(status: 400, body: 'bad request') + + expect { channel.reply_to_review('REV-1', 'x') } + .to raise_error(/Google Play reply failed \(400\)/) + end + end + + describe 'after_create_commit' do + it 'enqueues an initial review fetch' do + expect do + create(:channel_google_play, account: account) + end.to have_enqueued_job(Inboxes::FetchGooglePlayReviewsJob) + end + end +end diff --git a/spec/services/conversations/message_window_service_spec.rb b/spec/services/conversations/message_window_service_spec.rb index 32542e87e..a9b0e641c 100644 --- a/spec/services/conversations/message_window_service_spec.rb +++ b/spec/services/conversations/message_window_service_spec.rb @@ -625,4 +625,22 @@ RSpec.describe Conversations::MessageWindowService do expect(service.can_reply?).to be true end end + + describe 'on Google Play channels' do + let!(:google_play_channel) { create(:channel_google_play) } + let(:inbox) { google_play_channel.inbox } + let(:conversation) { create(:conversation, inbox: inbox, account: google_play_channel.account) } + + it 'allows replies when the most recent incoming review is within 7 days' do + create(:message, account: conversation.account, inbox: inbox, conversation: conversation, created_at: 3.days.ago) + + expect(described_class.new(conversation).can_reply?).to be true + end + + it 'blocks replies when the most recent incoming review is older than 7 days' do + create(:message, account: conversation.account, inbox: inbox, conversation: conversation, created_at: 10.days.ago) + + expect(described_class.new(conversation).can_reply?).to be false + end + end end diff --git a/spec/services/google_play/review_builder_spec.rb b/spec/services/google_play/review_builder_spec.rb new file mode 100644 index 000000000..a5b073f9e --- /dev/null +++ b/spec/services/google_play/review_builder_spec.rb @@ -0,0 +1,127 @@ +require 'rails_helper' + +RSpec.describe GooglePlay::ReviewBuilder do + let(:channel) { create(:channel_google_play) } + let(:inbox) { channel.inbox } + + def base_review(overrides = {}) + { + 'reviewId' => 'rev-abc', + 'authorName' => 'Jane Reviewer', + 'comments' => [ + { 'userComment' => { + 'text' => 'Great app, but crashes sometimes.', + 'starRating' => 4, + 'reviewerLanguage' => 'en', + 'appVersionName' => '4.5.0', + 'androidOsVersion' => 33, + 'device' => 'a15', + 'deviceMetadata' => { 'productName' => 'Galaxy A15', 'manufacturer' => 'Samsung' }, + 'lastModified' => { 'seconds' => '1779000000', 'nanos' => 0 } + } } + ] + }.deep_merge(overrides) + end + + it 'creates a contact, conversation, and incoming message from userComment' do + expect do + described_class.new(review: base_review, channel: channel).perform + end.to change(Contact, :count).by(1) + .and change(Conversation, :count).by(1) + .and change(Message, :count).by(1) + + message = Message.last + expect(message.message_type).to eq 'incoming' + expect(message.source_id).to eq 'rev-abc::1779000000' + expect(message.content).to include('★★★★☆ (4/5)') + expect(message.content).to include('Great app, but crashes sometimes.') + expect(message.content).to include('Galaxy A15 • v4.5.0 • Android 33') + expect(message.content_attributes['google_play']).to include( + 'star_rating' => 4, + 'app_version' => '4.5.0', + 'manufacturer' => 'Samsung', + 'reviewer_language' => 'en' + ) + end + + it 'is idempotent for the same userComment lastModified seconds' do + described_class.new(review: base_review, channel: channel).perform + + expect do + described_class.new(review: base_review, channel: channel).perform + end.not_to change(Message, :count) + end + + it 'creates a new incoming message when the reviewer edits (new lastModified)' do + described_class.new(review: base_review, channel: channel).perform + + edited = base_review.deep_dup + edited['comments'].first['userComment']['lastModified']['seconds'] = '1779999999' + edited['comments'].first['userComment']['text'] = 'Edited review' + + expect do + described_class.new(review: edited, channel: channel).perform + end.to change(Message, :count).by(1) + .and(not_change(Conversation, :count)) + end + + it 'skips entirely when the user comment text is blank' do + review = base_review + review['comments'].first['userComment']['text'] = '' + + expect do + described_class.new(review: review, channel: channel).perform + end.to(not_change(Message, :count)) + end + + context 'when the review also has a developerComment' do + let(:review_with_reply) do + base_review('comments' => [ + { 'userComment' => base_review['comments'].first['userComment'] }, + { 'developerComment' => { + 'text' => 'Thanks for the feedback!', + 'lastModified' => { 'seconds' => '1779100000' } + } } + ]) + end + + it 'mirrors the developer comment as an outgoing message' do + described_class.new(review: review_with_reply, channel: channel).perform + + outgoing = Message.outgoing.last + expect(outgoing.content).to eq('Thanks for the feedback!') + expect(outgoing.source_id).to eq('rev-abc::reply::1779100000') + expect(outgoing.status).to eq('sent') + end + + it 'is idempotent and does not duplicate the outgoing reply' do + described_class.new(review: review_with_reply, channel: channel).perform + + expect do + described_class.new(review: review_with_reply, channel: channel).perform + end.not_to change(Message, :count) + end + + it 'dedupes against a reply already sent through Chatwoot with the same source_id' do + conversation = create(:conversation, inbox: inbox, account: channel.account, + contact_inbox: create(:contact_inbox, inbox: inbox, source_id: 'rev-abc')) + create(:message, conversation: conversation, account: channel.account, inbox: inbox, + message_type: :outgoing, source_id: 'rev-abc::reply::1779100000', content: 'sent via chatwoot') + + expect do + described_class.new(review: review_with_reply, channel: channel).perform + end.to change(Message, :count).by(1) # the incoming user message only + expect(Message.outgoing.where(source_id: 'rev-abc::reply::1779100000').count).to eq(1) + end + end + + # RSpec helper for `not_change` (no built-in opposite of `change`) + matcher :not_change do |obj, method| + supports_block_expectations + match do |block| + before = obj.send(method) + block.call + obj.send(method) == before + end + end +end diff --git a/spec/services/google_play/send_on_google_play_service_spec.rb b/spec/services/google_play/send_on_google_play_service_spec.rb new file mode 100644 index 000000000..f0ea003f2 --- /dev/null +++ b/spec/services/google_play/send_on_google_play_service_spec.rb @@ -0,0 +1,34 @@ +require 'rails_helper' + +RSpec.describe GooglePlay::SendOnGooglePlayService do + let(:channel) { create(:channel_google_play) } + let(:inbox) { channel.inbox } + let(:contact) { create(:contact, account: channel.account) } + let(:contact_inbox) { create(:contact_inbox, contact: contact, inbox: inbox, source_id: 'REV-1') } + let(:conversation) { create(:conversation, contact: contact, contact_inbox: contact_inbox, inbox: inbox, account: channel.account) } + let(:message) { create(:message, message_type: :outgoing, content: 'thanks', conversation: conversation, inbox: inbox, account: channel.account) } + + describe '#perform' do + it 'stamps the outgoing message with the source_id returned from the API' do + allow(channel).to receive(:reply_to_review).with('REV-1', 'thanks').and_return('REV-1::reply::42') + allow_any_instance_of(Inbox).to receive(:channel).and_return(channel) + + described_class.new(message: message).perform + + expect(message.reload.source_id).to eq('REV-1::reply::42') + expect(message.status).to eq('sent') + end + + it 'marks the message as failed when the API call raises' do + allow(channel).to receive(:reply_to_review).and_raise(StandardError, 'Google Play reply failed (403)') + allow_any_instance_of(Inbox).to receive(:channel).and_return(channel) + allow(ChatwootExceptionTracker).to receive(:new).and_call_original + + described_class.new(message: message).perform + + expect(message.reload.status).to eq('failed') + expect(message.external_error).to eq('Google Play reply failed (403)') + expect(ChatwootExceptionTracker).to have_received(:new) + end + end +end diff --git a/spec/services/message_templates/hook_execution_service_spec.rb b/spec/services/message_templates/hook_execution_service_spec.rb index e186227be..cb0b600e2 100644 --- a/spec/services/message_templates/hook_execution_service_spec.rb +++ b/spec/services/message_templates/hook_execution_service_spec.rb @@ -270,4 +270,28 @@ describe MessageTemplates::HookExecutionService do expect(out_of_office_service).not_to receive(:perform) end end + + context 'when the inbox is a Google Play Reviews channel' do + let(:channel) { create(:channel_google_play) } + let(:inbox) { channel.inbox } + let(:conversation) { create(:conversation, inbox: inbox, account: channel.account) } + + it 'does not fire the greeting template even when greeting_enabled is true' do + inbox.update!(greeting_enabled: true, greeting_message: 'Thanks for reviewing!') + allow(MessageTemplates::Template::Greeting).to receive(:new) + + create(:message, conversation: conversation, account: conversation.account) + + expect(MessageTemplates::Template::Greeting).not_to have_received(:new) + end + + it 'does not fire the out-of-office template even when configured' do + inbox.update!(working_hours_enabled: true, out_of_office_message: 'Back tomorrow') + allow(MessageTemplates::Template::OutOfOffice).to receive(:new) + + create(:message, conversation: conversation, account: conversation.account) + + expect(MessageTemplates::Template::OutOfOffice).not_to have_received(:new) + end + end end