spree_google_products 1.0

data/app/controllers/spree/admin/google_shopping/products_controller.rb

@@ -0,0 +1,79 @@
+module Spree
+  module Admin
+    module GoogleShopping
+      class ProductsController < Spree::Admin::ResourceController
+
+        def model_class
+          Spree::Product
+        end
+
+        def index
+          per_page = params[:per_page].to_i > 0 ? params[:per_page].to_i : 25
+
+          @search = Spree::Product.accessible_by(current_ability, :read).ransack(params[:q])
+          
+          @collection = @search.result(distinct: true)
+                                      .includes(:google_product_attribute)
+                                      .page(params[:page])
+                                      .per(per_page)
+        end
+
+        def edit
+          @product = Spree::Product.friendly.find(params[:id])
+          @product.build_google_product_attribute unless @product.google_product_attribute
+        end
+
+        def update
+          @product = Spree::Product.friendly.find(params[:id])
+          if @product.update(product_params)
+
+            Spree::GoogleShopping::SyncProductJob.perform_later(@product.id)
+            
+            flash[:success] = "Product updated. Syncing to Google Merchant Center"
+            redirect_to admin_google_shopping_product_path(@product)
+          else
+            flash[:error] = "Could not update product"
+            render :edit
+          end
+        end
+
+        def issues
+          @product = Spree::Product.friendly.find(params[:id])
+          
+          @variant = Spree::Variant.find_by(id: params[:variant_id])
+          
+          if @variant
+
+            @google_attr = Spree::GoogleVariantAttribute.find_by(variant_id: @variant.id)
+            @issues = @google_attr&.google_issues || []
+          else
+            flash[:error] = "Variant not found."
+            redirect_to admin_google_shopping_product_path(@product)
+          end
+        end
+
+        private
+
+        def product_params
+          params.require(:product).permit(
+            google_product_attribute_attributes: [
+              :id, 
+              :brand, 
+              :product_type,
+              :google_product_category, 
+              :gender, 
+              :age_group, 
+              :condition, 
+              :gtin, 
+              :mpn,
+              :sale_start_at,
+              :sale_end_at,
+              :min_handling_time,
+              :max_handling_time
+            ]
+          )
+        end
+      end
+    end
+  end
+end

data/app/controllers/spree/admin/google_shopping/taxons_controller.rb

@@ -0,0 +1,39 @@
+module Spree
+    module Admin
+      module GoogleShopping
+        class TaxonsController < Spree::Admin::BaseController
+
+          def drill_down
+            parent_path = params[:parent_path]
+
+            if parent_path.blank?
+
+              categories = Spree::GoogleTaxon.pluck(:name).map { |n| n.split(' > ').first }.uniq.sort
+            else
+
+              prefix = "#{parent_path} > "
+              
+              categories = Spree::GoogleTaxon
+                             .where("name LIKE ?", "#{prefix}%")
+                             .pluck(:name)
+                             .map { |n| n.sub(prefix, '').split(' > ').first }
+                             .uniq
+                             .sort
+            end
+  
+            current_taxon_id = nil
+            if parent_path.present?
+              taxon = Spree::GoogleTaxon.find_by(name: parent_path)
+              current_taxon_id = taxon&.google_id
+            end
+  
+            render json: {
+              categories: categories,
+              current_id: current_taxon_id,
+              is_leaf: categories.empty?
+            }
+          end
+        end
+      end
+    end
+  end

data/app/helpers/spree/admin/google_shopping_helper.rb

