effective_learndash 0.1.0

data/app/models/effective/learndash_course.rb

@@ -0,0 +1,39 @@
+module Effective
+  class LearndashCourse < ActiveRecord::Base
+    has_many :learndash_enrollments
+    has_many :learndash_users, through: :learndash_enrollments
+
+    effective_resource do
+      # This user the wordpress credentials
+      course_id                 :integer
+      status                    :string
+      title                     :string
+
+      timestamps
+    end
+
+    scope :deep, -> { all }
+    scope :sorted, -> { order(:title) }
+
+    validates :course_id, presence: true
+    validates :status, presence: true
+    validates :title, presence: true
+
+    # Syncs all courses
+    def self.refresh!
+      courses = all()
+
+      EffectiveLearndash.api.courses.each do |data|
+        course = courses.find { |course| course.course_id == data[:id] } || new()
+        course.update!(course_id: data[:id], title: data.dig(:title, :rendered), status: data[:status], link: data[:link])
+      end
+
+      true
+    end
+
+    def to_s
+      title.presence || 'learndash course'
+    end
+
+  end
+end

data/app/models/effective/learndash_enrollment.rb

@@ -0,0 +1,73 @@
+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
+
+    PROGRESS_STATUSES = ['not-started', 'in-progress', 'completed']
+
+    effective_resource do
+      last_synced_at      :string
+
+      # Wordpress
+      progress_status     :string
+
+      last_step           :integer
+      steps_completed     :integer
+      steps_total         :integer
+
+      date_started        :datetime
+      date_completed      :datetime
+
+      timestamps
+    end
+
+    scope :completed, -> { where(progress_status: 'completed') }
+    scope :in_progress, -> { where(progress_status: 'in-progress') }
+    scope :not_started, -> { where(progress_status: 'not-started') }
+
+    scope :deep, -> { all }
+    scope :sorted, -> { order(:id) }
+
+    before_validation do
+      self.owner ||= learndash_user&.owner
+    end
+
+    validates :learndash_user_id, uniqueness: { scope: :learndash_course_id, message: 'already enrolled in this course' }
+
+    # First time sync only for creating a new enrollment from the form
+    validate(if: -> { last_synced_at.blank? && learndash_user.present? && learndash_course.present? && errors.blank? }) do
+      assign_api_attributes
+    end
+
+    def to_s
+      persisted? ? "#{learndash_user} #{learndash_course}" : 'learndash enrollment'
+    end
+
+    def completed?
+      progress_status == 'completed'
+    end
+
+    def refresh!
+      assign_api_attributes
+      save!
+    end
+
+    def assign_api_attributes(data = nil)
+      data ||= EffectiveLearndash.api.find_enrollment(self) || EffectiveLearndash.api.create_enrollment(self)
+
+      assign_attributes(
+        last_synced_at: Time.zone.now,
+        progress_status: data[:progress_status],
+        last_step: data[:last_step],
+        steps_completed: data[:steps_completed],
+        steps_total: data[:steps_total],
+        date_started: Time.use_zone('UTC') { Time.zone.parse(data[:date_started]) },
+        date_completed: (Time.use_zone('UTC') { Time.zone.parse(data[:date_completed]) } if data[:date_completed].present?)
+      )
+    end
+
+  end
+end

data/app/models/effective/learndash_user.rb

