pixelforce_kit 0.9

data/app/controllers/concerns/exception_handler.rb

@@ -0,0 +1,57 @@
+module ExceptionHandler
+  extend ActiveSupport::Concern
+
+  included do
+    rescue_from StandardError do |e|
+      notify_error(e, airbrake_notify: true)
+      render_error(500, e.message)
+    end
+
+    rescue_from ActiveRecord::RecordNotFound do |e|
+      notify_error(e)
+      message = (e.message.present? && e.message != 'ActiveRecord::RecordNotFound') ? e.message : I18n.t('errors.record_not_found')
+      render_error(404, message)
+    end
+
+    rescue_from ActiveRecord::RecordInvalid do |e|
+      notify_error(e)
+      message = (e.message.present? && e.message != 'ActiveRecord::RecordInvalid') ? e.message : I18n.t('errors.record_invalid')
+      render_error(422, message)
+    end
+
+    rescue_from ActionController::ParameterMissing do |e|
+      notify_error(e)
+      render_error(404, e.message)
+    end
+
+    rescue_from JSON::ParserError do |e|
+      notify_error(e)
+      render_error(404, I18n.t('errors.record_invalid'))
+    end
+
+    rescue_from ActiveRecord::RecordNotUnique do |e|
+      notify_error(e)
+      message = (e.message.present? && e.message != 'ActiveRecord::RecordNotUnique') ? e.message : I18n.t('errors.record_not_unique')
+      render_error(404, message)
+    end
+
+    private
+
+    def notify_error(error, airbrake_notify: false)
+      airbrake_notify(error) if airbrake_notify
+      raise_error(error)
+    end
+
+    def raise_error(error)
+      if Rails.env.test? || Rails.env.development?
+        raise error
+      end
+    end
+
+    def airbrake_notify(error)
+      if Rails.env.production? || Rails.env.staging?
+        Airbrake.notify(error)
+      end
+    end
+  end
+end

data/app/controllers/concerns/request_header_handler.rb

@@ -0,0 +1,35 @@
+module RequestHeaderHandler
+  extend ActiveSupport::Concern
+
+  def cloudfront_headers
+    @cloudfront_headers ||= {
+      cloudfront_viewer_address:             request.headers['CloudFront-Viewer-Address'],
+      cloudfront_viewer_country:             request.headers['CloudFront-Viewer-Country'],
+      cloudfront_is_ios_viewer:              request.headers['CloudFront-Is-Ios-Viewer'],
+      cloudfront_is_tablet_viewer:           request.headers['CloudFront-Is-Tablet-Viewer'],
+      cloudfront_viewer_country_name:        request.headers['CloudFront-Viewer-Country-Name'],
+      cloudfront_is_mobile_viewer:           request.headers['CloudFront-Is-Mobile-Viewer'],
+      cloudfront_is_smarttv_viewer:          request.headers['CloudFront-Is-Smarttv-Viewer'],
+      cloudfront_viewer_country_region:      request.headers['CloudFront-Viewer-Country-Region'],
+      cloudfront_is_android_viewer:          request.headers['CloudFront-Is-Android-Viewer'],
+      cloudfront_viewer_country_region_name: request.headers['CloudFront-Viewer-Country-Region-Name'],
+      cloudfront_viewer_city:                request.headers['CloudFront-Viewer-City'],
+      cloudfront_viewer_latitude:            request.headers['CloudFront-Viewer-Latitude'],
+      cloudfront_viewer_longitude:           request.headers['CloudFront-Viewer-Longitude'],
+      cloudfront_viewer_postal_code:         request.headers['CloudFront-Viewer-Postal-Code'],
+      cloudfront_is_desktop_viewer:          request.headers['CloudFront-Is-Desktop-Viewer']
+    }
+  end
+
+  def device_headers
+    @device_headers ||= {
+      app_version:       request.headers['HTTP_X_APP_VERSION'],
+      platform:          request.headers['HTTP_X_PLATFORM'],
+      device_model:      request.headers['HTTP_X_DEVICE_MODEL'],
+      os_version:        request.headers['HTTP_X_OS_VERSION'],
+      app_build_version: request.headers['HTTP_X_APP_BUILD_VERSION'],
+      device_token:      request.headers['HTTP_X_DEVICE_TOKEN'],
+      user_timezone:     request.headers['HTTP_X_USER_TIMEZONE']
+    }
+  end
+end

