Class: Crm::PostsController

# File 'app/controllers/crm/posts_controller.rb', line 325

def analyze_seo
  authorize!(:update, Post)

  site_maps = @post.site_maps.to_a

  if site_maps.empty?
    flash[:warning] = 'No sitemaps found for this post. The post may need to be published first.'
    redirect_to post_path(@post, anchor: 'seo-schema')
    return
  end

  return_path = post_path(@post, anchor: 'seo-schema')

  # Queue analysis for each sitemap with return path back to post. The jobs
  # surface automatically in the global Jobs tracker — every status-tracked
  # worker enqueued during a CRM request is captured (see
  # CrmController#persist_enqueued_status_jobs + the Sidekiq client middleware).
  site_maps.each do |site_map|
    SeoPageAnalysisWorker.perform_async(site_map.id, { return_path: return_path })
  end

  flash[:info] = "SEO analysis queued for #{site_maps.size} locale(s): #{site_maps.map(&:locale).join(', ')}. Analysis takes ~1 minute per locale."

  # Redirect back to the post immediately — queued jobs appear in the Jobs
  # tracker (top-right) with live progress; results land on refresh.
  redirect_to return_path
end

#calendar ⇒ `Object`



211
212
213

# File 'app/controllers/crm/posts_controller.rb', line 211

def calendar
  @event = Event.new
end

#check_links ⇒ `Object`

POST /posts/:id/check_links
Queues a background link audit and redirects to job status page.

# File 'app/controllers/crm/posts_controller.rb', line 425

def check_links
  authorize!(:update, @post)

  html = active_html_for(@post)
  if html.blank?
    flash[:info] = 'Post has no content to check.'
    redirect_to post_path(@post, anchor: 'internal-links') and return
  end

  return_path = post_path(@post, anchor: 'internal-links')
  job_id = ArticleLinkCheckerWorker.perform_async(
    'article_ids' => [@post.id],
    'skip_external' => true,
    'return_path' => return_path
  )

  redirect_to job_path(job_id)
end

#clone ⇒ `Object`

# File 'app/controllers/crm/posts_controller.rb', line 124

def clone
  @old_post = Post.find(params[:id])
  authorize!(:create, @post)
  @post = @old_post.deep_dup
  @post.published_at = nil
  if @post.save
    flash[:info] = 'Post was successfully cloned.'
    redirect_to edit_post_path(@post.id)
  else
    flash[:error] = "Error cloning post: #{@post.errors_to_s}"
    redirect_to post_path(@old_post.id)
  end
end

#create ⇒ `Object`

# File 'app/controllers/crm/posts_controller.rb', line 138

def create
  @post = Post.new((params[:post] || {}).merge(params[:blog_post] || {}).merge(params[:article_post] || {}))
  @post.creator_id ||= current_user.id
  @post.user_id = @post.creator_id

  if @post.save # and @post.save
    respond_to do |format|
      format.html do
        flash[:info] = 'Blog post was successfully created.'
        redirect_to post_path(@post.id)
      end
      format.turbo_stream # Renders create.turbo_stream.erb which calls Turbo.visit() to edit page
    end
  else
    setup_image_template
    respond_to do |format|
      format.html { render :new, status: :unprocessable_content }
      format.turbo_stream { render :new, status: :unprocessable_content } # Re-render form with inline validation errors
    end
  end
end

#destroy ⇒ `Object`

# File 'app/controllers/crm/posts_controller.rb', line 204

def destroy
  authorize!(:destroy, @post)
  flash[:info] = "Post #{@post.id} destroyed"
  @post.destroy
  redirect_to url_for(action: :index)
end

#drafts ⇒ `Object`

GET /posts/drafts — target of the blog admin bar's "Edit Drafts" link
(drafts_posts_path). There is no dedicated drafts view; reuse the
index pre-filtered to draft posts, matching the state_eq links the
stats cards already use. The route existed without a matching action,
so the link 500'd with AbstractController::ActionNotFound (#5590).



63
64
65

# File 'app/controllers/crm/posts_controller.rb', line 63

def drafts
  redirect_to posts_path(q: { state_eq: 'draft' }, anchor: 'results')
end

#edit ⇒ `Object`