@@ -0,0 +1,97 @@
+module Effective
+  class LearndashUser < ActiveRecord::Base
+    belongs_to :owner, polymorphic: true
+    log_changes(to: :owner) if respond_to?(:log_changes)
+
+    has_many :learndash_enrollments
+    accepts_nested_attributes_for :learndash_enrollments
+
+    has_many :learndash_courses, through: :learndash_enrollments
+
+    effective_resource do
+      last_synced_at            :string
+
+      # This user the wordpress credentials
+      user_id                   :integer
+      email                     :string
+      username                  :string
+      password                  :string
+
+      timestamps
+    end
+
+    scope :deep, -> { includes(:owner) }
+    scope :sorted, -> { order(:id) }
+
+    # I want to validate owner uniqueness, and only then create the learndash user on wordpress
+    validate(if: -> { new_record? && owner.present? }) do
+      self.errors.add(:owner, "already exists") if self.class.where(owner: owner).exists?
+    end
+
+    # First time sync only for creating a new user from the form
+    validate(if: -> { last_synced_at.blank? && owner.present? && errors.blank? }) do
+      assign_api_attributes
+    end
+
+    with_options(if: -> { last_synced_at.present? }) do
+      validates :user_id, presence: true
+      validates :email, presence: true
+      validates :username, presence: true
+      validates :password, presence: true
+    end
+
+    def to_s
+      owner&.to_s || username.presence || 'learndash user'
+    end
+
+    def refresh!
+      assign_api_course_enrollments
+      save!
+    end
+
+    # Find
+    def enrollment(course:)
+      learndash_enrollments.find { |enrollment| enrollment.learndash_course_id == course.id }
+    end
+
+    # Find or build
+    def build_enrollment(course:)
+      enrollment(course: course) || learndash_enrollments.build(learndash_course: course)
+    end
+
+    # Create
+    def create_enrollment(course:)
+      enrollment = build_enrollment(course: course)
+      enrollment.save!
+      enrollment
+    end
+
+    # Assign my model attributes from API. These should never change.
+    def assign_api_attributes(data = nil)
+      data ||= EffectiveLearndash.api.find_user(owner) || EffectiveLearndash.api.create_user(owner)
+
+      # Take special care not to overwrite password. We only get password once.
+      self.password ||= (data[:password].presence || 'unknown')
+
+      assign_attributes(email: data[:email], user_id: data[:id], username: data[:username], last_synced_at: Time.zone.now)
+    end
+
+    # This synchronizes all the course enrollments from the API down locally.
+    def assign_api_course_enrollments
+      raise('must be persisted') unless persisted?
+
+      courses = LearndashCourse.all()
+
+      EffectiveLearndash.api.user_enrollments(self).each do |data|
+        course = courses.find { |course| course.course_id == data[:course] }
+        raise("unable to find local persisted learndash course for id #{data[:course]}. Run Effective::LearndashCourse.sync!") unless course.present?
+
+        enrollment = build_enrollment(course: course)
+        enrollment.assign_api_attributes(data)
+      end
+
+      assign_attributes(last_synced_at: Time.zone.now)
+    end
+
+  end
+end

data/app/views/admin/learndash_courses/_learndash_course.html.haml

@@ -0,0 +1,12 @@
+= card('Learndash Course') do
+  %p= learndash_course.title
+  %p= link_to(learndash_course.link, learndash_course.link, target: '_blank')
+
+  %p= link_to "Learndash LMS Course Admin", EffectiveLearndash.learndash_url.chomp('/') + "/wp-admin/post.php?post=#{learndash_course.course_id}}&action=edit", target: '_blank'
+
+%h3 Learndash User Enrollments
+
+%p Click the New button from the below table to enroll a user into this course.
+
+- datatable = Admin::EffectiveLearndashEnrollmentsDatatable.new(learndash_course: learndash_course)
+= render_datatable(datatable, inline: true)

data/app/views/admin/learndash_enrollments/_form.html.haml

@@ -0,0 +1,16 @@
+= effective_form_with(model: [:admin, learndash_enrollment], engine: true) do |f|
+  = f.hidden_field :learndash_course_id
+  = f.hidden_field :learndash_user_id
+
+  - if inline_datatable?
+    - if inline_datatable.attributes[:learndash_course_id].blank?
+      - collection = Effective::LearndashCourse.all.deep.sorted.where.not(id: f.object.learndash_user&.learndash_courses)
+      = f.select :learndash_course_id, collection
+
+    - if inline_datatable.attributes[:learndash_user_id].blank?
+      = f.select :learndash_user_id, Effective::LearndashUser.all.deep.sorted
+  - else
+    = f.select :learndash_course_id,  Effective::LearndashCourse.all.deep.sorted
+    = f.select :learndash_user_id, Effective::LearndashUser.all.deep.sorted
+
+  = f.submit

data/app/views/admin/learndash_owners/_form.html.haml

@@ -0,0 +1,5 @@
+- if owner.learndash_user.blank?
+  %p #{owner} does not yet have an account on Learndash.
+
+- if owner.learndash_user.present?
+  = render('admin/learndash_users/learndash_user', learndash_user: owner.learndash_user)

data/app/views/admin/learndash_users/_form.html.haml

@@ -0,0 +1,6 @@
+= effective_form_with(model: [:admin, learndash_user], engine: true) do |f|
+
+  = f.select :owner, {'Owners' => current_user.class.sorted }, polymorphic: true,
+    hint: 'Create a Learndash user account for this website user'
+
+  = f.submit