data/app/controllers/concerns/response_handler.rb

@@ -0,0 +1,51 @@
+module ResponseHandler
+  extend ActiveSupport::Concern
+
+  included do
+    before_action :config_default_response_settings
+    layout false
+  end
+
+  def config_default_response_settings
+    set_response_format
+  end
+
+  def set_response_format
+    if request.format.to_s != 'text/csv'
+      request.format = :json
+      self.content_type = 'application/json'
+    end
+  end
+
+  def render_success
+    render json: {}, status: :ok
+  end
+
+  def render_no_content
+    render json: {}, status: :no_content
+  end
+
+  def render_error(status, message, errors = nil, source: nil, meta: {}, admin_server_error: false)
+    response = {
+      'status' => 'error',
+      'source' => source,
+      'errors' => {},
+      'meta' => meta
+    }
+  
+    if errors.is_a?(ActiveModel::Errors)
+      errors.each do |error|
+        attribute = error.attribute.to_s
+        error_message = error.message
+        response['errors'][attribute] ||= []
+        response['errors'][attribute] << error_message
+      end
+    elsif errors.is_a?(Hash)
+      response['errors'] = errors
+    else
+      response['errors'] = admin_server_error ? { 'root' => { 'serverError' => { message: message } } } : { 'server' => [message] }
+    end
+  
+    render json: response, status: status
+  end
+end

data/app/controllers/concerns/search_params_parser.rb

@@ -0,0 +1,35 @@
+module SearchParamsParser
+  extend ActiveSupport::Concern
+
+  def get_search_params
+    return @get_search_params if defined?(@get_search_params)
+
+    @get_search_params = search_params(search_filter_params)
+  end
+
+  def search_filter_params
+    return {} if params[:filter].blank?
+
+    @search_filter_params ||= additional_search_filter_params
+    @search_filter_params
+  end
+
+  def additional_search_filter_params
+    params.require(:filter).permit!
+  end
+
+  def search_params(extra_params = {})
+    id = keywords&.first&.delete('%')&.to_i
+    @search_params = if id && !id.zero?
+                       extra_params.delete('keyword')
+                       {
+                         id: id
+                       }
+                     else
+                       {
+                         keyword: keywords
+                       }
+                     end
+    @search_params.merge!(extra_params)
+  end
+end

data/app/controllers/pages_controller.rb

@@ -0,0 +1,36 @@
+class PagesController < ApplicationController
+  layout 'rails_template'
+
+  def index; end
+
+  def fonts_page; end
+
+  def spinners_page; end
+
+  def animations_page; end
+
+  def global_notice_page
+    flash.now[:notice] = 'Here is a notice flash message!'
+    flash.now[:success] = 'Here is a success flash message!'
+    flash.now[:warning] = 'Here is a warning flash message!'
+    flash.now[:error] = 'Here is an error flash message!'
+  end
+
+  def new
+    @template_model = TemplateModel.new
+  end
+
+  def create
+    @template_model = TemplateModel.new(template_model_params)
+    if @template_model.save
+      flash[:success] = 'Template has been created successfully.'
+      redirect_to new_template_model_path
+    else
+      render :new
+    end
+  end
+
+  def template_model_params
+    params.require(:template_model).permit(:first_name, :last_name, :email, :dob, :gender, :message, :level, :active)
+  end
+end

data/app/controllers/users_controller.rb

@@ -0,0 +1,3 @@
+class UsersController < ApplicationController
+  def reset_password_success; end
+end

data/app/models/ahoy/event.rb

@@ -0,0 +1,8 @@
+class Ahoy::Event < ApplicationRecord
+  include Ahoy::QueryMethods
+
+  self.table_name = 'ahoy_events'
+
+  belongs_to :visit
+  belongs_to :user, optional: true
+end

data/app/models/ahoy/visit.rb

@@ -0,0 +1,6 @@
+class Ahoy::Visit < ApplicationRecord
+  self.table_name = 'ahoy_visits'
+
+  has_many :events, class_name: 'Ahoy::Event'
+  belongs_to :user, optional: true
+end

