rails_onboarding 0.6.1

data/app/models/rails_onboarding/analytics.rb

@@ -0,0 +1,255 @@
+module RailsOnboarding
+  class Analytics
+    # Default pagination settings to prevent memory issues
+    DEFAULT_PAGE_SIZE = 1000
+    MAX_PAGE_SIZE = 10000
+
+    class << self
+      # Summary methods for analytics reporting
+
+      def onboarding_completion_rate(date_range: nil)
+        events = base_events_query(date_range)
+
+        started_count = events.by_event_type(AnalyticsEvent::ONBOARDING_STARTED).count
+        return 0.0 if started_count.zero?
+
+        completed_count = events.by_event_type(AnalyticsEvent::ONBOARDING_COMPLETED).count
+
+        (completed_count.to_f / started_count * 100).round(2)
+      end
+
+      def onboarding_skip_rate(date_range: nil)
+        events = base_events_query(date_range)
+
+        started_count = events.by_event_type(AnalyticsEvent::ONBOARDING_STARTED).count
+        return 0.0 if started_count.zero?
+
+        skipped_count = events.by_event_type(AnalyticsEvent::ONBOARDING_SKIPPED).count
+
+        (skipped_count.to_f / started_count * 100).round(2)
+      end
+
+      def average_completion_time(date_range: nil)
+        events = base_events_query(date_range)
+        completion_events = events.by_event_type(AnalyticsEvent::ONBOARDING_COMPLETED)
+
+        # properties is serialized JSON stored in a plain text column, so
+        # filtering by a key inside it has to happen in Ruby, not SQL -
+        # JSON_EXTRACT is a MySQL/SQLite function name; PostgreSQL has no
+        # such function (it uses ->/->> on an actual json/jsonb column).
+        # Process in batches to prevent memory issues.
+        total_time = 0.0
+        count = 0
+
+        completion_events.find_each(batch_size: DEFAULT_PAGE_SIZE) do |event|
+          completion_time = event.properties&.dig("completion_time_seconds")
+          next if completion_time.nil?
+
+          total_time += completion_time.to_f
+          count += 1
+        end
+
+        return 0.0 if count.zero?
+
+        (total_time / count).round(2)
+      end
+
+      def step_completion_rates(date_range: nil)
+        events = base_events_query(date_range)
+
+        step_events = events.by_event_type(AnalyticsEvent::ONBOARDING_STEP_COMPLETED)
+
+        # Process in batches to prevent memory issues
+        step_counts = Hash.new(0)
+        step_events.find_each(batch_size: DEFAULT_PAGE_SIZE) do |event|
+          step_name = event.properties&.dig("step_name")
+          step_counts[step_name] += 1 if step_name
+        end
+
+        total_users = events.by_event_type(AnalyticsEvent::ONBOARDING_STARTED).count
+        return {} if total_users.zero?
+
+        step_counts.transform_values do |count|
+          (count.to_f / total_users * 100).round(2)
+        end
+      end
+
+      def step_skip_rates(date_range: nil)
+        events = base_events_query(date_range)
+
+        skip_events = events.by_event_type(AnalyticsEvent::ONBOARDING_STEP_SKIPPED)
+
+        # Process in batches to prevent memory issues
+        step_skips = Hash.new(0)
+        skip_events.find_each(batch_size: DEFAULT_PAGE_SIZE) do |event|
+          step_name = event.properties&.dig("step_name")
+          step_skips[step_name] += 1 if step_name
+        end
+
+        total_users = events.by_event_type(AnalyticsEvent::ONBOARDING_STARTED).count
+        return {} if total_users.zero?
+
+        step_skips.transform_values do |count|
+          (count.to_f / total_users * 100).round(2)
+        end
+      end
+
+      def average_step_completion_times(date_range: nil)
+        events = base_events_query(date_range)
+
+        # properties is serialized JSON stored in a plain text column, so
+        # filtering by a key inside it has to happen in Ruby, not SQL (see
+        # average_completion_time above) - the time_spent > 0 check below
+        # already excludes events with no time_spent_seconds recorded.
+        step_events = events.by_event_type(AnalyticsEvent::ONBOARDING_STEP_COMPLETED)
+
+        # Process in batches to prevent memory issues
+        step_times = Hash.new { |h, k| h[k] = { total: 0.0, count: 0 } }
+        step_events.find_each(batch_size: DEFAULT_PAGE_SIZE) do |event|
+          step_name = event.properties&.dig("step_name")
+          time_spent = event.properties&.dig("time_spent_seconds").to_f
+          if step_name && time_spent > 0
+            step_times[step_name][:total] += time_spent
+            step_times[step_name][:count] += 1
+          end
+        end
+
+        step_times.transform_values do |data|
+          data[:count] > 0 ? (data[:total] / data[:count]).round(2) : 0.0
+        end
+      end
+
+      def tooltip_engagement_rate(date_range: nil)
+        events = base_events_query(date_range)
+
+        shown_count = events.by_event_type(AnalyticsEvent::TOOLTIP_SHOWN).count
+        return 0.0 if shown_count.zero?
+
+        clicked_count = events.by_event_type(AnalyticsEvent::TOOLTIP_CLICKED).count
+
+        (clicked_count.to_f / shown_count * 100).round(2)
+      end
+
+      def tooltip_metrics_by_feature(date_range: nil)
+        events = base_events_query(date_range)
+
+        tooltip_events = events.where(event_type: [
+          AnalyticsEvent::TOOLTIP_SHOWN,
+          AnalyticsEvent::TOOLTIP_CLICKED,
+          AnalyticsEvent::TOOLTIP_DISMISSED
+        ])
+
+        # Process in batches to prevent memory issues
+        feature_metrics = Hash.new { |h, k| h[k] = { shown: 0, clicked: 0, dismissed: 0 } }
+        tooltip_events.find_each(batch_size: DEFAULT_PAGE_SIZE) do |event|
+          feature = event.properties&.dig("tooltip_feature")
+          next unless feature
+
+          case event.event_type
+          when AnalyticsEvent::TOOLTIP_SHOWN
+            feature_metrics[feature][:shown] += 1
+          when AnalyticsEvent::TOOLTIP_CLICKED
+            feature_metrics[feature][:clicked] += 1
+          when AnalyticsEvent::TOOLTIP_DISMISSED
+            feature_metrics[feature][:dismissed] += 1
+          end
+        end
+
+        feature_metrics.map do |feature, metrics|
+          engagement_rate = metrics[:shown] > 0 ? (metrics[:clicked].to_f / metrics[:shown] * 100).round(2) : 0.0
+
+          {
+            feature: feature,
+            shown: metrics[:shown],
+            clicked: metrics[:clicked],
+            dismissed: metrics[:dismissed],
+            engagement_rate: engagement_rate
+          }
+        end
+      end
+
+      def milestone_achievement_rates(date_range: nil)
+        events = base_events_query(date_range)
+
+        milestone_events = events.by_event_type(AnalyticsEvent::MILESTONE_ACHIEVED)
+
+        # Process in batches to prevent memory issues
+        milestone_counts = Hash.new(0)
+        milestone_events.find_each(batch_size: DEFAULT_PAGE_SIZE) do |event|
+          milestone_key = event.properties&.dig("milestone_key")
+          milestone_counts[milestone_key] += 1 if milestone_key
+        end
+
+        total_users = events.by_event_type(AnalyticsEvent::ONBOARDING_STARTED).count
+        return {} if total_users.zero?
+
+        milestone_counts.transform_values do |count|
+          (count.to_f / total_users * 100).round(2)
+        end
+      end
+
+      def funnel_analysis(date_range: nil)
+        events = base_events_query(date_range)
+
+        started = events.by_event_type(AnalyticsEvent::ONBOARDING_STARTED).count
+
+        # Build step completion counts in batches
+        step_completed_events = events.by_event_type(AnalyticsEvent::ONBOARDING_STEP_COMPLETED)
+        step_completion_counts = Hash.new(0)
+        step_completed_events.find_each(batch_size: DEFAULT_PAGE_SIZE) do |event|
+          step_name = event.properties&.dig("step_name").to_s
+          step_completion_counts[step_name] += 1 if step_name.present?
+        end
+
+        steps = RailsOnboarding.configuration.steps.map.with_index do |step, index|
+          completed = step_completion_counts[step[:name].to_s] || 0
+          retention_rate = started > 0 ? (completed.to_f / started * 100).round(2) : 0.0
+
+          {
+            step_name: step[:name],
+            step_index: index,
+            step_title: step[:title],
+            users_reached: completed,
+            retention_rate: retention_rate
+          }
+        end
+
+        completed = events.by_event_type(AnalyticsEvent::ONBOARDING_COMPLETED).count
+        overall_completion = started > 0 ? (completed.to_f / started * 100).round(2) : 0.0
+
+        {
+          total_started: started,
+          overall_completion_rate: overall_completion,
+          steps: steps
+        }
+      end
+
+      def daily_summary(date: Date.current)
+        date_range = date.beginning_of_day..date.end_of_day
+
+        {
+          date: date,
+          onboarding_started: base_events_query(date_range).by_event_type(AnalyticsEvent::ONBOARDING_STARTED).count,
+          onboarding_completed: base_events_query(date_range).by_event_type(AnalyticsEvent::ONBOARDING_COMPLETED).count,
+          onboarding_skipped: base_events_query(date_range).by_event_type(AnalyticsEvent::ONBOARDING_SKIPPED).count,
+          tooltips_shown: base_events_query(date_range).by_event_type(AnalyticsEvent::TOOLTIP_SHOWN).count,
+          tooltips_clicked: base_events_query(date_range).by_event_type(AnalyticsEvent::TOOLTIP_CLICKED).count,
+          milestones_achieved: base_events_query(date_range).by_event_type(AnalyticsEvent::MILESTONE_ACHIEVED).count
+        }
+      end
+
+      private
+
+      def base_events_query(date_range = nil)
+        return AnalyticsEvent.none unless AnalyticsEvent.table_exists?
+
+        query = AnalyticsEvent.all
+        query = query.by_date_range(date_range.begin, date_range.end) if date_range
+        query
+      rescue ActiveRecord::StatementInvalid
+        # Return empty relation if table doesn't exist
+        AnalyticsEvent.none
+      end
+    end
+  end
+end

