effective_learndash 0.1.1 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f10afce8560043990198e9b364944ce9ed5d50f4c97f0a070074fa58a2e56014
-  data.tar.gz: b4f516fcd3ceac21941a5db7e7bb8a43766608bba652998dd5f6677c74b3eccc
+  metadata.gz: 83cc9e6d5daa0a6e08e491f1ea9edec7f8e394b045801a2d704eaacab5c93f18
+  data.tar.gz: 467de056d4e11255c927a212e0f893b54ddcac8720ec12bf80299873ff5e2910
 SHA512:
-  metadata.gz: 7b2d11bce9c397f42f95b823003530eedfe21feb80fa08a28d04c92272085906812b9dcf2685b798a171262ae1054661535394246e7374a7f5f3dcd941d4e939
-  data.tar.gz: 1eef5bd56979080599f509b17df4835370fc392d0eded403d39091b0d3974846e9462ed215df69835158d4c0e0d3dad7bc2bea9b9f8160ae34875179522268f9
+  metadata.gz: 1cbb48faa89c8d2a6fee3f47b78cdb41f3cf20871b354f7e88852a5103e0a294d4b2dd1d2eca63be1525dd546e365fd8143416e35942d714039ecd6031a12a0c
+  data.tar.gz: ee47891e98f74e0c8ecdbacbd76f37071a16d95a347bca7014f421a4aeb007b7ffc92d0f96c080dea39c8d57b15b92aa83f06f5558a0ee2182049dfa442952c0

data/README.md