# File 'app/controllers/crm/posts_controller.rb', line 119

def edit
  setup_image_template
  authorize!(:update, @post)
end

#extract_schema ⇒ `Object`

# File 'app/controllers/crm/posts_controller.rb', line 302

def extract_schema
  authorize!(:update, Post)

  if @post.present?
    # Extract schema for the current post
    options = { return_path: post_path(@post.id) }
    job_id = BlogSchemaExtractionWorker.perform_async(@post.id, options)
    flash[:info] = "Schema extraction queued for post: #{@post.subject}"
    redirect_to job_path(job_id)
  elsif params[:article_id].present?
    # Extract schemas from a specific article
    job_id = BlogSchemaExtractionWorker.perform_async(params[:article_id].to_i)
    flash[:info] = "Schema extraction queued for article #{params[:article_id]}"
    redirect_to job_path(job_id)
  else
    # No batch processing - redirect back to posts index
    flash[:warning] = 'Please select a specific post to extract schema from'
    redirect_to posts_path
  end
end

#fix_link ⇒ `Object`

POST /posts/:id/fix_link
Replaces a broken internal link href with a corrected path

# File 'app/controllers/crm/posts_controller.rb', line 368

def fix_link
  authorize!(:update, @post)

  broken_href = params[:broken_href].to_s
  replacement_path = params[:replacement_path].to_s.strip
  if broken_href.blank? || replacement_path.blank?
    flash[:error] = 'Both the broken link and replacement path are required.'
    redirect_to post_path(@post, anchor: 'internal-links') and return
  end

  html = active_html_for(@post)
  if html.blank?
    flash[:error] = 'Post has no content to fix.'
    redirect_to post_path(@post, anchor: 'internal-links') and return
  end

  new_href = "https://www.warmlyyours.com/{{locale}}#{replacement_path}"
  doc = Nokogiri::HTML::DocumentFragment.parse(html)
  locale_normalizer = ->(s) { s.gsub(/%7B%7B[%20\s]*locale[%20\s]*%7D%7D/i, '{{locale}}').gsub(/\{\{[%20\s]*locale[%20\s]*\}\}/, '{{locale}}') }
  resolved_broken = locale_normalizer.call(broken_href).gsub(/\{\{\s*locale\s*\}\}/, 'en-US')
  replaced = 0

  doc.css('a[href]').each do |link|
    link_href = locale_normalizer.call(link['href'].to_s).gsub(/\{\{\s*locale\s*\}\}/, 'en-US')
    next unless link_href == resolved_broken

    link['href'] = new_href
    replaced += 1
  end

  if replaced.zero?
    flash[:warning] = 'Link not found in post content. It may have already been fixed.'
    redirect_to post_path(@post, anchor: 'internal-links') and return
  end

  new_html = doc.to_html
  @post.solution = new_html
  @post.auto_sanitize_urls = true
  @post.updater_id = current_user.id
  @post.revision_change_notes = "Fixed broken link: #{broken_href.truncate(60)}"
  @post.save!

  begin
    Seo::InternalLinkValidator.upsert_editorial_links!(@post)
  rescue StandardError
    nil
  end

  # Re-run audit in background so the cached broken links reflect the fix
  ArticleLinkCheckerWorker.perform_async('article_ids' => [@post.id], 'skip_external' => true)

  flash[:success] = "Fixed #{replaced} link occurrence(s): #{broken_href.truncate(50)} → #{replacement_path}"
  redirect_to post_path(@post, anchor: 'internal-links')
end

#flush_all_cache ⇒ `Object`

# File 'app/controllers/crm/posts_controller.rb', line 293

def flush_all_cache
  authorize!(:update, Post)
  all_posts = Post.published
  all_posts.touch_all
  # Use tag-based purging instead of URL-based purging for better performance
  Post.purge_all_posts_by_tag
  redirect_to url_for(action: :index), notice: 'Cache refreshed for all posts using tag-based purging, this can take a couple minutes'
end

#flush_cache ⇒ `Object`

# File 'app/controllers/crm/posts_controller.rb', line 286

def flush_cache
  authorize!(:update, Post)
  @post.touch
  @post.purge_edge_cache
  redirect_to(@post, notice: 'Cache purge has been queued, this can take a couple minutes')
