loyalty_ref 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 9121c050f889b1da8ed81d383e140eb59fe2509047624b2bbdee8db73269a61a
+  data.tar.gz: 70f184d4e5d77fad62598cf2bdef2acce13d9f1da17771cf53bc992cca402801
+SHA512:
+  metadata.gz: b893711e8162a2ba5b4df96a7d6144a73ddb1f504b1e800d719b04dafdbe06a64ab1b3cd611414c4a15bc6e9baf2c81960185395a1249a56aececf769ed4531c
+  data.tar.gz: 452d754032c03431816ca66a459e7fa1def567218f87c781aede9d514618d85cd3f19882d59b09aa3e69b6e21dac6cbfbc163c28a336656020c72d5cfa99c0ec

data/CHANGELOG.md

@@ -0,0 +1,27 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+## [0.1.0] - 2025-01-XX
+
+### Added
+- Initial release of LoyaltyRef gem
+- Points system with customizable earning/redeem rules
+- Dynamic tier levels (Silver, Gold, Platinum)
+- Unique referral codes and multi-level tracking
+- Built-in tracking for signups, geo, device (no Redis needed)
+- Admin dashboard with ERB views
+- Support for any user model (User, Customer, Account, etc.)
+- Rails generator for easy installation
+- Comprehensive configuration system
+- Transaction logging and analytics
+- Referral sharing with full analytics
+- Points expiration system
+- Tier change callbacks
+- Device and browser detection
+- Conversion rate tracking 

data/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Kapil Pal
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE. 

data/README.md