data/app/models/rails_onboarding/analytics_event.rb

@@ -0,0 +1,168 @@
+module RailsOnboarding
+  class AnalyticsEvent < ApplicationRecord
+    self.table_name = "rails_onboarding_analytics_events"
+
+    belongs_to :user, polymorphic: true, optional: true
+
+    # Rails 8 compatibility: Handle polymorphic associations gracefully
+    def user=(user_instance)
+      if user_instance
+        klass = user_instance.class
+        unless klass.respond_to?(:has_query_constraints?)
+          klass.define_singleton_method(:has_query_constraints?) { false }
+        end
+        unless klass.respond_to?(:composite_primary_key?)
+          klass.define_singleton_method(:composite_primary_key?) { false }
+        end
+      end
+      super(user_instance)
+    end
+
+    validates :event_type, presence: true
+    validates :occurred_at, presence: true
+
+    serialize :properties, coder: JSON
+
+    scope :by_event_type, ->(type) { where(event_type: type) }
+    scope :by_user, ->(user) { where(user: user) }
+    scope :by_date_range, ->(start_date, end_date) { where(occurred_at: start_date..end_date) }
+    scope :recent, ->(limit = 100) { order(occurred_at: :desc).limit(limit) }
+    scope :with_user, -> { includes(:user) } # Eager load users to prevent N+1 queries
+    scope :ordered, -> { order(occurred_at: :asc) } # Consistent ordering for pagination
+
+    # Event types
+    ONBOARDING_STARTED = "onboarding_started".freeze
+    ONBOARDING_STEP_STARTED = "onboarding_step_started".freeze
+    ONBOARDING_STEP_COMPLETED = "onboarding_step_completed".freeze
+    ONBOARDING_STEP_SKIPPED = "onboarding_step_skipped".freeze
+    ONBOARDING_COMPLETED = "onboarding_completed".freeze
+    ONBOARDING_SKIPPED = "onboarding_skipped".freeze
+    TOOLTIP_SHOWN = "tooltip_shown".freeze
+    TOOLTIP_DISMISSED = "tooltip_dismissed".freeze
+    TOOLTIP_CLICKED = "tooltip_clicked".freeze
+    MILESTONE_ACHIEVED = "milestone_achieved".freeze
+
+    def self.track_event(user:, event_type:, properties: {}, session_id: nil)
+      return unless RailsOnboarding.configuration.enable_analytics
+      return unless table_exists?
+
+      create!(
+        user: user,
+        event_type: event_type,
+        properties: properties,
+        session_id: session_id,
+        occurred_at: Time.current
+      )
+    rescue ActiveRecord::StatementInvalid => e
+      # Gracefully handle missing table - analytics is optional
+      Rails.logger.warn "RailsOnboarding Analytics: #{e.message}" if defined?(Rails)
+      nil
+    end
+
+    def self.track_onboarding_started(user:, session_id: nil)
+      track_event(
+        user: user,
+        event_type: ONBOARDING_STARTED,
+        properties: {
+          user_created_at: user.created_at,
+          total_steps: RailsOnboarding.configuration.total_steps
+        },
+        session_id: session_id
+      )
+    end
+
+    def self.track_step_started(user:, step_name:, step_index:, session_id: nil)
+      track_event(
+        user: user,
+        event_type: ONBOARDING_STEP_STARTED,
+        properties: {
+          step_name: step_name,
+          step_index: step_index,
+          progress_percentage: user.onboarding_progress
+        },
+        session_id: session_id
+      )
+    end
+
+    def self.track_step_completed(user:, step_name:, step_index:, time_spent: nil, session_id: nil)
+      track_event(
+        user: user,
+        event_type: ONBOARDING_STEP_COMPLETED,
+        properties: {
+          step_name: step_name,
+          step_index: step_index,
+          time_spent_seconds: time_spent,
+          progress_percentage: user.onboarding_progress
+        },
+        session_id: session_id
+      )
+    end
+
+    def self.track_step_skipped(user:, step_name:, step_index:, session_id: nil)
+      track_event(
+        user: user,
+        event_type: ONBOARDING_STEP_SKIPPED,
+        properties: {
+          step_name: step_name,
+          step_index: step_index,
+          progress_percentage: user.onboarding_progress
+        },
+        session_id: session_id
+      )
+    end
+
+    def self.track_onboarding_completed(user:, completion_time: nil, was_skipped: false, session_id: nil)
+      track_event(
+        user: user,
+        event_type: was_skipped ? ONBOARDING_SKIPPED : ONBOARDING_COMPLETED,
+        properties: {
+          completion_time_seconds: completion_time,
+          was_skipped: was_skipped,
+          total_steps: RailsOnboarding.configuration.total_steps
+        },
+        session_id: session_id
+      )
+    end
+
+    def self.track_tooltip_interaction(user:, tooltip_feature:, action:, session_id: nil)
+      event_type = case action.to_s
+      when "shown" then TOOLTIP_SHOWN
+      when "dismissed" then TOOLTIP_DISMISSED
+      when "clicked" then TOOLTIP_CLICKED
+      else "tooltip_interaction"
+      end
+
+      track_event(
+        user: user,
+        event_type: event_type,
+        properties: {
+          tooltip_feature: tooltip_feature,
+          action: action
+        },
+        session_id: session_id
+      )
+    end
+
+    def self.track_milestone_achieved(user:, milestone_key:, points_earned:, session_id: nil)
+      track_event(
+        user: user,
+        event_type: MILESTONE_ACHIEVED,
+        properties: {
+          milestone_key: milestone_key,
+          points_earned: points_earned,
+          total_points: user.total_milestone_points
+        },
+        session_id: session_id
+      )
+    end
+
+    def self.track_custom_event(user:, event_name:, event_data: {}, session_id: nil)
+      track_event(
+        user: user,
+        event_type: event_name,
+        properties: event_data,
+        session_id: session_id
+      )
+    end
+  end
+end