data/app/models/application_record.rb

@@ -0,0 +1,11 @@
+class ApplicationRecord < ActiveRecord::Base
+  primary_abstract_class
+  include Searchable
+  include Taggable
+
+  class << self
+    def attach_user_id_to_admin_activity?
+      column_names.include?('user_id') || name == 'User'
+    end
+  end
+end

data/app/models/concerns/account_deletable.rb

@@ -0,0 +1,26 @@
+module AccountDeletable
+  extend ActiveSupport::Concern
+
+  included do
+    def soft_delete!
+      ActiveRecord::Base.transaction do
+        # raise error if user has any active subscription
+        if try(:payment_subscriptions)&.active&.exists?
+          raise StandardError, I18n.t('errors.user_deletion_error')
+        end
+
+        user_devices.destroy_all
+        update_columns(
+          deleted_at:           Time.zone.now,
+          tokens:               nil,
+          email:                nil,
+          uid:                  SecureRandom.uuid,
+          encrypted_password:   '',
+          first_name:           nil,
+          last_name:            nil,
+          email_before_deleted: email
+        )
+      end
+    end
+  end
+end

data/app/models/concerns/assets_uploadable.rb

@@ -0,0 +1,20 @@
+module AssetsUploadable
+  extend ActiveSupport::Concern
+
+  class_methods do
+    def has_uploadable(*fields, **_options)
+      fields.each do |field|
+        attr_accessor "#{field}_blob_id"
+
+        after_save do
+          blob_id = send("#{field}_blob_id")
+          if blob_id.present?
+            blob = ActiveStorage::Blob.find_signed(blob_id)
+            send("#{field}_blob_id=", nil)
+            send(field).attach(blob)
+          end
+        end
+      end
+    end
+  end
+end

data/app/models/concerns/codenamable.rb

@@ -0,0 +1,13 @@
+module Codenamable
+  extend ActiveSupport::Concern
+
+  included do
+    before_create :set_code_name
+
+    validates :name, presence: true
+  end
+
+  def set_code_name
+    self.code_name = name.parameterize(separator: '_') if code_name.blank?
+  end
+end

data/app/models/concerns/image_sizable.rb

@@ -0,0 +1,58 @@
+module ImageSizable
+  extend ActiveSupport::Concern
+
+  class_methods do
+    def has_sizable(*fields, **_options)
+      fields.each do |field|
+        define_method("#{field}_urls") do |*selected_sizes|
+          attachment = send(field)
+          return {} unless attachment.attached?
+
+          generate_urls(attachment, *selected_sizes)
+        end
+      end
+    end
+  end
+
+  def generate_urls(blob, *selected_sizes)
+    selected_sizes = default_sizes if selected_sizes.empty?
+    selected_sizes.map!(&:to_s)
+
+    urls = {}
+    if blob.image?
+      selected_sizes.each do |size|
+        if size == 'original'
+          urls[size] = Rails.application.routes.url_helpers.rails_blob_url(blob)
+        else
+          variant = blob.variant(resize_to_limit: size_detail(size))
+          urls[size] = Rails.application.routes.url_helpers.rails_representation_url(variant)
+        end
+      end
+    else
+      urls['original'] = Rails.application.routes.url_helpers.rails_blob_url(blob)
+    end
+    urls
+  end
+
+  def size_detail(size)
+    case size
+    when 'small'
+      [600, 600]
+    when 'medium'
+      [1200, 1200]
+    when 'large'
+      [1920, 1920]
+    else
+      'original'
+    end
+  end
+
+  def default_sizes
+    @default_sizes ||= %w[
+      original
+      small
+      medium
+      large
+    ]
+  end
+end

data/app/models/concerns/isolationable.rb

@@ -0,0 +1,18 @@
+module Isolationable
+  extend ActiveSupport::Concern
+
+  def run_in_transaction(retry_times: 10, level: :repeatable_read, &block)
+    if Rails.env.test?
+      ActiveRecord::Base.transaction(&block)
+    else
+      ActiveRecord::Base.transaction isolation: level, &block
+    end
+  rescue ActiveRecord::SerializationFailure => e
+    retry_times -= 1
+    if retry_times.positive?
+      retry
+    else
+      raise ActiveRecord::SerializationFailure
+    end
+  end
+end