end

#index ⇒ `Object`

# File 'app/controllers/crm/posts_controller.rb', line 11

def index
  @search_mode = params[:search_mode].presence || 'keyword'
  @search_query = params[:search_query].to_s.strip

  # Direct ID lookup: redirect straight to the post (HTML) or show in results (Turbo Frame)
  if @search_query.match?(/\A\d+\z/)
    post = Post.find_by(id: @search_query.to_i)
    if post
      return redirect_to post_path(post) unless turbo_frame_request?
    end
  end

  @q = Post.with_comments_count.ransack(params[:q])
  @q.sorts = 'updated_at DESC' if @q.sorts.blank?
  @available_schema_types = Article.available_schema_types

  # Apply search based on mode
  base_scope = @q.result
  @posts = apply_search_mode(base_scope, @search_mode, @search_query)

  # Stats for Blogs with Video card
  @total_posts = Post.count
  @posts_with_video = Post.has_video('true').count
  @posts_with_video_percentage = percentage_of(@posts_with_video, @total_posts)

  # Other stats to render with the same component
  @published_posts = Post.published.count
  @scheduled_posts = Post.waiting_to_publish.count
  @no_schema_published = Post.published.no_schema.count
  @with_schema_published = Post.published.has_schema('true').count
  @with_comments_posts = Post.published.joins(:post_comments).distinct.count
  @draft_posts = Post.drafts.count
  @archived_posts = Post.archived.count

  @published_percentage = percentage_of(@published_posts, @total_posts)
  @scheduled_percentage = percentage_of(@scheduled_posts, @total_posts)
  @no_schema_percentage = percentage_of(@no_schema_published, @total_posts)
  @with_schema_percentage = percentage_of(@with_schema_published, @total_posts)
  @with_comments_percentage = percentage_of(@with_comments_posts, @total_posts)
  @draft_percentage = percentage_of(@draft_posts, @total_posts)
  @archived_percentage = percentage_of(@archived_posts, @total_posts)

  respond_to do |format|
    format.html
  end
end

#internal_links ⇒ `Object`

GET /posts/:id/internal_links
Lazy-loaded turbo frame for the Internal Links tab content.

# File 'app/controllers/crm/posts_controller.rb', line 355

def internal_links
  load_internal_links_data
  render partial: 'internal_links_tab',
         locals: { post: @post,
                   outbound_links: @outbound_links,
                   inbound_links: @inbound_links,
                   broken_links: @broken_links,
                   post_site_map: @post_site_map,
                   last_audit_at: @last_audit_at }
end

#keyword_research ⇒ `Object`

GET /posts/:id/keyword_research
Returns keyword suggestions via Turbo Frame

# File 'app/controllers/crm/posts_controller.rb', line 230

def keyword_research
  load_post unless @post
  authorize! :read, @post

  # Extract main topic from post subject
  topic = extract_topic(@post.subject)

  begin
    client = Seo::KeywordsPeopleUseClient.new
    @keyword_result = client.keyword_generator(topic)
    @paa_result = client.people_also_ask(topic)
  rescue Seo::KeywordsPeopleUseClient::AuthenticationError => e
    @error = "API authentication failed: #{e.message}"
  rescue StandardError => e
    @error = "Failed to fetch keywords: #{e.message}"
    Rails.logger.error "[PostsController#keyword_research] #{e.class}: #{e.message}"
  end

  respond_to do |format|
    format.turbo_stream
    format.html { render partial: 'keyword_research_results', locals: { post: @post } }
  end
end

#lookup ⇒ `Object`

GET /posts/lookup

# File 'app/controllers/crm/posts_controller.rb', line 68

