effective_learndash 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: '0970ec691c0993f6c77e5131eba3da9ed11ef1c74a5cd00f0cdba5373cf1f5b4'
+  data.tar.gz: dd0229161ba6030e9711202259063af16e506ec6d029647d43a112b4ac4f8150
+SHA512:
+  metadata.gz: a6ff74e9f0842c69d6f69886a8a7ef86b1196bbfd83e803afdd58e075c8ac99371a4b125d22b67e136268b4b5d4ac6718371b3ff6db936abddcb123ac3d8b28a
+  data.tar.gz: e742085fcf413769c5936203091663b95d704a98d4b26b3778d77668f62d7ec79a53c52ffade1e9cf0d4cf56941ab83797d67a3efac1905ae30755f416958ff2

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2022 Code and Effect Inc.
+
+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,126 @@
+# Effective Learndash
+
+Create Wordpress users and read Learndash course progress. This is an unoffocial integration that is not supported or affiliated with WordPress or Learndash.
+
+## Getting Started
+
+This requires Rails 6+ and Twitter Bootstrap 4 and just works with Devise.
+
+Please first install the [effective_datatables](https://github.com/code-and-effect/effective_datatables) gem.
+
+Please download and install the [Twitter Bootstrap4](http://getbootstrap.com)
+
+Add to your Gemfile:
+
+```ruby
+gem 'haml-rails' # or try using gem 'hamlit-rails'
+gem 'effective_learndash'
+```
+
+Run the bundle command to install it:
+
+```console
+bundle install
+```
+
+Then run the generator:
+
+```ruby
+rails generate effective_learndash:install
+```
+
+The generator will install an initializer which describes all configuration options and creates a database migration.
+
+If you want to tweak the table names, manually adjust both the configuration file and the migration now.
+
+Then migrate the database:
+
+```ruby
+rake db:migrate
+```
+
+Add to your user class:
+
+```
+class User < ApplicationRecord
+  effective_learndash_owner
+end
+```
+
+Add a link to the admin menu:
+
+```haml
+- if can? :admin, :effective_learndash
+  = nav_dropdown 'Learndash' do
+    - if can? :index, Effective::LearndashUser
+      = nav_link_to 'Learndash Users', effective_learndash.admin_learndash_users_path
+
+    - if can? :index, Effective::LearndashCourse
+      = nav_link_to 'Learndash Courses', effective_learndash.admin_learndash_courses_path
+
+    - if can? :index, Effective::LearndashEnrollment
+      = nav_link_to 'Learndash Enrollments', effective_learndash.admin_learndash_enrollments_path
+```
+
+## Authorization
+
+All authorization checks are handled via the effective_resources gem found in the `config/initializers/effective_resources.rb` file.
+
+## Permissions
+
+The permissions you actually want to define are as follows (using CanCan):
+
+```ruby
+if user.admin?
+  can :admin, :effective_learndash
+
+  can(crud + [:refresh], Effective::LearndashUser)
+  can(crud + [:refresh], Effective::LearndashCourse)
+
+  can(crud, Effective::LearndashEnrollment)
+  can(:refresh, Effective::LearndashEnrollment) { |enrollment| !enrollment.completed? }
+end
+```
+
+## Configuring Learndash
+
+Your Wordpress should be configured ahead of time with the Learndash plugin.
+
+Please generate an application password via:
+
+https://make.wordpress.org/core/2020/11/05/application-passwords-integration-guide/
+
+and fill in the username/password details in config/initializers/effective_leardash.rb
+
+## Working with Learndash
+
+Visit `/admin/learndash_courses` and Refresh the list of Courses.
+
+Create a New Learndash User will create a new Wordpress/Learndash account with a username/password according to the settings in the config file.
+
+When you create a user, you only get access to the password once. So any existing users will have an unknown password.
+
+Create a new Learndash Enrollment to enroll a learndash user into a course. This will begin tracking their progress.
+
+There are no webhooks or callbacks from Learndash, everything is a GET request that updates the local database.
+
+You can refresh an entire learndash user in one operation and it will sync the entire user at once, `user.learndash_user.refresh!`
+
+## License
+
+MIT License. Copyright [Code and Effect Inc.](http://www.codeandeffect.com/)
+
+## Testing
+
+```ruby
+rails test
+```
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Bonus points for test coverage
+6. Create new Pull Request

data/Rakefile

@@ -0,0 +1,18 @@
+require "bundler/setup"
+
+APP_RAKEFILE = File.expand_path("test/dummy/Rakefile", __dir__)
+load "rails/tasks/engine.rake"
+
+load "rails/tasks/statistics.rake"
+
+require "bundler/gem_tasks"
+
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+task default: :test

data/app/assets/config/effective_learndash_manifest.js

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

data/app/assets/javascripts/effective_learndash.js

@@ -0,0 +1 @@
+//= require_tree ./effective_learndash

data/app/assets/stylesheets/effective_learndash.scss

@@ -0,0 +1 @@
+@import 'effective_learndash/base';

data/app/controllers/admin/learndash_courses_controller.rb

@@ -0,0 +1,15 @@
+module Admin
+  class LearndashCoursesController < ApplicationController
+    before_action(:authenticate_user!) if defined?(Devise)
+    before_action { EffectiveResources.authorize!(self, :admin, :effective_learndash) }
+
+    include Effective::CrudController
+
+    def refresh
+      resource_scope.refresh!
+      flash[:success] = "Successfully refreshed Courses from Learndash"
+      redirect_to effective_learndash.admin_learndash_courses_path
+    end
+
+  end
+end

data/app/controllers/admin/learndash_enrollments_controller.rb

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

data/app/controllers/admin/learndash_users_controller.rb

@@ -0,0 +1,11 @@
+module Admin
+  class LearndashUsersController < ApplicationController
+    before_action(:authenticate_user!) if defined?(Devise)
+    before_action { EffectiveResources.authorize!(self, :admin, :effective_learndash) }
+
+    include Effective::CrudController
+
+    on :refresh, success: -> { "Successfully refreshed #{resource} and all course enrollments" }
+
+  end
+end

data/app/datatables/admin/effective_learndash_courses_datatable.rb

@@ -0,0 +1,26 @@
+module Admin
+  class EffectiveLearndashCoursesDatatable < Effective::Datatable
+    datatable do
+      order :title
+
+      col :id, visible: false
+      col :course_id, label: 'Learndash Id', visible: false
+
+      col :title
+      col :status
+
+      col :link do |course|
+        link_to(course.link, course.link, target: '_blank')
+      end
+
+      col :learndash_users, visible: false
+
+      actions_col
+    end
+
+    collection do
+      Effective::LearndashCourse.deep.all
+    end
+
+  end
+end

data/app/datatables/admin/effective_learndash_enrollments_datatable.rb

@@ -0,0 +1,39 @@
+module Admin
+  class EffectiveLearndashEnrollmentsDatatable < Effective::Datatable
+    filters do
+      scope :all
+      scope :completed
+      scope :in_progress
+      scope :not_started
+    end
+
+    datatable do
+      col :id, visible: false
+
+      col :last_refreshed, visible: false do |enrollment|
+        time_ago_in_words(enrollment.last_synced_at) + ' ago'
+      end
+
+      col :owner, visible: false
+
+      col :learndash_course
+      col :learndash_user
+
+      col :progress_status
+
+      col :last_step, visible: false
+      col :steps_completed, visible: false
+      col :steps_total, visible: false
+
+      col :date_started, as: :date
+      col :date_completed, as: :date
+
+      actions_col
+    end
+
+    collection do
+      Effective::LearndashEnrollment.deep.all
+    end
+
+  end
+end

data/app/datatables/admin/effective_learndash_users_datatable.rb

@@ -0,0 +1,25 @@
+module Admin
+  class EffectiveLearndashUsersDatatable < Effective::Datatable
+    datatable do
+      col :id, visible: false
+      col :user_id, label: 'Learndash Id', visible: false
+
+      col :last_refreshed, visible: true do |user|
+        time_ago_in_words(user.last_synced_at) + ' ago'
+      end
+
+      col :owner
+      col :email
+      col :username
+      col :password
+      col :learndash_courses
+
+      actions_col
+    end
+
+    collection do
+      Effective::LearndashUser.deep.all
+    end
+
+  end
+end

data/app/helpers/effective_learndash_helper.rb

@@ -0,0 +1,2 @@
+module EffectiveLearndashHelper
+end

data/app/models/concerns/effective_learndash_owner.rb

@@ -0,0 +1,64 @@
+# EffectiveLearndashOwner
+#
+# Mark your user model with effective_learndash_owner to get all the includes
+
+module EffectiveLearndashOwner
+  extend ActiveSupport::Concern
+
+  module Base
+    def effective_learndash_owner
+      include ::EffectiveLearndashOwner
+    end
+  end
+
+  module ClassMethods
+    def effective_learndash_owner?; true; end
+  end
+
+  included do
+    # Effective Scoped - this is a has_one in preactice
+    has_many :learndash_users, class_name: 'Effective::LearndashUser', as: :owner, inverse_of: :owner, dependent: :delete_all
+    accepts_nested_attributes_for :learndash_users, allow_destroy: true
+
+    # Not used
+    has_many :learndash_enrollments, class_name: 'Effective::LearndashEnrollment', as: :owner, inverse_of: :owner, dependent: :delete_all
+    accepts_nested_attributes_for :learndash_enrollments, allow_destroy: true
+  end
+
+  # Find
+  def learndash_user
+    learndash_users.first
+  end
+
+  # Find or create
+  def create_learndash_user
+    learndash_user || learndash_users.create!(owner: self)
+  end
+
+  # Find
+  def learndash_enrollment(course:)
+    learndash_user&.enrollment(course: course)
+  end
+
+  # Find or create
+  def create_learndash_enrollment(course:)
+    raise('expected a persisted learndash_user') unless learndash_user&.persisted?
+    learndash_user.create_enrollment(course: course)
+  end
+
+  # Find or sync and check completed?
+  def learndash_completed?(course:)
+    enrollment = learndash_enrollment(course: course)
+
+    # We haven't been enrolled
+    return false if enrollment.blank?
+
+    # Return completed right away if previously marked completed
+    return true if enrollment.completed?
+
+    # Check the API
+    enrollment.sync!
+    enrollment.completed?
+  end
+
+end

data/app/models/effective/learndash_api.rb

@@ -0,0 +1,269 @@
+require 'net/http'
+
+module Effective
+  class LearndashApi
+
+    attr_accessor :url
+    attr_accessor :username
+    attr_accessor :password
+
+    def initialize(url:, username:, password:)
+      @url = url
+      @username = username
+      @password = password
+    end
+
+    # Methods
+    # https://developer.wordpress.org/rest-api/reference/users/#definition
+    # curl --user username:password http://www.example.com/wp-json/wp/v2/users/me
+    def me
+      get('/wp/v2/users/me')
+    end
+
+    # List users
+    def users
+      get('/wp/v2/users')
+    end
+
+    # Returns a WP Hash of User or nil
+    # This find by EMAIL doesn't work reliably
+    def find_user(value)
+      # Find by email
+      if value.kind_of?(String) && value.include?('@')
+        return find_by("/wp/v2/users", :email, value)
+      end
+
+      # Fetch by saved param value
+      user_id = user_id(value)
+      user = find("/wp/v2/users/#{user_id}", context: :edit) if user_id
+      return user if user.present?
+
+      # Find by email
+      email = value.try(:email)
+      user = find_by("/wp/v2/users", :email, email) if email
+      return user if user.present?
+
+      # Find by username
+      username = username_for(value) if value.class.respond_to?(:effective_learndash_owner?)
+      user = find_by("/wp/v2/users", :username, username) if username
+      return user if user.present?
+
+      # Otherwise none
+      nil
+    end
+
+    # Create User
+    # Usernames can only contain lowercase letters (a-z) and numbers.
+    def create_user(owner)
+      raise ('expected a leardash owner') unless owner.class.respond_to?(:effective_learndash_owner?)
+      raise('owner must have an email') unless owner.try(:email).present?
+
+      username = username_for(owner)
+      password = password_for(owner)
+
+      payload = {
+        username: username,
+        password: password,
+
+        name: owner.to_s,
+        email: owner.email,
+        roles: ['subscriber'],
+
+        first_name: owner.try(:first_name),
+        last_name: owner.try(:last_name)
+      }.compact
+
+      post("/wp/v2/users", payload.stringify_keys).merge(password: password)
+    end
+
+    # List Courses
+    def courses
+      get('/ldlms/v2/sfwd-courses')
+    end
+
+    # List User Course Progress
+    def user_enrollments(user)
+      user = user_id(user) || raise('expected a user')
+
+      get("/ldlms/v2/users/#{user}/course-progress")
+    end
+
+    # Helper methods for enrollments
+    def find_enrollment(enrollment)
+      find_user_course(enrollment.learndash_user, enrollment.learndash_course)
+    end
+
+    def create_enrollment(enrollment)
+      create_user_course(enrollment.learndash_user, enrollment.learndash_course)
+    end
+
+    # Find User Course Progress
+    def find_user_course(user, course)
+      user = user_id(user) || raise('expected a user')
+      course = course_id(course) || raise('expected a course')
+
+      find("/ldlms/v2/users/#{user}/course-progress/#{course}")
+    end
+
+    # Crete Course User
+    def create_user_course(user, course)
+      user = user_id(user) || raise('expected a user')
+      course = course_id(course) || raise('expected a course')
+
+      response = post("/ldlms/v2/sfwd-courses/#{course}/users", user_ids: [user])
+
+      unless (response.first.fetch(:code) rescue nil) == 'learndash_rest_enroll_success'
+        raise("unsuccessful course creation: #{response}")
+      end
+
+      find_user_course(user, course)
+    end
+
+    # private under this point
+
+
+    def user_id(resource)
+      if resource.class.respond_to?(:effective_learndash_owner?) # This is a user
+        resource.learndash_user&.user_id
+      elsif resource.kind_of?(LearndashEnrollment)
+        resource.learndash_user&.user_id
+      elsif resource.kind_of?(LearndashUser)
+        resource.user_id
+      else
+        resource
+      end
+    end
+
+    def course_id(resource)
+      if resource.kind_of?(LearndashCourse)
+        resource.course_id
+      elsif resource.kind_of?(LearndashEnrollment)
+        resource.learndash_course&.course_id
+      else
+        resource
+      end
+    end
+
+    def username_for(resource)
+      raise('expected a learndash owner') unless resource.class.respond_to?(:effective_learndash_owner?) # This is a user
+
+      name = EffectiveLearndash.wp_username_for(resource)
+      name = "test#{name}" unless Rails.env.production?
+      name
+    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)
+    end
+
+    def find(endpoint, params = nil)
+      response = get(endpoint, params)
+
+      if response == false
+        nil
+      elsif response.kind_of?(Hash) && response.dig(:data, :status) == 404
+        nil
+      elsif response.kind_of?(Hash)
+        response
+      elsif response.kind_of?(Array)
+        response.first
+      else
+        raise("unexpected Learndash API response #{response}")
+      end
+    end
+
+    # We can't just like, find by email, so we gotta search then filter on our side
+    def find_by(endpoint, key, value)
+      raise('expected a symbol key') unless key.kind_of?(Symbol)
+      raise('expected a value') unless value.present?
+
+      response = get(endpoint, { search: value, context: :edit })
+
+      collection = Array(
+        if response == false
+          nil
+        elsif response.kind_of?(Hash) && response.dig(:data, :status) == 404
+          nil
+        elsif response.kind_of?(Hash)
+          response
+        elsif response.kind_of?(Array)
+          response
+        else
+          raise("unexpected Learndash API find_by response #{response}")
+        end
+      )
+
+      resource = collection.find { |data| data[key] == value }
+      resource
+    end
+
+    def get(endpoint, params = nil)
+      query = ('?' + params.compact.map { |k, v| "#{k}=#{v}" }.join('&')) if params.present?
+
+      uri = URI.parse(api_url + endpoint + query.to_s)
+
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = (uri.scheme == 'https')
+      http.read_timeout = 10
+
+      response = with_retries do
+        puts("[GET] #{uri}") if Rails.env.development?
+        http.get(uri, headers)
+      end
+
+      unless response.code.start_with?('2')
+        puts("Response code: #{response.code} #{response.body}") if Rails.env.development?
+        return false
+      end
+
+      JSON.parse(response.body, symbolize_names: true)
+    end
+
+    def post(endpoint, params = nil)
+      uri = URI.parse(api_url + endpoint)
+
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = (uri.scheme == 'https')
+      http.read_timeout = 10
+
+      response = with_retries do
+        puts("[POST] #{uri} #{params}") if Rails.env.development?
+        http.post(uri.path, (params || {}).to_json, headers)
+      end
+
+      unless response.code.start_with?('2')
+        raise("Invalid Learndash API request: #{response.body}")
+      end
+
+      JSON.parse(response.body, symbolize_names: true)
+    end
+
+    def api_url
+      url.chomp('/') + '/wp-json'
+    end
+
+    def headers
+      {
+        'Authorization': "Basic #{Base64.strict_encode64("#{username}:#{password}")}",
+        'Accept': 'application/json',
+        'Content-Type': 'application/json'
+      }
+    end
+
+    def with_retries(retries: 3, wait: 2, &block)
+      raise('expected a block') unless block_given?
+
+      begin
+        return yield
+      rescue Exception => e
+        if (retries -= 1) > 0
+          sleep(wait); retry
+        else
+          raise
+        end
+      end
+    end
+
+  end
+end