@@ -71,6 +71,15 @@ All authorization checks are handled via the effective_resources gem found in th
 The permissions you actually want to define are as follows (using CanCan):
 
 ```ruby
+can(:show, Effective::LearndashUser) { |lduser| lduser.owner_id == user.id }
+can(:index, Effective::LearndashEnrollment)
+
+can([:index, :show], Effective::LearndashCourse) { |course| !course.draft? }
+can([:show, :index], Effective::CourseRegistrant) { |registrant| registrant.owner == user || registrant.owner.blank? }
+can([:new, :create], EffectiveLearndash.CourseRegistration)
+can([:show, :index], EffectiveLearndash.CourseRegistration) { |registration| registration.owner == user }
+can([:update, :destroy], EffectiveLearndash.CourseRegistration) { |registration| registration.owner == user && !registration.was_submitted? }
+
 if user.admin?
   can :admin, :effective_learndash
 

data/app/assets/config/effective_learndash_manifest.js

@@ -1,3 +1,2 @@
 //= link_directory ../javascripts .js
 //= link_directory ../stylesheets .css
-//= link_directory ../images/effective_learndash

data/app/controllers/admin/course_registrations_controller.rb

@@ -0,0 +1,8 @@
+module Admin
+  class CourseRegistrationsController < ApplicationController
+    before_action(:authenticate_user!) if defined?(Devise)
+    before_action { EffectiveResources.authorize!(self, :admin, :effective_learndash) }
+
+    include Effective::CrudController
+  end
+end

data/app/controllers/effective/course_registrations_controller.rb

@@ -0,0 +1,13 @@
+module Effective
+  class CourseRegistrationsController < ApplicationController
+    before_action(:authenticate_user!) if defined?(Devise)
+
+    include Effective::WizardController
+
+    resource_scope -> {
+      learndash_course = Effective::LearndashCourse.find(params[:learndash_course_id])
+      EffectiveLearndash.CourseRegistration.deep.where(owner: current_user, learndash_course: learndash_course)
+    }
+
+  end
+end

data/app/controllers/effective/learndash_courses_controller.rb

@@ -0,0 +1,32 @@
+module Effective
+  class LearndashCoursesController < ApplicationController
+    include Effective::CrudController
+
+    resource_scope -> {
+      unpublished = EffectiveResources.authorized?(self, :admin, :effective_learndash)
+      Effective::LearndashCourse.learndash_courses(user: current_user, unpublished: unpublished)
+    }
+
+    def show
+      @learndash_course = resource_scope.find(params[:id])
+
+      if @learndash_course.respond_to?(:roles_permit?)
+        raise Effective::AccessDenied.new('Access Denied', :show, @learndash_course) unless @learndash_course.roles_permit?(current_user)
+      end
+
+      EffectiveResources.authorize!(self, :show, @learndash_course)
+
+      if EffectiveResources.authorized?(self, :admin, :effective_learndash)
+        flash.now[:warning] = [
+          'Hi Admin!',
+          ('You are viewing a hidden course.' if @learndash_course.draft?),
+          'Click here to',
+          ("<a href='#{effective_learndash.edit_admin_learndash_course_path(@learndash_course)}' class='alert-link'>edit learndash course settings</a>.")
+        ].compact.join(' ')
+      end
+
+      @page_title ||= @learndash_course.to_s
+    end
+
+  end
+end

data/app/datatables/admin/effective_course_registrations_datatable.rb

@@ -0,0 +1,28 @@
+module Admin
+  class EffectiveCourseRegistrationsDatatable < Effective::Datatable
+    datatable do
+      col :updated_at, visible: false
+      col :created_at, visible: false
+      col :id, visible: false
+
+      col :token, visible: false
+
+      col :created_at, label: 'Created', visible: false
+      col :updated_at, label: 'Updated', visible: false
+      col :submitted_at, label: 'Submitted', visible: false, as: :date
+
+      col :learndash_course
+      col :owner
+
+      col :course_registrants, search: :string, visible: false
+      col :orders, label: 'Order'
+
+      actions_col
+    end
+
+    collection do
+      scope = EffectiveLearndash.CourseRegistration.all.deep.done
+    end
+
+  end
+end

data/app/datatables/admin/effective_learndash_courses_datatable.rb

@@ -15,6 +15,10 @@ module Admin
 
       col :learndash_users, visible: false
 
+      col :can_register
+      col :regular_price, as: :price
+      col :member_price, as: :price
+
       actions_col
     end
 

data/app/datatables/admin/effective_learndash_enrollments_datatable.rb

@@ -14,8 +14,7 @@ module Admin
         time_ago_in_words(enrollment.last_synced_at) + ' ago'
       end
 
-      col :owner, visible: false
-
+      col :owner
       col :learndash_course
       col :learndash_user
 

data/app/datatables/effective_course_registrants_datatable.rb

@@ -0,0 +1,24 @@
+# Used on the Course Registrations courses step
+
+class EffectiveCourseRegistrantsDatatable < Effective::Datatable
+  datatable do
+    col :learndash_course
+    col :owner, label: 'User', action: false
+    col :price, as: :price
+  end
+
+  collection do
+    scope = Effective::CourseRegistrant.deep.all
+
+    if attributes[:learndash_course_id].present?
+      scope = scope.where(learndash_course_id: attributes[:learndash_course_id])
+    end
+
+    if attributes[:course_registration_id].present?
+      scope = scope.where(course_registration_id: attributes[:course_registration_id])
+    end
+
+    scope
+  end
+
+end

data/app/datatables/effective_course_registrations_datatable.rb

@@ -0,0 +1,35 @@
+# Dashboard Course Registrations
+class EffectiveCourseRegistrationsDatatable < Effective::Datatable
+  datatable do
+    order :created_at
+
+    col :token, visible: false
+    col :created_at, visible: false
+
+    col(:submitted_at, label: 'Registered on') do |registration|
+      registration.submitted_at&.strftime('%F') || 'Incomplete'
+    end
+
+    col :learndash_course, search: :string do |registration|
+      registration.learndash_course.to_s
+    end
+
+    col :owner, visible: false, search: :string
+    col :status, visible: false
+    col :orders, action: :show, visible: false, search: :string
+
+    actions_col(actions: []) do |registration|
+      if registration.draft?
+        dropdown_link_to('Continue', effective_learndash.learndash_course_course_registration_build_path(registration.learndash_course, registration, registration.next_step), 'data-turbolinks' => false)
+        dropdown_link_to('Delete', effective_learndash.learndash_course_course_registration_path(registration.learndash_course, registration), 'data-confirm': "Really delete #{registration}?", 'data-method': :delete)
+      else
+        dropdown_link_to('Show', effective_learndash.learndash_course_course_registration_path(registration.learndash_course, registration))
+      end
+    end
+  end
+
+  collection do
+    EffectiveLearndash.CourseRegistration.deep.where(owner: current_user)
+  end
+
+end

data/app/datatables/effective_learndash_courses_datatable.rb

@@ -0,0 +1,28 @@
+# Dashboard Courses
+class EffectiveLearndashCoursesDatatable < Effective::Datatable
+  filters do
+    # Registerable should be first here, so when displayed as a simple datatable on the dashboard they only see registerable courses
+    scope :registerable
+    scope :all
+  end
+
+  datatable do
+    order :title
+    col :id, visible: false
+
+    col :title, label: 'Title' do |learndash_course|
+      link_to(learndash_course.to_s, effective_learndash.learndash_course_path(learndash_course))
+    end
+
+    actions_col show: false do |learndash_course|
+      if learndash_course.can_register?
+        dropdown_link_to('Register', effective_learndash.new_learndash_course_course_registration_path(learndash_course))
+      end
+    end
+  end
+
+  collection do
+    Effective::LearndashCourse.deep.learndash_courses(user: current_user)
+  end
+
+end

data/app/datatables/effective_learndash_enrollments_datatable.rb

@@ -1,7 +1,10 @@
 # Dashboard LearndashUsers
 class EffectiveLearndashEnrollmentsDatatable < Effective::Datatable
   datatable do
-    col :learndash_course
+    col :learndash_course do |enrollment|
+      link_to(enrollment.learndash_course, EffectiveLearndash.learndash_url, target: '_blank')
+    end
+
     col :progress_status
 
     col :last_step, visible: false
@@ -10,6 +13,17 @@ class EffectiveLearndashEnrollmentsDatatable < Effective::Datatable
 
     col :date_started, as: :date
     col :date_completed, as: :date
+
+    actions_col(show: false) do |enrollment|
+      if enrollment.not_started?
+        dropdown_link_to('Start', EffectiveLearndash.learndash_url, target: '_blank')
+      elsif enrollment.in_progress?
+        dropdown_link_to('Continue', EffectiveLearndash.learndash_url, target: '_blank')
+      else
+        dropdown_link_to('Show', EffectiveLearndash.learndash_url, target: '_blank')
+      end
+    end
+
   end
 
   collection do

data/app/models/concerns/effective_learndash_course_registration.rb

@@ -0,0 +1,167 @@
+# frozen_stcourse_registrant_literal: true
+
+# EffectiveLearndashCourseRegistration
+#
+# Mark your owner model with effective_learndash_course_registration to get all the includes
+
+module EffectiveLearndashCourseRegistration
+  extend ActiveSupport::Concern
+
+  module Base
+    def effective_learndash_course_registration
+      include ::EffectiveLearndashCourseRegistration
+    end
+  end
+
+  module ClassMethods
+    def effective_learndash_course_registration?; true; end
+  end
+
+  included do
+    acts_as_purchasable_parent
+    acts_as_tokened
+
+    acts_as_statused(
+      :draft,      # Just Started
+      :submitted   # All done
+    )
+
+    acts_as_wizard(
+      start: 'Start',
+      course: 'Course',
+      summary: 'Review',
+      billing: 'Billing Address',
+      checkout: 'Checkout',
+      submitted: 'Submitted'
+    )
+
+    acts_as_purchasable_wizard
+
+    log_changes(except: :wizard_steps) if respond_to?(:log_changes)
+
+    # Application Namespace
+    belongs_to :owner, polymorphic: true
+    accepts_nested_attributes_for :owner
+
+    # Effective Namespace
+    belongs_to :learndash_course, class_name: 'Effective::LearndashCourse'
+
+    has_many :course_registrants, -> { order(:id) }, class_name: 'Effective::CourseRegistrant', inverse_of: :course_registration, dependent: :destroy
+    accepts_nested_attributes_for :course_registrants, reject_if: :all_blank, allow_destroy: true
+
+    has_many :orders, -> { order(:id) }, as: :parent, class_name: 'Effective::Order', dependent: :nullify
+    accepts_nested_attributes_for :orders
+
+    effective_resource do
+      # Acts as Statused
+      status                 :string, permitted: false
+      status_steps           :text, permitted: false
+
+      # Dates
+      submitted_at           :datetime
+
+      # Acts as Wizard
+      wizard_steps           :text, permitted: false
+
+      timestamps
+    end
+
+    scope :deep, -> { includes(:owner, :orders, :course_registrants) }
+    scope :sorted, -> { order(:id) }
+
+    scope :in_progress, -> { where.not(status: [:submitted]) }
+    scope :done, -> { where(status: [:submitted]) }
+
+    scope :for, -> (user) { where(owner: user) }
+
+    # All Steps validations
+    validates :owner, presence: true
+
+    # Course Step
+    validate(if: -> { current_step == :course }) do
+      self.errors.add(:course_registrants, "can't be blank") unless present_course_registrants.present?
+    end
+
+    # All Fees and Orders
+    def submit_fees
+      course_registrants
+    end
+
+    def after_submit_purchased!
+      # Enroll them in the course!
+      learndash_owner.create_learndash_enrollment(course: learndash_course)
+    end
+
+  end
+
+  # Instance Methods
+  def to_s
+    persisted? ? "#{learndash_course} - #{owner}" : 'course registration'
+  end
+
+  def course
+    learndash_course
+  end
+
+  def in_progress?
+    draft?
+  end
+
+  def done?
+    submitted?
+  end
+
+  def course_registrant
+    course_registrants.first
+  end
+
+  def build_course_registrant
+    course_registrants.build(owner: owner)
+  end
+
+  def learndash_owner
+    (course_registrant&.owner || owner)
+  end
+
+  def member_pricing?
+    learndash_owner.membership_present?
+  end
+
+  def assign_pricing
+    price = (member_pricing? ? learndash_course.member_price : learndash_course.regular_price)
+
+    course_registrant.assign_attributes(
+      price: price,
+      qb_item_name: learndash_course.qb_item_name,
+      tax_exempt: learndash_course.tax_exempt
+    )
+  end
+
+  # After the course step.
+  def course!
+    raise('expected a learndash course') unless learndash_course.present?
+    raise('expected a course_registrant to be present') unless course_registrant.present?
+    raise('expected a course_registrant to have an owner') unless course_registrant.owner.present?
+    raise('expected a learndash owner') unless learndash_owner.class.try(:effective_learndash_owner?)
+
+    # Assign prices
+    assign_pricing()
+    raise('expected course_registrant to have a price') if course_registrant.price.blank?
+
+    # Save record
+    save!
+
+    # Create a learndash user now before payment to catch any errors in server stuff before payment.
+    learndash_owner.create_learndash_user
+    raise('expected a persisted learndash user') unless learndash_owner.learndash_user&.persisted?
+
+    true
+  end
+
+  private
+
+  def present_course_registrants
+    course_registrants.reject(&:marked_for_destruction?)
+  end
+
+end

data/app/models/concerns/effective_learndash_owner.rb

@@ -57,7 +57,7 @@ module EffectiveLearndashOwner
     return true if enrollment.completed?
 
     # Check the API
-    enrollment.sync!
+    enrollment.refresh!
     enrollment.completed?
   end
 

data/app/models/effective/course_registrant.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+# This is the registrant as created by the course registration
+# It tracks who purchased which course for how much
+
+module Effective
+  class CourseRegistrant < ActiveRecord::Base
+    acts_as_purchasable
+
+    log_changes(to: :learndash_course) if respond_to?(:log_changes)
+
+    # The learndash course containing all the pricing and unique info about this course purchase
+    belongs_to :learndash_course
+
+    # Every course is charged to a owner
+    belongs_to :owner, polymorphic: true
+
+    # As checked out through the learndash course purchase wizard
+    belongs_to :course_registration, polymorphic: true
+
+    effective_resource do
+      # Acts as Purchasable
+      price             :integer
+      qb_item_name      :string
+      tax_exempt        :boolean
+
+      timestamps
+    end
+
+    scope :sorted, -> { order(:id) }
+    scope :deep, -> { includes(:learndash_course, :owner, :course_registration) }
+
+    before_validation(if: -> { course_registration.present? }) do
+      self.learndash_course ||= course_registration.learndash_course
+      self.owner ||= course_registration.owner
+    end
+
+    before_validation(if: -> { learndash_course.present? }) do
+      self.price ||= learndash_course.price
+      self.qb_item_name ||= learndash_course.qb_item_name
+      self.tax_exempt = learndash_course.tax_exempt? if self.tax_exempt.nil?
+    end
+
+    def to_s
+      persisted? ? title : 'course purchase'
+    end
+
+    def title
+      "#{learndash_course} - #{owner}"
+    end
+
+  end
+end

data/app/models/effective/course_registration.rb

@@ -0,0 +1,5 @@
+module Effective
+  class CourseRegistration < ActiveRecord::Base
+    effective_learndash_course_registration
+  end
+end

data/app/models/effective/learndash_api.rb

@@ -60,13 +60,14 @@ module Effective
 
       username = username_for(owner)
       password = password_for(owner)
+      email = email_for(owner)
 
       payload = {
         username: username,
         password: password,
+        email: email,
 
         name: owner.to_s,
-        email: owner.email,
         roles: ['subscriber'],
 
         first_name: owner.try(:first_name),
@@ -152,6 +153,14 @@ module Effective
       name
     end
 
+    def email_for(resource)
+      raise('expected a learndash owner') unless resource.class.respond_to?(:effective_learndash_owner?) # This is a user
+
+      email = resource.email
+      email = "test#{email}" unless Rails.env.production?
+      email
+    end
+
     def password_for(resource)
       raise('expected a learndash owner') unless resource.class.respond_to?(:effective_learndash_owner?) # This is a user
       EffectiveLearndash.wp_password_for(resource)

data/app/models/effective/learndash_course.rb

@@ -3,22 +3,88 @@ module Effective
     has_many :learndash_enrollments
     has_many :learndash_users, through: :learndash_enrollments
 
+    log_changes if respond_to?(:log_changes)
+
+    # rich_text_body - Used by the select step
+    has_many_rich_texts
+
+    # rich_text_body
+
+    # rich_text_all_steps_content
+    # rich_text_start_content
+    # rich_text_select_content
+    # rich_text_select_content
+
+    acts_as_slugged
+    log_changes if respond_to?(:log_changes)
+    acts_as_role_restricted if respond_to?(:acts_as_role_restricted)
+
     effective_resource do
       # This user the wordpress credentials
-      course_id                 :integer
-      status                    :string
-      title                     :string
+      course_id             :integer
+      title                 :string
+      status                :string
+
+      # Our attributes
+      slug                   :string
+
+      # For course purchases
+      can_register           :boolean
+
+      # Pricing
+      regular_price         :integer
+      member_price          :integer
+
+      qb_item_name          :string
+      tax_exempt            :boolean
+
+      # Access
+      roles_mask             :integer
+      authenticate_user      :boolean
 
       timestamps
     end
 
     scope :deep, -> { all }
     scope :sorted, -> { order(:title) }
+    scope :registerable, -> { where(can_register: true) }
+    scope :published, -> { all }
+
+    scope :paginate, -> (page: nil, per_page: nil) {
+      page = (page || 1).to_i
+      offset = [(page - 1), 0].max * (per_page || EffectiveLearndash.per_page)
+
+      limit(per_page).offset(offset)
+    }
+
+    scope :learndash_courses, -> (user: nil, unpublished: false) {
+      scope = all.deep.sorted
+
+      if defined?(EffectiveRoles) && EffectiveLearndash.use_effective_roles
+        scope = scope.for_role(user&.roles)
+      end
+
+      if user.blank?
+        scope = scope.where(authenticate_user: false)
+      end
+
+      # TODO
+      # unless unpublished
+      #   scope = scope.published
+      # end
+
+      scope
+    }
 
     validates :course_id, presence: true
     validates :status, presence: true
     validates :title, presence: true
 
+    with_options(if: -> { can_register? }) do
+      validates :regular_price, presence: true
+      validates :member_price, presence: true
+    end
+
     # Syncs all courses
     def self.refresh!
       courses = all()
@@ -35,5 +101,14 @@ module Effective
       title.presence || 'learndash course'
     end
 
+    def body
+      rich_text_body
+    end
+
+    # Todo
+    def draft?
+      false
+    end
+
   end
 end

data/app/models/effective/learndash_enrollment.rb

@@ -1,11 +1,11 @@
 module Effective
   class LearndashEnrollment < ActiveRecord::Base
     belongs_to :owner, polymorphic: true
-    log_changes(to: :owner) if respond_to?(:log_changes)
-
     belongs_to :learndash_course
     belongs_to :learndash_user
 
+    log_changes(to: :learndash_course, except: [:last_synced_at]) if respond_to?(:log_changes)
+
     PROGRESS_STATUSES = ['not-started', 'in-progress', 'completed']
 
     effective_resource do
@@ -46,11 +46,23 @@ module Effective
       persisted? ? "#{learndash_user} #{learndash_course}" : 'learndash enrollment'
     end
 
+    def not_started?
+      progress_status == 'not-started'
+    end
+
+    def in_progress?
+      progress_status == 'in-progress'
+    end
+
     def completed?
       progress_status == 'completed'
     end
 
-    def refresh!
+    def refresh!(force: false)
+      unless force
+        return if last_synced_at.present? && (Time.zone.now - last_synced_at) < 5
+      end
+
       assign_api_attributes
       save!
     end