@@ -0,0 +1,39 @@
+module Spree
+    module Admin
+      module GoogleShoppingHelper
+  
+        def google_supported_countries_options
+          [
+            ['United States (US)', 'US'], ['India (IN)', 'IN'], ['United Kingdom (GB)', 'GB'],
+            ['Canada (CA)', 'CA'], ['Australia (AU)', 'AU'], ['Germany (DE)', 'DE'],
+            ['France (FR)', 'FR'], ['Italy (IT)', 'IT'], ['Spain (ES)', 'ES'],
+            ['Netherlands (NL)', 'NL'], ['Brazil (BR)', 'BR'], ['Japan (JP)', 'JP'],
+            ['Mexico (MX)', 'MX'], ['Austria (AT)', 'AT'], ['Belgium (BE)', 'BE'],
+            ['Denmark (DK)', 'DK'], ['Finland (FI)', 'FI'], ['Greece (GR)', 'GR'],
+            ['Hungary (HU)', 'HU'], ['Indonesia (ID)', 'ID'], ['Ireland (IE)', 'IE'],
+            ['Israel (IL)', 'IL'], ['Malaysia (MY)', 'MY'], ['New Zealand (NZ)', 'NZ'],
+            ['Norway (NO)', 'NO'], ['Philippines (PH)', 'PH'], ['Poland (PL)', 'PL'],
+            ['Portugal (PT)', 'PT'], ['Romania (RO)', 'RO'], ['Russia (RU)', 'RU'],
+            ['Saudi Arabia (SA)', 'SA'], ['Singapore (SG)', 'SG'], ['South Africa (ZA)', 'ZA'],
+            ['South Korea (KR)', 'KR'], ['Sweden (SE)', 'SE'], ['Switzerland (CH)', 'CH'],
+            ['Taiwan (TW)', 'TW'], ['Thailand (TH)', 'TH'], ['Turkey (TR)', 'TR'],
+            ['Ukraine (UA)', 'UA'], ['United Arab Emirates (AE)', 'AE'], ['Vietnam (VN)', 'VN']
+            # Add others if needed based on GMC docs
+          ].sort
+        end
+  
+        def google_supported_currencies_options
+          [
+            ['US Dollar (USD)', 'USD'], ['Indian Rupee (INR)', 'INR'], ['British Pound (GBP)', 'GBP'],
+            ['Euro (EUR)', 'EUR'], ['Canadian Dollar (CAD)', 'CAD'], ['Australian Dollar (AUD)', 'AUD'],
+            ['Japanese Yen (JPY)', 'JPY'], ['Brazilian Real (BRL)', 'BRL'], ['Mexican Peso (MXN)', 'MXN'],
+            ['Swiss Franc (CHF)', 'CHF'], ['Hong Kong Dollar (HKD)', 'HKD'], ['New Zealand Dollar (NZD)', 'NZD'],
+            ['Polish Zloty (PLN)', 'PLN'], ['Russian Ruble (RUB)', 'RUB'], ['Singapore Dollar (SGD)', 'SGD'],
+            ['South African Rand (ZAR)', 'ZAR'], ['South Korean Won (KRW)', 'KRW'], ['Swedish Krona (SEK)', 'SEK'],
+            ['Turkish Lira (TRY)', 'TRY'], ['Danish Krone (DKK)', 'DKK'], ['Norwegian Krone (NOK)', 'NOK']
+          ].sort
+        end
+  
+      end
+    end
+  end

data/app/javascript/spree_google_products/application.js

@@ -0,0 +1,16 @@
+import '@hotwired/turbo-rails'
+import { Application } from '@hotwired/stimulus'
+
+let application
+
+if (typeof window.Stimulus === "undefined") {
+  application = Application.start()
+  application.debug = false
+  window.Stimulus = application
+} else {
+  application = window.Stimulus
+}
+
+import SpreeGoogleProductsController from 'spree_google_products/controllers/spree_google_products_controller' 
+
+application.register('spree_google_products', SpreeGoogleProductsController)

data/app/javascript/spree_google_products/controllers/spree_google_products_controller.js

@@ -0,0 +1,7 @@
+import { Controller } from '@hotwired/stimulus'
+
+export default class extends Controller {
+  connect() {
+    console.log('Hello, SpreeGoogleProducts!')
+  }
+}

data/app/jobs/spree/google_shopping/fetch_status_job.rb

@@ -0,0 +1,23 @@
+module Spree
+  module GoogleShopping
+    class FetchStatusJob < SpreeGoogleProducts::BaseJob
+      #queue_as :default
+
+      def perform
+        credential = Spree::Store.default.google_credential
+        return unless credential&.active?
+
+        service = Spree::GoogleShopping::ContentService.new(credential)
+        
+        Spree::GoogleVariantAttribute.where.not(google_status: nil).find_each(batch_size: 50) do |g_attr|
+          variant = Spree::Variant.find_by(id: g_attr.variant_id)
+          next unless variant
+          
+          service.fetch_product_status(variant)
+          
+          sleep 0.2
+        end
+      end
+    end
+  end
+end

data/app/jobs/spree/google_shopping/sync_all_job.rb

@@ -0,0 +1,18 @@
+module Spree
+    module GoogleShopping
+      class SyncAllJob < SpreeGoogleProducts::BaseJob
+        #queue_as :default
+  
+        def perform
+          credential = Spree::Store.default.google_credential
+          return unless credential&.active?
+  
+          service = Spree::GoogleShopping::ContentService.new(credential)
+          
+          Spree::Product.active.find_each(batch_size: 50) do |product|
+            service.push_product(product)
+          end
+        end
+      end
+    end
+  end

data/app/jobs/spree/google_shopping/sync_product_job.rb