data/app/views/admin/learndash_users/_learndash_user.html.haml

@@ -0,0 +1,21 @@
+= card('Learndash User') do
+  %p
+    = link_to(learndash_user.owner, "/admin/users/#{learndash_user.owner.to_param}/edit")
+    has an existing account on Learndash.
+
+  %ul
+    %li Email: #{learndash_user.email}
+    %li Username: #{learndash_user.username}
+    %li Password: #{learndash_user.password}
+
+  %p= link_to "Learndash LMS User Admin", EffectiveLearndash.learndash_url.chomp('/') + "/wp-admin/user-edit.php?user_id=#{learndash_user.user_id}", target: '_blank'
+
+  %p
+    %small Last refreshed #{time_ago_in_words(learndash_user.last_synced_at)} ago.
+
+%h3 Learndash Course Enrollments
+
+%p Click the New button from the below table to manually enroll this user into a new course.
+
+- datatable = Admin::EffectiveLearndashEnrollmentsDatatable.new(learndash_user: learndash_user)
+= render_datatable(datatable, inline: true)

data/config/effective_learndash.rb

@@ -0,0 +1,18 @@
+EffectiveLearndash.setup do |config|
+  # Layout Settings
+  # Configure the Layout per controller, or all at once
+  # config.layout = { application: 'application', admin: 'admin' }
+
+  # Application Password
+  # This is an application password from your Wordpress install hosting Learndash plugin.
+  # https://make.wordpress.org/core/2020/11/05/application-passwords-integration-guide/
+  #
+  config.learndash_url = ENV['LEARNDASH_URL']
+  config.learndash_username = ENV['LEARNDASH_USERNAME']
+  config.learndash_password = ENV['LEARNDASH_PASSWORD']
+
+  # Customize the method used to assign Wordpress username and passwords
+  # Usernames can only contain lowercase letters (a-z) and numbers.
+  # config.wp_username = Proc.new { |user| "user#{user.id}" }
+  # config.wp_password = Proc.new { |user| SecureRandom.base64(12) }
+end

data/config/routes.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+Rails.application.routes.draw do
+  mount EffectiveLearndash::Engine => '/', as: 'effective_learndash'
+end
+
+EffectiveLearndash::Engine.routes.draw do
+  namespace :admin do
+    get '/learndash', to: 'learndash#index', as: :learndash
+
+    resources :learndash_users, only: [:index, :show, :new, :create, :update] do
+      post :refresh, on: :member
+    end
+
+    resources :learndash_enrollments, only: [:index, :new, :create, :update] do
+      post :refresh, on: :member
+    end
+
+    resources :learndash_courses, only: [:index, :show, :update] do
+      get :refresh, on: :collection
+    end
+
+  end
+
+end

data/db/migrate/01_create_effective_learndash.rb.erb

@@ -0,0 +1,48 @@
+class CreateEffectiveLearndash < ActiveRecord::Migration[6.1]
+  create_table :learndash_users do |t|
+    t.integer :owner_id
+    t.string :owner_type
+
+    t.datetime :last_synced_at
+
+    # Wordpress
+    t.integer   :user_id
+    t.string    :email
+    t.string    :username
+    t.string    :password
+
+    t.timestamps
+  end
+
+  create_table :learndash_courses do |t|
+    # Wordpress
+    t.integer :course_id
+    t.string  :status
+    t.string  :title
+    t.string  :link
+
+    t.timestamps
+  end
+
+  create_table :learndash_enrollments do |t|
+    t.integer :owner_id
+    t.string :owner_type
+
+    t.integer :learndash_course_id
+    t.integer :learndash_user_id
+
+    t.datetime :last_synced_at
+
+    # Wordpress
+    t.string :progress_status
+
+    t.integer :last_step
+    t.integer :steps_completed
+    t.integer :steps_total
+
+    t.datetime :date_started
+    t.datetime :date_completed
+
+    t.timestamps
+  end
+end

data/db/seeds.rb

@@ -0,0 +1 @@
+puts "Running effective_learndash seeds"

data/lib/effective_learndash/engine.rb