@@ -0,0 +1,194 @@
+ # LoyaltyRef 💎
+
+A flexible Ruby gem for building loyalty and referral systems in Rails apps.
+
+* 🎁 Reward users with points based on their activity
+* 🧱 Create dynamic tier levels (Silver, Gold, Platinum)
+* 🤝 Add referral rewards with unique referral codes
+* 🔧 Fully customizable and configurable
+* 🎛️ Admin dashboard (ERB based)
+* 🔄 Supports any user model: `User`, `Customer`, `Account`, etc.
+
+---
+
+## 📚 Documentation
+
+- **[Quick Start Guide](QUICK_START.md)** - Get running in 5 minutes
+- **[Complete Documentation](DOCUMENTATION.md)** - Full developer guide with examples
+- **[API Reference](DOCUMENTATION.md#api-reference)** - All methods and options
+
+---
+
+## 🚀 Installation
+
+```ruby
+# Gemfile
+gem 'loyalty_ref'
+```
+
+```bash
+$ bundle install
+$ rails generate loyalty_ref:install
+$ rails db:migrate
+```
+
+---
+
+## 🛠️ Configuration
+
+Create your configuration block in an initializer:
+
+```ruby
+# config/initializers/loyalty_ref.rb
+
+LoyaltyRef.configure do |config|
+  # Define which model represents your app's user/customer
+  config.reference_class_name = 'User' # or 'Customer', 'Account', etc.
+
+  config.earning_rule = ->(user, event) do
+    # Example: earn 10 points per ₹100 spent
+    event.amount / 10
+  end
+
+  config.redeem_rule = ->(user, offer) do
+    offer.cost_in_points
+  end
+
+  config.tier_thresholds = {
+    "Silver" => 500,
+    "Gold" => 1000,
+    "Platinum" => 2500
+  }
+
+  config.reward_modifier = ->(user) do
+    case user.tier
+    when "Silver" then 1.0
+    when "Gold" then 1.2
+    when "Platinum" then 1.5
+    else 1.0
+    end
+  end
+
+  config.referral_reward = ->(referrer, referee) do
+    LoyaltyRef.earn_points(referrer, 100)
+    LoyaltyRef.earn_points(referee, 50)
+  end
+end
+```
+
+---
+
+## ✅ Features
+
+### 🎁 Loyalty Program
+
+| Feature              | Description                   |
+| -------------------- | ----------------------------- |
+| Points system        | Earn points via config lambda |
+| Custom earning rules | Define rules per event/user   |
+| Redeem points        | Redeem points for offers      |
+| Manual adjustment    | Admins can modify balances    |
+| Points expiration    | e.g. 90 days                  |
+| Transaction logging  | All activity is logged        |
+| Check balance        | Easy method to check          |
+
+### 🧱 Tier System (Dynamic)
+
+| Feature                 | Description                 |
+| ----------------------- | --------------------------- |
+| Dynamic definitions     | e.g. Silver => 500 points   |
+| Auto tier assignment    | Based on balance            |
+| Callbacks on promotion  | `on_tier_changed` hook      |
+| Reward modifier by tier | e.g. Gold users get +20%    |
+| DB persistence          | Can store or calculate tier |
+
+### 🤝 Referral System
+
+| Feature               | Description                                                   |
+| --------------------- | ------------------------------------------------------------- |
+| Unique referral codes | Auto-generated or custom                                      |
+| ?ref=code tracking    | Via signup links                                              |
+| Multi-level referrals | Parent/child tree                                             |
+| Referral rewards      | Custom logic supported                                        |
+| Referral analytics    | Track clicks, accepted signups, geo-location, and device type |
+
+### ⚙️ Core Gem Features
+
+* Developer config block
+* Extensible models
+* Simple public API: `earn_points`, `redeem_points`, `balance`, `track_referral`
+* Rails generators for setup
+* Support for any user model (User, Account, Customer, etc.)
+
+### 🖥️ Admin UI
+
+* Mountable engine with ERB templates
+* Routes like `/loyalty`
+* Views to list users, transactions, referrals
+
+---
+
+## 🔮 Future Scope
+
+### 📊 Analytics & Admin
+
+* Leaderboards by points
+* Referral tree visualizer
+* ActiveAdmin / custom dashboard
+* Export CSV/JSON of logs
+
+### 🔔 Engagement
+
+* Email / in-app notifications
+* Badges based on milestones
+* Activity calendar
+* Social sharing for referral links
+
+---
+
+## 📂 Folder Structure (Gem)
+
+```
+lib/
+├── loyalty_ref.rb
+├── loyalty_ref/
+│   ├── engine.rb
+│   ├── configuration.rb
+│   ├── version.rb
+│   ├── models/
+│   │   ├── transaction.rb
+│   │   ├── referral_log.rb
+│   └── controllers/
+│       ├── dashboard_controller.rb
+app/views/loyalty_ref/dashboard/
+  ├── index.html.erb
+  ├── show.html.erb
+```
+
+---
+
+## 🧪 Usage Examples
+
+```ruby
+# Earn points
+LoyaltyRef.earn_points(current_user, event: order)
+
+# Redeem points
+LoyaltyRef.redeem_points(current_user, offer: coupon)
+
+# Check balance
+LoyaltyRef.balance(current_user)
+
+# Track referral
+LoyaltyRef.track_referral(ref_code: params[:ref])
+```
+
+---
+
+## 📬 Contribution
+
+PRs are welcome 🙌 — help improve the gem or suggest features.
+
+## 📜 License
+
+MIT © 2025 Kapil Pal 

data/app/assets/javascripts/loyalty_ref.js

@@ -0,0 +1,138 @@
+// LoyaltyRef - Device Detection and Geo-location Collection
+// This script automatically collects device and location data when users click referral links
+
+(function() {
+  'use strict';
+
+  // Check if LoyaltyRef tracking is enabled
+  if (typeof window.LoyaltyRefConfig === 'undefined' || !window.LoyaltyRefConfig.enabled) {
+    return;
+  }
+
+  // Device detection
+  function detectDevice() {
+    const userAgent = navigator.userAgent.toLowerCase();
+    
+    // Device type detection
+    let deviceType = 'desktop';
+    if (/mobile|android|iphone|ipod|blackberry|windows phone/.test(userAgent)) {
+      deviceType = 'mobile';
+    } else if (/tablet|ipad/.test(userAgent)) {
+      deviceType = 'tablet';
+    }
+
+    // Browser detection
+    let browser = 'Other';
+    if (userAgent.includes('chrome')) {
+      browser = 'Chrome';
+    } else if (userAgent.includes('firefox')) {
+      browser = 'Firefox';
+    } else if (userAgent.includes('safari') && !userAgent.includes('chrome')) {
+      browser = 'Safari';
+    } else if (userAgent.includes('edge')) {
+      browser = 'Edge';
+    } else if (userAgent.includes('opera')) {
+      browser = 'Opera';
+    }
+
+    return {
+      device_type: deviceType,
+      browser: browser,
+      screen_width: screen.width,
+      screen_height: screen.height,
+      viewport_width: window.innerWidth,
+      viewport_height: window.innerHeight,
+      language: navigator.language,
+      platform: navigator.platform,
+      cookie_enabled: navigator.cookieEnabled,
+      online: navigator.onLine
+    };
+  }
+
+  // Geo-location detection (if enabled and user consents)
+  function detectLocation() {
+    return new Promise((resolve) => {
+      if (!window.LoyaltyRefConfig.collect_geo || !navigator.geolocation) {
+        resolve(null);
+        return;
+      }
+
+      navigator.geolocation.getCurrentPosition(
+        function(position) {
+          resolve({
+            latitude: position.coords.latitude,
+            longitude: position.coords.longitude,
+            accuracy: position.coords.accuracy,
+            timestamp: position.timestamp
+          });
+        },
+        function(error) {
+          console.log('LoyaltyRef: Geolocation not available or denied');
+          resolve(null);
+        },
+        {
+          enableHighAccuracy: false,
+          timeout: 5000,
+          maximumAge: 60000
+        }
+      );
+    });
+  }
+
+  // Collect all device and location data
+  async function collectDeviceData() {
+    const deviceData = detectDevice();
+    const locationData = await detectLocation();
+
+    return {
+      ...deviceData,
+      geo_data: locationData,
+      collected_at: new Date().toISOString()
+    };
+  }
+
+  // Enhanced referral tracking
+  function enhanceReferralTracking() {
+    // Find all referral links
+    const referralLinks = document.querySelectorAll('a[href*="?ref="], a[href*="&ref="]');
+    
+    referralLinks.forEach(link => {
+      link.addEventListener('click', async function(e) {
+        // Only enhance if it's a referral link
+        if (!this.href.includes('ref=')) return;
+
+        try {
+          // Collect device and location data
+          const deviceData = await collectDeviceData();
+          
+          // Store in sessionStorage for the next page load
+          sessionStorage.setItem('loyalty_ref_device_data', JSON.stringify(deviceData));
+          
+          // Add a small delay to ensure data is stored
+          setTimeout(() => {
+            // Continue with normal link navigation
+            return true;
+          }, 100);
+          
+        } catch (error) {
+          console.error('LoyaltyRef: Error collecting device data:', error);
+        }
+      });
+    });
+  }
+
+  // Initialize when DOM is ready
+  if (document.readyState === 'loading') {
+    document.addEventListener('DOMContentLoaded', enhanceReferralTracking);
+  } else {
+    enhanceReferralTracking();
+  }
+
+  // Make functions available globally for manual use
+  window.LoyaltyRef = {
+    detectDevice: detectDevice,
+    detectLocation: detectLocation,
+    collectDeviceData: collectDeviceData
+  };
+
+})(); 

data/app/controllers/loyalty_ref/dashboard_controller.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module LoyaltyRef
+  class DashboardController < ActionController::Base
+    layout "loyalty_ref/dashboard"
+
+    before_action :authenticate_user!
+    before_action :ensure_admin_access!
+
+    def index
+      @total_users = user_class.count
+      @total_transactions = LoyaltyRef::Transaction.count
+      @total_referrals = LoyaltyRef::ReferralLog.count
+      @conversion_rate = LoyaltyRef::ReferralLog.conversion_rate
+      
+      @recent_transactions = LoyaltyRef::Transaction.includes(:user)
+                                                   .order(created_at: :desc)
+                                                   .limit(10)
+      
+      @top_users = user_class.joins(:loyalty_ref_transactions)
+                            .group("users.id")
+                            .order("SUM(loyalty_ref_transactions.points) DESC")
+                            .limit(10)
+    end
+
+    def users
+      @users = safe_paginate(user_class.includes(:loyalty_ref_transactions)
+                        .order(created_at: :desc), 20)
+    end
+
+    def user
+      @user = user_class.find(params[:id])
+      @transactions = safe_paginate(@user.loyalty_ref_transactions
+                          .order(created_at: :desc), 20)
+      @balance = LoyaltyRef.balance(@user)
+      @tier = LoyaltyRef.tier(@user)
+    end
+
+    def transactions
+      @transactions = safe_paginate(LoyaltyRef::Transaction.includes(:user)
+                                            .order(created_at: :desc), 50)
+    end
+
+    def referrals
+      @referrals = safe_paginate(LoyaltyRef::ReferralLog.order(clicked_at: :desc), 50)
+    end
+
+    def analytics
+      @total_clicks = LoyaltyRef::ReferralLog.clicked_count
+      @total_conversions = LoyaltyRef::ReferralLog.converted_count
+      @conversion_rate = LoyaltyRef::ReferralLog.conversion_rate
+      
+      @referrals_by_device = LoyaltyRef::ReferralLog.group(:device_type).count
+      @referrals_by_browser = LoyaltyRef::ReferralLog.group(:browser).count
+      
+      @daily_clicks = LoyaltyRef::ReferralLog.group("DATE(clicked_at)")
+                                            .count
+                                            .sort_by { |date, _| date }
+                                            .last(30)
+    end
+
+    private
+
+    def user_class
+      LoyaltyRef.configuration.reference_class_name.constantize
+    end
+
+    def safe_paginate(relation, per_page = 20)
+      if defined?(Kaminari) && relation.respond_to?(:page)
+        relation.page(params[:page]).per(per_page)
+      else
+        # Fallback pagination without Kaminari
+        page = (params[:page] || 1).to_i
+        offset = (page - 1) * per_page
+        relation.offset(offset).limit(per_page)
+      end
+    end
+
+    def authenticate_user!
+      # Override this method in your app to implement authentication
+      # For example: redirect_to login_path unless current_user
+      true
+    end
+
+    def ensure_admin_access!
+      # Override this method in your app to implement admin authorization
+      # For example: redirect_to root_path unless current_user&.admin?
+      true
+    end
+  end
+end 

data/app/controllers/loyalty_ref/tracking_controller.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module LoyaltyRef
+  class TrackingController < ActionController::Base
+    skip_before_action :verify_authenticity_token, only: [:track_referral]
+    
+    def track_referral
+      ref_code = params[:ref_code]
+      device_data = params[:device_data]
+      
+      if ref_code.present?
+        success = LoyaltyRef.track_referral(
+          ref_code: ref_code,
+          user_agent: request.user_agent,
+          ip_address: request.remote_ip,
+          referrer: request.referer,
+          device_data: device_data
+        )
+        
+        if success
+          render json: { success: true, message: "Referral tracked successfully" }
+        else
+          render json: { success: false, message: "Failed to track referral" }, status: 422
+        end
+      else
+        render json: { success: false, message: "Referral code is required" }, status: 400
+      end
+    end
+  end
+end 

data/app/helpers/loyalty_ref/application_helper.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module LoyaltyRef
+  module ApplicationHelper
+    # Include LoyaltyRef JavaScript and configuration
+    def loyalty_ref_javascript_tag
+      return unless LoyaltyRef.configuration.enable_device_tracking
+      
+      config = {
+        enabled: LoyaltyRef.configuration.enable_device_tracking,
+        collect_geo: LoyaltyRef.configuration.collect_geo_location,
+        api_endpoint: loyalty_ref_track_referral_path
+      }
+      
+      content_tag(:script, "window.LoyaltyRefConfig = #{config.to_json};", type: 'application/javascript') +
+      javascript_include_tag('loyalty_ref', 'data-turbolinks-track': 'reload')
+    end
+
+    # Generate a referral link with enhanced tracking
+    def loyalty_ref_referral_link(user, options = {})
+      return unless user.respond_to?(:referral_code) && user.referral_code.present?
+      
+      base_url = options[:base_url] || root_url
+      ref_param = options[:ref_param] || 'ref'
+      
+      "#{base_url}#{base_url.include?('?') ? '&' : '?'}#{ref_param}=#{user.referral_code}"
+    end
+
+    # Generate a referral link button with styling
+    def loyalty_ref_referral_button(user, text = nil, options = {})
+      text ||= "Share Referral Link"
+      link_text = options[:icon] ? "#{options[:icon]} #{text}" : text
+      
+      link_to(
+        link_text,
+        loyalty_ref_referral_link(user, options),
+        options.merge(
+          class: "loyalty-ref-referral-link #{options[:class]}".strip,
+          target: options[:target] || '_blank',
+          rel: options[:rel] || 'noopener'
+        )
+      )
+    end
+
+    # Display user's referral stats
+    def loyalty_ref_user_stats(user)
+      return unless user.respond_to?(:points_balance)
+      
+      content_tag(:div, class: 'loyalty-ref-user-stats') do
+        concat(content_tag(:div, "Points: #{user.points_balance}", class: 'points'))
+        concat(content_tag(:div, "Tier: #{user.current_tier || 'None'}", class: 'tier'))
+        concat(content_tag(:div, "Referrals: #{user.total_referrals rescue 0}", class: 'referrals'))
+      end
+    end
+  end
+end 

data/app/helpers/loyalty_ref/dashboard_helper.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module LoyaltyRef
+  module DashboardHelper
+    def loyalty_paginate(collection)
+      if defined?(Kaminari) && collection.respond_to?(:current_page)
+        paginate(collection)
+      else
+        # Simple pagination without Kaminari
+        render_simple_pagination(collection)
+      end
+    end
+
+    private
+
+    def render_simple_pagination(collection)
+      return unless collection.respond_to?(:limit_value) && collection.respond_to?(:offset_value)
+      
+      current_page = (collection.offset_value / collection.limit_value) + 1
+      
+      # For fallback pagination, we need to get total count differently
+      # Since we don't have total_count method, we'll just show basic navigation
+      content_tag(:div, class: 'pagination') do
+        links = []
+        
+        # Previous page
+        if current_page > 1
+          links << link_to('Previous', url_for(page: current_page - 1), class: 'pagination-link')
+        end
+        
+        # Current page
+        links << content_tag(:span, "Page #{current_page}", class: 'pagination-current')
+        
+        # Next page (we'll always show this for fallback)
+        links << link_to('Next', url_for(page: current_page + 1), class: 'pagination-link')
+        
+        links.join.html_safe
+      end
+    end
+  end
+end