def lookup
  term = params[:q].to_s.strip
  per_page = params[:per_page].to_i
  per_page = 20 if per_page < 1 || per_page > 100

  scope = Post.published.where.not(id: params[:exclude_id])

  if term.present?
    ilike = "%#{ActiveRecord::Base.sanitize_sql_like(term)}%"
    scope = scope.where('LOWER(subject) LIKE LOWER(?) OR LOWER(slug) LIKE LOWER(?)', ilike, ilike)
  end

  # Order by subject alphabetically (matching related_articles_for_select), with relevance boost for searches
  scope = if term.present?
            # Sanitize the search term for LIKE comparison
            search_prefix = "#{ActiveRecord::Base.sanitize_sql_like(term)}%"
            scope.order(Arel.sql(ActiveRecord::Base.sanitize_sql_array(['CASE WHEN LOWER(subject) LIKE LOWER(?) THEN 0 ELSE 1 END, subject', search_prefix])))
          else
            scope.order(:subject)
          end

  # Use Pagy for pagination
  @pagy, paginated_scope = pagy(scope, limit: per_page)

  # Pluck data matching the format from related_articles_for_select: "Subject (YYYY-MM-DD) - ID"
  results = paginated_scope.pluck(:id, Arel.sql("articles.subject || ' (' || TO_CHAR(articles.updated_at, 'YYYY-MM-DD') || ') - ' || articles.id::varchar"))

  render json: {
    results: results.map { |id, display_text| { id: id, text: display_text } },
    has_more: @pagy.next.present?,
    page: @pagy.page
  }
end

#new ⇒ `Object`

# File 'app/controllers/crm/posts_controller.rb', line 113

def new
  setup_image_template
  @post = Post.new(original_author_id: current_user.id)
  authorize!(:create, @post)
end

#preview ⇒ `Object`

# File 'app/controllers/crm/posts_controller.rb', line 215

def preview
  @preview_mode = true
  # Generate JWT token for secure preview access
  token = BlogPreviewTokenService.generate_token(@post.id, current_user&.id)
  preview_url = "#{WEB_URL}#{preview_post_path(@post, token: token)}"
  redirect_to preview_url, allow_other_host: true
end

#refresh_oembed ⇒ `Object`

POST /posts/:id/refresh_oembed
Re-renders all oEmbed content (FAQs, products, videos, images) in the post body

# File 'app/controllers/crm/posts_controller.rb', line 446

def refresh_oembed
  authorize!(:update, Post)

  service = Oembed::ContentRefreshService.new
  updated = service.refresh_post(@post)
  result = service.instance_variable_get(:@stats)

  if updated
    parts = []
    parts << "#{result[:faqs_refreshed]} FAQs" if result[:faqs_refreshed].to_i > 0
    parts << "#{result[:products_refreshed]} products" if result[:products_refreshed].to_i > 0
    parts << "#{result[:videos_refreshed]} videos" if result[:videos_refreshed].to_i > 0
    parts << "#{result[:images_refreshed]} images" if result[:images_refreshed].to_i > 0
    flash[:success] = "oEmbed content refreshed: #{parts.any? ? parts.join(', ') : 'content updated'}."
  else
    flash[:info] = 'No oEmbed changes detected — content is already up to date.'
  end

  flash[:warning] = "#{result[:errors].size} error(s): #{result[:errors].first(3).join('; ')}" if result[:errors].any?

  redirect_to post_path(@post, anchor: 'linked-assets')
end

#retrieve_sku_info ⇒ `Object`

# File 'app/controllers/crm/posts_controller.rb', line 254

def retrieve_sku_info
  sku = params[:sku]
  item = Item.find_by(sku: sku)
  ic = CatalogItem.by_skus(sku).main_catalogs
  item_catalog_usa = ic.where(catalog_id: 1).first
  item_catalog_ca = ic.where(catalog_id: 2).first
  product_review = ReviewsIo.fetch_reviews(sku: sku, page: 1, limit: 5)
  rating = Rating.new(product_review, item)

  price_usa = if item_catalog_usa.sale_price_in_effect?
                item_catalog_usa.sale_price
              else
                item_catalog_usa.bom_price
              end

  price_ca = if item_catalog_ca.sale_price_in_effect?
               item_catalog_ca.sale_price
             else
               item_catalog_ca.bom_price
             end

  respond_to do |format|
    format.json do
      render json: { sku: sku,
                     product_name: item_catalog_usa.name,
                     price_usa: price_usa,
                     price_ca: price_ca,
                     reviews: rating.review_count }
    end
  end
end

#send_by_email ⇒ `Object`

# File 'app/controllers/crm/posts_controller.rb', line 223