data/app/models/rails_onboarding/application_record.rb

@@ -0,0 +1,5 @@
+module RailsOnboarding
+  class ApplicationRecord < ActiveRecord::Base
+    self.abstract_class = true
+  end
+end

data/app/models/rails_onboarding/flow.rb

@@ -0,0 +1,41 @@
+module RailsOnboarding
+  class Flow < ApplicationRecord
+    self.table_name = "rails_onboarding_flows"
+
+    serialize :steps, coder: JSON
+
+    validates :name, presence: true
+
+    scope :active, -> { where(active: true) }
+
+    # Hash-style reader so views written against the old session-hash flows
+    # (flow[:name], flow[:steps], ...) keep working against this AR-backed model.
+    def [](key)
+      public_send(key)
+    end
+
+    # JSON round-trips a saved flow's steps back with string keys, but every
+    # view reads them with symbols (step[:icon], step[:title], ...). Normalize
+    # on read so it doesn't matter whether a step hash was just assigned in
+    # memory or came back from the database.
+    def steps
+      Array(super).map { |step| step.is_a?(Hash) ? step.with_indifferent_access : step }
+    end
+
+    def self.seed_default!
+      create!(
+        name: "Current Configuration",
+        description: "Flow from current configuration",
+        steps: RailsOnboarding.configuration.steps,
+        active: true
+      )
+    end
+
+    def self.activate!(flow)
+      transaction do
+        where.not(id: flow.id).update_all(active: false)
+        flow.update!(active: true)
+      end
+    end
+  end
+end