@@ -0,0 +1,35 @@
+module Spree
+  module GoogleShopping
+    class SyncProductJob < SpreeGoogleProducts::BaseJob
+      #queue_as :default
+
+      def perform(product_id)
+        product = Spree::Product.find_by(id: product_id)
+        unless product
+          Rails.logger.error "GOOGLE SYNC JOB: Product ID #{product_id} not found."
+          return
+        end
+
+        credential = Spree::Store.default.google_credential
+        unless credential&.active?
+          Rails.logger.warn "GOOGLE SYNC JOB: Credential missing or inactive. Aborting."
+          return
+        end
+
+        Rails.logger.info "GOOGLE SYNC JOB: Starting sync for Product '#{product.name}' (ID: #{product.id})..."
+        
+        begin
+          service = Spree::GoogleShopping::ContentService.new(credential)
+          service.push_product(product)
+
+          credential.update_column(:last_sync_at, Time.current)
+          
+          Rails.logger.info "GOOGLE SYNC JOB: ✅ Completed successfully for Product #{product.id}."
+        rescue => e
+          Rails.logger.error "GOOGLE SYNC JOB: ❌ Failed for Product #{product.id}. Error: #{e.message}"
+          Rails.logger.error e.backtrace.join("\n")
+        end
+      end
+    end
+  end
+end

data/app/jobs/spree_google_products/base_job.rb

@@ -0,0 +1,5 @@
+module SpreeGoogleProducts
+  class BaseJob < Spree::BaseJob
+    queue_as SpreeGoogleProducts.queue
+  end
+end

data/app/models/spree/google_credential.rb

@@ -0,0 +1,29 @@
+module Spree
+  class GoogleCredential < Spree::Base
+    belongs_to :store, class_name: 'Spree::Store'
+
+    validates :merchant_center_id, presence: true, on: :update
+    
+    validates :target_country, length: { is: 2 }, allow_blank: true
+    validates :target_currency, length: { is: 3 }, allow_blank: true
+
+    validates :store_id, presence: true, uniqueness: true
+    
+    if respond_to?(:encrypts)
+      encrypts :access_token
+      encrypts :refresh_token
+    end
+
+    def active?
+      refresh_token.present?
+    end
+
+    def expired?
+      token_expires_at.nil? || token_expires_at <= Time.current
+    end
+
+    def ready_for_sync?
+      active? && merchant_center_id.present?
+    end
+  end
+end

data/app/models/spree/google_product_attribute.rb

@@ -0,0 +1,9 @@
+module Spree
+    class GoogleProductAttribute < Spree::Base
+      belongs_to :product, class_name: 'Spree::Product'
+      serialize :google_issues, coder: JSON
+      validates :gender, inclusion: { in: %w[male female unisex], allow_blank: true }
+      validates :age_group, inclusion: { in: %w[adult kids toddler infant], allow_blank: true }
+      validates :condition, inclusion: { in: %w[new refurbished used], allow_blank: true }
+    end
+  end

data/app/models/spree/google_taxon.rb

@@ -0,0 +1,5 @@
+module Spree
+    class GoogleTaxon < Spree::Base
+      validates :google_id, presence: true, uniqueness: true
+    end
+  end

data/app/models/spree/google_variant_attribute.rb

@@ -0,0 +1,6 @@
+module Spree
+    class GoogleVariantAttribute < Spree::Base
+      belongs_to :variant, class_name: 'Spree::Variant'
+      serialize :google_issues, coder: JSON
+    end
+  end

data/app/models/spree/product_decorator.rb

@@ -0,0 +1,29 @@
+module Spree
+    module ProductDecorator
+      def self.prepended(base)
+        base.has_one :google_product_attribute, class_name: 'Spree::GoogleProductAttribute', dependent: :destroy
+        base.accepts_nested_attributes_for :google_product_attribute, allow_destroy: true
+        base.after_initialize :ensure_google_attribute
+        base.after_commit :sync_to_google, on: [:create, :update]
+      end
+  
+      private
+  
+      def ensure_google_attribute
+        build_google_product_attribute if google_product_attribute.nil?
+      end
+  
+      def sync_to_google
+        Spree::GoogleShopping::SyncProductJob.perform_later(self.id)
+      end
+
+      def sync_to_google_shopping
+        credential = Spree::Store.default.google_credential
+        return unless credential&.ready_for_sync?
+        return if saved_changes.keys.include?('google_product_attribute_updated_at')
+        Spree::GoogleShopping::SyncProductJob.perform_later(self.id)
+      end
+    end
+  end
+
+  Spree::Product.prepend(Spree::ProductDecorator)