data/app/models/concerns/searchable.rb

@@ -0,0 +1,94 @@
+module Searchable
+  extend ActiveSupport::Concern
+
+  class_methods do
+    def search(params = {}, search_order: { id: :desc }, scope: nil, &custom_filter_block)
+      params = {} if params.nil?
+      validate_search_params(params)
+      validate_search_order(search_order)
+      results = scope ||= all
+
+      results = apply_keyword_search(results, params[:keyword]) if params[:keyword].present?
+      results = apply_attribute_filters(results, params)
+      results = apply_custom_filters(results, params, &custom_filter_block)
+      results = none if results.nil?
+      apply_ordering(results, search_order)
+    end
+
+    private
+
+    def default_attributes
+      %i[id created_at updated_at]
+    end
+
+    def validate_search_params(params)
+      valid_keys = searchable_attributes + %i[keyword order] + default_attributes
+      invalid_keys = params.keys.map(&:to_sym) - valid_keys
+      if invalid_keys.any?
+        raise ArgumentError, "Invalid search parameters: #{invalid_keys.join(', ')}, check searchable_attributes"
+      end
+    end
+
+    def validate_search_order(search_order)
+      valid_order_keys = searchable_orders
+      invalid_keys = search_order.keys.map(&:to_sym) - valid_order_keys
+
+      if invalid_keys.any?
+        raise ArgumentError, "Invalid order: #{invalid_keys.join(', ')}, check searchable_orders"
+      end
+    end
+
+    def apply_keyword_search(results, keyword)
+      keyword = ["%#{keyword}%"] if keyword.is_a?(String)
+      keyword_fields = searchable_keyword_fields
+
+      if keyword_fields.any?
+        string_fields = keyword_fields.select { |field| column_for_attribute(field).type == :string }
+        conditions = string_fields.map { |field| "#{field} ILIKE ANY ( array[:keyword] )" }.join(' OR ')
+        results = results.where(conditions, keyword:)
+      else
+        results
+      end
+    end
+
+    def apply_attribute_filters(results, params)
+      (searchable_attributes + default_attributes).each do |attr|
+        value = params[attr] || params[attr.to_s]
+
+        next if value.blank?
+        results = results.where(attr => value)
+      end
+      results
+    end
+
+    def apply_custom_filters(results, params)
+      if block_given?
+        yield(results, params)
+      else
+        results
+      end
+    end
+
+    def apply_ordering(results, search_order)
+      if search_order.present?
+        results.order(search_order)
+      else
+        results.order(id: :desc)
+      end
+    end
+
+    def searchable_attributes
+      # Override this method in the including class to specify which attributes are searchable
+      column_names.map(&:to_sym) & %i[name code_name id user_id transaction_id payment_subscription_id]
+    end
+
+    def searchable_orders
+      %i[id created_at updated_at]
+    end
+
+    def searchable_keyword_fields
+      # Override this method in the including class to specify which fields should be searched for keywords
+      column_names.map(&:to_sym) & %i[name code_name id user_id transaction_id payment_subscription_id identifier]
+    end
+  end
+end

data/app/models/concerns/taggable.rb

@@ -0,0 +1,57 @@
+module Taggable
+  extend ActiveSupport::Concern
+
+  # tag_filter = {
+  #   groups: [
+  #     { category: 'workout' },
+  #     { code_names: ['10-minutes', '20-minutes'] }
+  #   ],
+  #   logical_operator: 'and'
+  # }
+
+  included do
+    has_many :tag_attachables, as: :taggable, dependent: :destroy, inverse_of: :taggable, class_name: 'TagAttachable'
+    has_many :tags, through: :tag_attachables, source: :tag, class_name: 'Tag'
+
+    accepts_nested_attributes_for :tag_attachables, allow_destroy: true
+
+    scope :tagged_with, lambda { |tag_filter|
+      groups = tag_filter[:groups]
+      logical_operator = tag_filter[:logical_operator]&.downcase
+
+      queries = groups.map do |group|
+        if group[:code_names]
+          subquery = joins(:tags).where(tags: { code_name: group[:code_names] })
+                                 .group("#{table_name}.id")
+                                 .having('COUNT(DISTINCT tags.id) = ?', group[:code_names].size)
+        elsif group[:tag_category_id]
+          subquery = joins(:tags).where(tags: { tag_category_id: group[:tag_category_id] })
+                                 .group("#{table_name}.id")
+        else
+          next
+        end
+
+        subquery
+      end.compact
+
+      if queries.empty?
+        all
+      else
+        if logical_operator == 'or'
+          combined_query = queries.map(&:to_sql).join(' UNION ')
+          combined_query = from("(#{combined_query}) AS #{table_name}")
+        else
+          combined_query = queries.reduce do |combined, query|
+            if combined.nil?
+              query
+            else
+              combined.where(id: query.select(:id))
+            end
+          end
+        end
+
+        combined_query.distinct
+      end
+    }
+  end
+end