data/app/services/rails_onboarding/milestone_service.rb

@@ -0,0 +1,105 @@
+module RailsOnboarding
+  class MilestoneService
+    def self.check_and_award_milestones(user, trigger, conditions = {})
+      return [] unless RailsOnboarding.configuration.enable_milestones
+      return [] unless user
+
+      eligible_milestones = RailsOnboarding.configuration.milestones_for_trigger(trigger, conditions)
+      awarded_milestones = []
+
+      eligible_milestones.each do |milestone|
+        next if user.milestone_achieved?(milestone[:key])
+
+        if milestone_conditions_met?(user, milestone, conditions)
+          achieved_milestone = user.achieve_milestone!(milestone[:key])
+          awarded_milestones << achieved_milestone if achieved_milestone
+        end
+      end
+
+      awarded_milestones
+    end
+
+    def self.check_onboarding_step_milestones(user, step_name)
+      check_and_award_milestones(user, :onboarding_step_completed, { step: step_name.to_sym })
+    end
+
+    def self.check_onboarding_completion_milestones(user)
+      check_and_award_milestones(user, :onboarding_completed)
+    end
+
+    def self.check_early_adopter_milestone(user)
+      return [] unless user.created_at > 1.hour.ago
+      check_and_award_milestones(user, :custom, { early_adopter: true })
+    end
+
+    # Award a milestone requested by the client (e.g. the milestones API),
+    # but only if the user genuinely qualifies for it right now. Milestones are
+    # normally granted by the server-side event helpers above; this exists for
+    # clients that want to claim one explicitly, and it re-derives eligibility
+    # from the user's actual state so a request can't grant an unearned award.
+    #
+    # @return [Hash, nil] the awarded milestone config, or nil if the user is
+    #   not eligible / already has it / milestones are disabled
+    def self.claim_if_eligible(user, milestone_key)
+      return nil unless RailsOnboarding.configuration.enable_milestones
+      return nil unless user
+      return nil if user.milestone_achieved?(milestone_key)
+
+      milestone = RailsOnboarding.configuration.milestone_by_key(milestone_key)
+      return nil unless milestone
+      return nil unless user_eligible_for?(user, milestone)
+
+      user.achieve_milestone!(milestone[:key])
+    end
+
+    private
+
+    # Whether +user+ has actually met the trigger a milestone is awarded for,
+    # checked against their real record - not against caller-supplied values.
+    # Any trigger/condition we can't confirm server-side is denied.
+    def self.user_eligible_for?(user, milestone)
+      case milestone[:trigger]
+      when :onboarding_step_completed
+        step = milestone.dig(:conditions, :step)
+        step.present? && user.step_completed?(step)
+      when :onboarding_completed
+        user.onboarding_completed?
+      when :custom
+        custom_conditions_met?(user, milestone[:conditions])
+      else
+        false
+      end
+    end
+
+    # Custom-trigger milestones can carry arbitrary host-defined conditions, so
+    # only the ones we know how to verify from the user's record are honored;
+    # everything else (including an empty condition set) is treated as unearned.
+    def self.custom_conditions_met?(user, conditions)
+      return false if conditions.blank?
+
+      conditions.all? do |key, value|
+        case key.to_sym
+        when :early_adopter
+          value == true && user.created_at.present? && user.created_at > 1.hour.ago
+        else
+          false
+        end
+      end
+    end
+
+    def self.milestone_conditions_met?(user, milestone, trigger_conditions)
+      return true unless milestone[:conditions]
+
+      milestone[:conditions].all? do |key, value|
+        case key
+        when :step
+          trigger_conditions[:step] == value.to_sym
+        when :early_adopter
+          user.created_at > 1.hour.ago
+        else
+          trigger_conditions[key] == value
+        end
+      end
+    end
+  end
+end