@@ -0,0 +1,22 @@
+module EffectiveLearndash
+  class Engine < ::Rails::Engine
+    engine_name 'effective_learndash'
+
+    # Set up our default configuration options.
+    initializer 'effective_learndash.defaults', before: :load_config_initializers do |app|
+      eval File.read("#{config.root}/config/effective_learndash.rb")
+    end
+
+    initializer 'effective_learndash.assets' do |app|
+      app.config.assets.precompile += ['effective_learndash_manifest.js', 'effective_learndash/*']
+    end
+
+    # Include acts_as_addressable concern and allow any ActiveRecord object to call it
+    initializer 'effective_learndash.active_record' do |app|
+      ActiveSupport.on_load :active_record do
+        ActiveRecord::Base.extend(EffectiveLearndashOwner::Base)
+      end
+    end
+
+  end
+end

data/lib/effective_learndash/version.rb

@@ -0,0 +1,3 @@
+module EffectiveLearndash
+  VERSION = '0.1.0'.freeze
+end

data/lib/effective_learndash.rb

@@ -0,0 +1,52 @@
+require 'effective_resources'
+require 'effective_datatables'
+require 'effective_learndash/engine'
+require 'effective_learndash/version'
+
+module EffectiveLearndash
+  WP_USERNAME_PROC = Proc.new { |user| "user#{user.id}" }
+  WP_PASSWORD_PROC = Proc.new { |user| SecureRandom.base64(12) }
+
+  def self.config_keys
+    [
+      :learndash_url, :learndash_username, :learndash_password,
+      :wp_username, :wp_password,
+      :layout
+    ]
+  end
+
+  include EffectiveGem
+
+  def self.api
+    raise('please set learndash_url in config/initializers/effective_learndash.rb') unless learndash_url.present?
+    raise('please set learndash_username in config/initializers/effective_learndash.rb') unless learndash_username.present?
+    raise('please set learndash_password in config/initializers/effective_learndash.rb') unless learndash_password.present?
+
+    Effective::LearndashApi.new(
+      url: learndash_url,
+      username: learndash_username,
+      password: learndash_password
+    )
+  end
+
+  def self.wp_username
+    config[:wp_username] || WP_USERNAME_PROC
+  end
+
+  def self.wp_password
+    config[:wp_password] || WP_PASSWORD_PROC
+  end
+
+  # The user.learndash_username is the source of truth
+  # This is the backup to generate a new username
+  def self.wp_username_for(owner)
+    raise('expecting a learndash owner') unless owner.class.respond_to?(:effective_learndash_owner?)
+    owner.instance_exec(owner, &wp_username)
+  end
+
+  def self.wp_password_for(owner)
+    raise('expecting a learndash owner') unless owner.class.respond_to?(:effective_learndash_owner?)
+    owner.instance_exec(owner, &wp_password)
+  end
+
+end

data/lib/generators/effective_learndash/install_generator.rb

@@ -0,0 +1,29 @@
+module EffectiveLearndash
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+      include Rails::Generators::Migration
+
+      desc 'Creates an EffectiveLearndash initializer in your application.'
+
+      source_root File.expand_path('../../templates', __FILE__)
+
+      def self.next_migration_number(dirname)
+        if not ActiveRecord::Base.timestamped_migrations
+          Time.new.utc.strftime("%Y%m%d%H%M%S")
+        else
+          '%.3d' % (current_migration_number(dirname) + 1)
+        end
+      end
+
+      def copy_initializer
+        template ('../' * 3) + 'config/effective_learndash.rb', 'config/initializers/effective_learndash.rb'
+      end
+
+      def create_migration_file
+        @learndash_courses_table_name  = ':' + EffectiveLearndash.learndash_courses_table_name.to_s
+        migration_template ('../' * 3) + 'db/migrate/01_create_effective_learndash.rb.erb', 'db/migrate/create_effective_learndash.rb'
+      end
+
+    end
+  end
+end

data/lib/generators/templates/effective_learndash_mailer_preview.rb

@@ -0,0 +1,4 @@
+# Visit http://localhost:3000/rails/mailers
+
+class EffectiveLearndashMailerPreview < ActionMailer::Preview
+end

data/lib/tasks/effective_learndash_tasks.rake

@@ -0,0 +1,8 @@
+namespace :effective_learndash do
+
+  # bundle exec rake effective_learndash:seed
+  task seed: :environment do
+    load "#{__dir__}/../../db/seeds.rb"
+  end
+
+end