def send_by_email
  # @post = Article.find(params[:id].split("-")[0])
  redirect_to new_communication_path(resource_id: @post.id, resource_type: 'article')
end

#show ⇒ `Object`

# File 'app/controllers/crm/posts_controller.rb', line 102

def show
  @article = @post
  respond_to do |format|
    format.html
    format.pdf do
      result = Pdf::Document::Article.call(@post)
      send_data result.pdf, filename: result.file_name, type: 'application/pdf', disposition: 'inline'
    end
  end
end

#update ⇒ `Object`

# File 'app/controllers/crm/posts_controller.rb', line 160

def update
  authorize!(:update, @post)
  state_event = post_params[:state_event]

  filtered = post_params.except(:state_event).reject do |key, value|
    %w[published_at revised_at publish_on].include?(key.to_s) && value.blank?
  end
  @post.assign_attributes(filtered)
  @post.updater_id = current_user.id
  saved = @post.save

  # Handle state transitions (archive, publish, etc.) - these save automatically with bang methods
  if saved && state_event.present? && @post.send("can_#{state_event}?")
    begin
      @post.send("#{state_event}!")
    rescue StateMachines::InvalidTransition => e
      @post.errors.add(:base, e.message)
      saved = false
    end
  end

  if saved
    # Backfill any missing data-embedded-asset-uuid attributes synchronously so
    # the form re-renders with UUID-annotated HTML. The service is idempotent —
    # fast no-op when all UUIDs are already present.
    Posts::EmbeddedAssetSyncService.new(@post).call
    @post.reload # picks up UUID-annotated solution + clears cached errors
    flash[:info] = 'Post saved successfully.'
    respond_to do |format|
      format.html { redirect_to post_path(@post.id) }
      format.turbo_stream do
        setup_image_template
        # Renders update.turbo_stream.erb - flash will be appended by TurboStreamFlashable
      end
    end
  else
    setup_image_template
    respond_to do |format|
      format.html { render :edit, status: :unprocessable_content }
      format.turbo_stream { render :edit, status: :unprocessable_content } # Re-render form with inline validation errors
    end
  end
end

Class: Crm::PostsController

Overview

Constant Summary

Constants included from Controllers::Attachable

Constants included from Controllers::ReferenceFindable

Constants included from Controllers::AnalyticsEvents

Constants included from Controllers::ErrorRendering

Constants included from Www::SeoHelper

Constants included from IconHelper

Instance Method Summary collapse

Methods included from Controllers::Articlable

Methods included from Controllers::Attachable

Methods inherited from CrmController

Methods inherited from ApplicationController

Methods included from Controllers::ReturnPathHandling

Methods included from Controllers::AnalyticsEvents

Methods included from Controllers::DeviceDetection

Methods included from Controllers::SubdomainDetection

Methods included from Controllers::TurboSafeRedirect

Methods included from Controllers::TrackingDetection

Methods included from Controllers::AcceleratedFileSending

Methods included from Controllers::ErrorRendering

Methods included from Controllers::TurnstileVerification

Methods included from Controllers::CloudflareCaching

Methods included from Controllers::Webpackable

Methods included from Controllers::Localizable

Methods included from Controllers::Authenticable

Methods included from ApplicationHelper

Methods included from UppyUploaderHelper

Methods included from Www::ImagesHelper

Methods included from Www::SeoHelper

Methods included from UrlsHelper

Methods included from IconHelper

Instance Method Details

#analyze_seo ⇒ Object

#calendar ⇒ Object

#check_links ⇒ Object

#clone ⇒ Object

#create ⇒ Object

#destroy ⇒ Object

#drafts ⇒ Object

#edit ⇒ Object

#extract_schema ⇒ Object

#fix_link ⇒ Object

#flush_all_cache ⇒ Object

#flush_cache ⇒ Object

#index ⇒ Object

#internal_links ⇒ Object

#keyword_research ⇒ Object

#lookup ⇒ Object

#new ⇒ Object

#preview ⇒ Object

#refresh_oembed ⇒ Object

#retrieve_sku_info ⇒ Object

#send_by_email ⇒ Object

#show ⇒ Object

#update ⇒ Object

#analyze_seo ⇒ `Object`