data/app/views/layouts/rails_onboarding/admin.html.erb

@@ -0,0 +1,106 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <title>RailsOnboarding Admin</title>
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <%= csrf_meta_tags %>
+  <%= csp_meta_tag %>
+
+  <%= stylesheet_link_tag "rails_onboarding/application", media: "all" %>
+  <%= stylesheet_link_tag "rails_onboarding/admin", media: "all" %>
+  <%= javascript_include_tag "rails_onboarding/application", "data-turbo-track": "reload", defer: true %>
+</head>
+
+<body class="admin-layout">
+  <div class="admin-container">
+    <!-- Sidebar Navigation -->
+    <aside class="admin-sidebar">
+      <div class="admin-sidebar-header">
+        <h1 class="admin-logo">
+          <span class="admin-logo-icon">📊</span>
+          RailsOnboarding
+        </h1>
+      </div>
+
+      <nav class="admin-nav">
+        <%= link_to admin_dashboard_path, class: "admin-nav-item #{current_page?(admin_dashboard_path) ? 'onboarding-active' : ''}" do %>
+          <span class="admin-nav-icon">📈</span>
+          Dashboard
+        <% end %>
+
+        <%= link_to admin_users_path, class: "admin-nav-item #{current_page?(admin_users_path) ? 'onboarding-active' : ''}" do %>
+          <span class="admin-nav-icon">👥</span>
+          Users
+        <% end %>
+
+        <%= link_to admin_flows_path, class: "admin-nav-item #{current_page?(admin_flows_path) ? 'onboarding-active' : ''}" do %>
+          <span class="admin-nav-icon">🔄</span>
+          Flows
+        <% end %>
+
+        <%= link_to admin_ab_tests_path, class: "admin-nav-item #{current_page?(admin_ab_tests_path) ? 'onboarding-active' : ''}" do %>
+          <span class="admin-nav-icon">🧪</span>
+          A/B Tests
+        <% end %>
+
+        <%# Leaves the engine for the host app's root. Guarded because a host
+            app is not required to define a root route, and a missing one here
+            would break every admin page. %>
+        <% if main_app.respond_to?(:root_path) %>
+          <%= link_to main_app.root_path, class: "admin-nav-item admin-nav-item-home" do %>
+            <span class="admin-nav-icon">🏠</span>
+            Home
+          <% end %>
+        <% end %>
+      </nav>
+
+      <div class="admin-sidebar-footer">
+        <div class="admin-user-info">
+          <% if respond_to?(:current_user) && current_user %>
+            <div class="admin-user-avatar">
+              <%= current_user.email&.first&.upcase || 'A' %>
+            </div>
+            <div class="admin-user-details">
+              <div class="admin-user-name"><%= current_user.email || 'Admin' %></div>
+              <div class="admin-user-role">Administrator</div>
+            </div>
+          <% end %>
+        </div>
+      </div>
+    </aside>
+
+    <!-- Main Content -->
+    <main class="admin-main">
+      <!-- Header -->
+      <header class="admin-header">
+        <div class="admin-header-content">
+          <h2 class="admin-page-title"><%= yield :page_title %></h2>
+          <div class="admin-header-actions">
+            <%= yield :header_actions %>
+          </div>
+        </div>
+      </header>
+
+      <!-- Flash Messages -->
+      <% if flash.any? %>
+        <div class="admin-flash-messages">
+          <% flash.each do |type, message| %>
+            <div class="admin-flash-message admin-flash-<%= type %>" data-controller="flash">
+              <span class="admin-flash-icon">
+                <%= type == 'notice' ? '✓' : '⚠' %>
+              </span>
+              <span class="admin-flash-text"><%= message %></span>
+              <button class="admin-flash-close" data-action="click->flash#dismiss">×</button>
+            </div>
+          <% end %>
+        </div>
+      <% end %>
+
+      <!-- Page Content -->
+      <div class="admin-content">
+        <%= yield %>
+      </div>
+    </main>
+  </div>
+</body>
+</html>