data/app/models/tag.rb

@@ -0,0 +1,13 @@
+class Tag < ApplicationRecord
+  include Codenamable
+
+  has_many :tag_attachables, dependent: :destroy, class_name: 'TagAttachable'
+  has_many :taggables, through: :tag_attachables
+  belongs_to :tag_category, class_name: 'TagCategory'
+
+  class << self
+    def searchable_attributes
+      %i[name tag_category_id]
+    end
+  end
+end

data/app/models/tag_attachable.rb

@@ -0,0 +1,6 @@
+class TagAttachable < ApplicationRecord
+  belongs_to :taggable, polymorphic: true
+  belongs_to :tag, class_name: 'Tag'
+
+  validates :tag_id, presence: true
+end

data/app/models/tag_category.rb

@@ -0,0 +1,5 @@
+class TagCategory < ApplicationRecord
+  include Codenamable
+
+  has_many :tags, dependent: :destroy, class_name: 'Tag'
+end

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "pixelforce_kit"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/db/migrate/20220617021719_create_ahoy_visits_and_events.rb

@@ -0,0 +1,67 @@
+class CreateAhoyVisitsAndEvents < ActiveRecord::Migration[6.1]
+  def change
+    create_table :ahoy_visits do |t|
+      t.string :visit_token
+      t.string :visitor_token
+
+      # the rest are recommended but optional
+      # simply remove any you don't want
+
+      # user
+      t.references :user
+
+      # standard
+      t.string :ip
+      t.text :user_agent
+      t.text :referrer
+      t.string :referring_domain
+      t.text :landing_page
+
+      # technology
+      t.string :browser
+      t.string :os
+      t.string :device_type
+
+      # location
+      t.string :country
+      t.string :region
+      t.string :city
+      t.float :latitude
+      t.float :longitude
+
+      # utm parameters
+      t.string :utm_source
+      t.string :utm_medium
+      t.string :utm_term
+      t.string :utm_content
+      t.string :utm_campaign
+
+      # native apps
+      t.string :app_version
+      t.string :os_version
+      t.string :platform
+
+      t.datetime :started_at
+    end
+
+    add_index :ahoy_visits, :visit_token, unique: true
+
+    create_table :ahoy_events do |t|
+      t.references :visit
+      t.bigint :user_id
+      t.bigint :admin_action_on_user_id
+      
+      t.string :user_type
+      t.string :name
+      t.jsonb :properties
+      t.jsonb :cloudfront_headers, default: {}
+      t.datetime :time
+    end
+
+    add_index :ahoy_events, [:name, :time]
+    add_index :ahoy_events, :properties, using: :gin, opclass: :jsonb_path_ops
+    add_index :ahoy_events, %i[user_id user_type]
+    add_index :ahoy_events, :cloudfront_headers, using: :gin
+    add_index :ahoy_events, :admin_action_on_user_id
+  end
+end

data/db/migrate/20240828040425_create_tags.rb

@@ -0,0 +1,12 @@
+class CreateTags < ActiveRecord::Migration[7.1]
+  def change
+    create_table :tags do |t|
+      t.string :name
+      t.string :code_name
+      t.references :tag_category
+      t.timestamps
+    end
+
+    add_index :tags, [:code_name, :tag_category_id], unique: true
+  end
+end