data/app/models/spree/store_decorator.rb

@@ -0,0 +1,9 @@
+module Spree
+    module StoreDecorator
+      def self.prepended(base)
+        base.has_one :google_credential, class_name: 'Spree::GoogleCredential', dependent: :destroy
+      end
+    end
+  end
+  
+  ::Spree::Store.prepend(Spree::StoreDecorator)

data/app/models/spree/variant_decorator.rb

@@ -0,0 +1,8 @@
+module Spree
+    module VariantDecorator
+      def self.prepended(base)
+        base.has_one :google_variant_attribute, class_name: 'Spree::GoogleVariantAttribute', dependent: :destroy
+      end
+    end
+  end
+  Spree::Variant.prepend(Spree::VariantDecorator)

data/app/models/spree_google_products/ability.rb

@@ -0,0 +1,10 @@
+module SpreeGoogleProducts
+    class Ability
+      include CanCan::Ability
+  
+      def initialize(user)
+        return unless user.present? && user.respond_to?(:has_spree_role?) && user.has_spree_role?('admin')
+        can :manage, Spree::GoogleCredential
+      end
+    end
+  end

data/app/services/spree/google_shopping/content_service.rb

@@ -0,0 +1,215 @@
+require 'google/apis/content_v2_1'
+
+module Spree
+  module GoogleShopping
+    class ContentService
+      def initialize(credential)
+        @credential = credential
+        @service = Google::Apis::ContentV2_1::ShoppingContentService.new
+        @service.authorization = Spree::GoogleTokenService.new(@credential).token
+      end
+
+      def push_product(product)
+        ([product.master] + product.variants).each do |variant|
+          price = price_object_for(variant)
+          if price.nil? || price.amount.blank? || price.amount.zero?
+            next
+          end
+
+          product_obj = build_product_payload(variant)
+          
+          begin
+            @service.insert_product(@credential.merchant_center_id, product_obj)
+            update_status(variant, 'pending', [])
+          rescue Google::Apis::ClientError => e
+            handle_google_error(variant, e)
+          end
+        end
+      end
+
+      def fetch_product_status(variant)
+        return unless variant.sku.present?
+        
+        g_id = "online:en:#{@credential.target_country}:#{variant.sku}"
+        
+        begin
+
+          product_status = @service.get_productstatus(@credential.merchant_center_id, g_id)
+          
+          shopping_status = product_status.destination_statuses.find { |s| s.destination == "Shopping" }
+          
+          final_status = case shopping_status&.status
+                         when 'approved' then 'active'
+                         when 'disapproved' then 'disapproved'
+                         when 'pending' then 'pending'
+                         else 'pending'
+                         end
+          
+          issues = product_status.item_level_issues.map do |issue|
+            { "description" => issue.description, "detail" => issue.detail, "code" => issue.code }
+          end
+          
+          update_status(variant, final_status, issues)
+          Rails.logger.info "GOOGLE STATUS FETCH: #{variant.sku} is now '#{final_status}'"
+          
+        rescue Google::Apis::ClientError => e
+          if e.status_code == 404
+            update_status(variant, 'not_found_on_google', [])
+          else
+            Rails.logger.error "GOOGLE STATUS ERROR: #{e.message}"
+          end
+        end
+      end
+
+      private
+
+      def price_object_for(variant)
+        variant.price_in(@credential.target_currency)
+      end
+
+      def build_product_payload(variant)
+        product = variant.product
+        g_prod_attr = product.google_product_attribute 
+        g_var_attr = variant.google_variant_attribute 
+        
+        brand = g_prod_attr&.brand.presence || product.property('brand') || 'Generic'
+        
+        raw_product_type = g_prod_attr&.product_type.presence || @credential.default_product_type
+        product_types_list = raw_product_type.present? ? [raw_product_type] : []
+
+        google_category_id = g_prod_attr&.google_product_category.presence || @credential.default_google_product_category
+
+        raw_gtin = g_var_attr&.gtin.presence || g_prod_attr&.gtin.presence
+        gtin = (raw_gtin && raw_gtin.length >= 8) ? raw_gtin : nil
+        
+        mpn = g_var_attr&.mpn.presence || g_prod_attr&.mpn.presence || variant.sku
+
+        gender = g_prod_attr&.gender.presence 
+        age_group = g_prod_attr&.age_group.presence
+        condition = g_prod_attr&.condition.presence || 'new'
+
+        price_obj = price_object_for(variant)
+        current_price = price_obj.amount
+        original_price = price_obj.compare_at_amount
+        
+        google_price = nil
+        google_sale_price = nil
+        sale_date_range = nil
+
+        if original_price.present? && original_price > current_price
+          google_price = { value: original_price.to_s, currency: @credential.target_currency }
+          google_sale_price = { value: current_price.to_s, currency: @credential.target_currency }
+          
+          start_date = g_prod_attr&.sale_start_at
+          end_date = g_prod_attr&.sale_end_at
+
+          if start_date.present? && end_date.present?
+            start_iso = start_date.beginning_of_day.iso8601
+            end_iso = end_date.end_of_day.iso8601
+            sale_date_range = "#{start_iso}/#{end_iso}"
+          end
+        else
+          google_price = { value: current_price.to_s, currency: @credential.target_currency }
+          google_sale_price = nil
+        end
+        
+        product_input_weight = nil
+        if variant.weight.present? && variant.weight > 0
+          product_input_weight = Google::Apis::ContentV2_1::ProductShippingWeight.new(
+            value: variant.weight.to_f,
+            unit: 'kg'
+          )
+        end
+
+        product_input_length = nil
+        product_input_width = nil
+        product_input_height = nil
+
+        if variant.depth.present? && variant.width.present? && variant.height.present?
+           product_input_length = Google::Apis::ContentV2_1::ProductShippingDimension.new(value: variant.depth.to_f, unit: 'cm')
+           product_input_width = Google::Apis::ContentV2_1::ProductShippingDimension.new(value: variant.width.to_f, unit: 'cm')
+           product_input_height = Google::Apis::ContentV2_1::ProductShippingDimension.new(value: variant.height.to_f, unit: 'cm')
+        end
+
+        min_days = g_prod_attr&.min_handling_time.presence || @credential.default_min_handling_time
+        max_days = g_prod_attr&.max_handling_time.presence || @credential.default_max_handling_time
+        
+        shipping_array = []
+        if min_days.present? && max_days.present?
+          shipping_array << Google::Apis::ContentV2_1::ProductShipping.new(
+            country: @credential.target_country,
+            service: "Standard", # Required field
+            price: Google::Apis::ContentV2_1::Price.new(value: "0.00", currency: @credential.target_currency), # FIX: Added Price
+            min_handling_time: min_days.to_i,
+            max_handling_time: max_days.to_i
+          )
+        end
+
+        final_link = product_url(product)
+        final_image_link = image_url(variant)
+
+        Google::Apis::ContentV2_1::Product.new(
+          offer_id: variant.sku, 
+          title: product.name,
+          description: product.description&.truncate(5000) || product.name,
+          
+          link: final_link,
+          image_link: final_image_link,
+          
+          content_language: 'en',
+          target_country: @credential.target_country,
+          channel: 'online',
+          availability: variant.in_stock? ? 'in stock' : 'out of stock',
+          condition: condition,
+          price: google_price,
+          sale_price: google_sale_price,
+          sale_price_effective_date: sale_date_range,
+          shipping_weight: product_input_weight,
+          shipping_length: product_input_length,
+          shipping_width: product_input_width,
+          shipping_height: product_input_height,
+          shipping: shipping_array.presence,
+          brand: brand,
+          product_types: product_types_list,
+          google_product_category: google_category_id,
+          gtin: gtin,
+          mpn: mpn,
+          identifier_exists: gtin.present?,
+          gender: gender,
+          age_group: age_group,
+          item_group_id: product.id.to_s 
+        )
+      end
+
+      def product_url(product)
+        url = Spree::Core::Engine.routes.url_helpers.product_url(product, host: Spree::Store.default.url)
+        url.sub(/^http:/, 'https:')
+      end
+
+      def image_url(variant)
+        image = variant.images.first || variant.product.master.images.first
+        return "" unless image
+        url = Rails.application.routes.url_helpers.rails_blob_url(image.attachment, host: Spree::Store.default.url)
+        url.sub(/^http:/, 'https:')
+      rescue
+        ""
+      end
+
+      def update_status(variant, status, issues)
+        attr = Spree::GoogleVariantAttribute.find_or_initialize_by(variant_id: variant.id)
+        attr.google_status = status
+        attr.google_issues = issues
+        attr.last_synced_at = Time.current
+        attr.save!
+      end
+
+      def handle_google_error(variant, error)
+        error_json = JSON.parse(error.body) rescue {}
+        message = error_json.dig('error', 'message') || error.message
+        
+        update_status(variant, 'disapproved', [{ "description" => "API Error", "detail" => message }])
+        Rails.logger.error "GOOGLE SYNC ERROR (Variant #{variant.id}): #{message}"
+      end
+    end
+  end
+end