datashift_journey 0.1.2

data/app/controllers/datashift_journey/application_controller.rb

@@ -0,0 +1,53 @@
+module DatashiftJourney
+
+  class ApplicationController < ActionController::Base
+
+    protect_from_forgery with: :exception
+
+    include TokenBasedAccess
+
+    layout ->(_) { Configuration.call.layout }
+
+    # This form does NOT seem to work - helpers cause missing method in views
+    # helper DatashiftJourney::Engine.helpers
+    # helper "datashift_journey/user"
+
+    # This form seems to work - helpers now available in views
+    # include DatashiftJourney::ApplicationHelper
+    # include DatashiftJourney::BackLinkHelper
+
+    before_action :set_i18n_locale_from_params
+
+    rescue_from ActionController::InvalidAuthenticityToken, with: :handle_invalid_authenticity_token
+
+    private
+
+    def set_i18n_locale_from_params
+      return unless params[:locale]
+
+      available = I18n.available_locales.map(&:to_s)
+
+      if available.include?(params[:locale])
+        I18n.locale = params[:locale]
+        logger.debug "locale set to: #{params[:locale]}"
+      else
+        flash.now[:notice] = "#{params[:locale]} translation not available"
+        logger.error flash.now[:notice]
+      end
+    end
+
+    # http://jacopretorius.net/2014/01/force-page-to-reload-on-browser-back-in-rails.html
+    def back_button_cache_buster
+      response.headers['Cache-Control'] = 'no-cache, no-store, max-age=0, must-revalidate'
+      response.headers['Pragma'] = 'no-cache'
+      response.headers['Expires'] = 'Fri, 01 Jan 1990 00:00:00 GMT'
+    end
+
+    def handle_invalid_authenticity_token(exception)
+      Rails.logger.error 'DatashiftJourney::ApplicationController authenticity failed ' \
+                         "(browser cookies may have been disabled): #{exception}"
+
+      render 'datashift_journey/errors/invalid_authenticity_token'
+    end
+  end
+end

data/app/controllers/datashift_journey/errors_controller.rb

@@ -0,0 +1,24 @@
+module DatashiftJourney
+  class ErrorsController < ApplicationController
+    def show
+      @exception = env['action_dispatch.exception']
+      action = request.path[1..-1].gsub(/[^0-9]/, '')
+      action = 500 if action.blank?
+
+      status_code =
+        if @exception
+          trace = Rails.backtrace_cleaner.clean(@exception.backtrace)
+          Rails.logger.fatal trace.join("#\n")
+
+          ActionDispatch::ExceptionWrapper.new(env, @exception).status_code
+        else
+          action.to_i
+        end
+
+      respond_to do |format|
+        format.html { render action: action, status: status_code }
+        format.json { render json: { status: status_code, error: @exception.message } }
+      end
+    end
+  end
+end

data/app/controllers/datashift_journey/journey_ends_controller.rb

@@ -0,0 +1,19 @@
+require_dependency 'datashift_journey/application_controller'
+
+module DatashiftJourney
+
+  class JourneyEndsController < ApplicationController
+
+    def show
+      journey_plan_class = params[:journey_plan_class] ? params[:journey_plan_class].constantize : DatashiftJourney.journey_plan_class
+
+      token = params[:id] || params[:journey_plan_id]
+
+      @journey_plan = token ? journey_plan_class.find(token) : journey_plan_class.new
+
+      @journey_plan.on_journey_end if @journey_plan.respond_to? :on_journey_end
+
+    end
+
+  end
+end

data/app/controllers/datashift_journey/journey_plans_controller.rb

@@ -0,0 +1,166 @@
+require_dependency 'datashift_journey/application_controller'
+
+module DatashiftJourney
+
+  class JourneyPlansController < ApplicationController
+
+    include ValidateState
+
+    # Run BEFORE other filters to ensure the current journey_plan has been selected from the DB
+    prepend_before_action :set_journey_plan, only: [:new, :destroy, :back_a_state]
+
+    prepend_before_action :set_reform_object, only: [:create, :edit, :update]
+
+    # Validate state and state related params - covers certain edge cases such as browser refresh
+    before_action :validate_state, only: [:edit, :update]
+
+    def new
+      # Find and create the form object, backing the current states view
+      reform = FormObjectFactory.form_object_for(journey_plan)
+
+      render locals: { journey_plan: journey_plan, form: reform }
+    end
+
+    def create
+      # TOFIX - Validation from params is now broken
+      # NoMethodError (undefined method `each_with_index' for #<ActionController::Parameters:0x000055eacfa2c370>):
+      # result = form.validate(params)
+      # logger.debug("VALIDATION FAILED - Form Errors [#{form.errors.inspect}]") unless result
+      journey_plan = journey_plan_class.new
+
+      form_fields_to_data_nodes
+
+      move_next(journey_plan)
+    end
+
+    def back_a_state
+      respond_to do |format|
+        logger.debug("BACK Requested - current [#{journey_plan.state}] - previous [#{journey_plan.previous_state_name}]")
+
+        journey_plan.back!
+
+        if journey_plan.save
+
+          logger.debug("Successfully back a step - state now [#{journey_plan.state}]")
+
+          format.html do
+            redirect_to(datashift_journey.journey_plan_state_path(journey_plan.state, journey_plan)) && return
+          end
+
+        else
+          format.html { render :edit }
+        end
+      end
+    end
+
+    def edit
+      logger.debug "Editing journey_plan [#{journey_plan.inspect}]"
+      render locals: { journey_plan: @journey_plan, form: @reform }
+    end
+
+    def update
+
+      # result = form.validate(params)
+      #
+      # redirect_to(form.redirection_url) && return if form.redirect?
+      #
+      # if result && form.save
+      #   logger.debug("SUCCESS - Updated #{journey_plan.inspect}")
+      #
+      #   move_next(journey_plan)
+      # else
+      #   logger.debug("FAILED - Form Errors [#{form.errors.inspect}]")
+      #
+      #   render :edit, locals: { journey_plan: journey_plan, form: form }
+      # end
+
+      form_fields_to_data_nodes
+
+      logger.debug("UPDATED Plan [#{journey_plan.inspect}] - Move to Next")
+      puts journey_plan.inspect
+
+      move_next(journey_plan) && return
+    end # UPDATE
+
+    def form_fields_to_data_nodes
+      form_params = params.fetch(@reform.params_key, {})
+
+      data_nodes = form_params["data_nodes"] # =>{"form_field"=>{"0"=>"name", "1"=>"namespace"}, "field_value"=>{"0"=>"dfsdf", "1"=>"ghfghf"}}}
+
+      if data_nodes.present?
+
+        fields = data_nodes["form_field"]
+        values = data_nodes["field_value"]
+
+        fields.each do |idx, name|
+          ff = Collector::FormField.where(name: name, form_definition: @reform.definition).first
+          next unless ff
+
+          # Ensure when user goes back and changes a value we reflect the changed value
+          Collector::DataNode.find_or_initialize_by(plan: journey_plan, form_field: ff).tap do |node|
+            node.field_value = values[idx]
+            node.save
+          end
+
+        end
+      end
+    end
+
+    private
+
+    def move_next(journey_plan)
+      journey_plan.reload
+
+      redirect_to(@reform.redirection_url) && return if @reform.redirect?
+
+      if journey_plan.next_state_name.blank?
+        logger.error("JOURNEY ENDED - no next transition - rendering 'journey_end'")
+        redirect_to(datashift_journey.journey_end_path(journey_plan)) && return
+      end
+
+      # if there is no next event, state_machine dynamic helper can_next? not available
+      unless journey_plan.respond_to?('can_skip_fwd?') && journey_plan.can_skip_fwd?
+        logger.error("JOURNEY Cannot proceed - no next transition - rendering 'journey_end'")
+        redirect_to(datashift_journey.journey_end_path(journey_plan)) && return
+      end
+
+      journey_plan.skip_fwd!
+
+      logger.info("JOURNEY moved to next state - Current Plan :")
+      logger.info(journey_plan)
+
+      redirect_to(datashift_journey.journey_plan_state_path(journey_plan.state, journey_plan)) && return
+    end
+
+    def set_journey_plan_class
+      @journey_plan_class = params[:journey_plan_class] ? params[:journey_plan_class].constantize : DatashiftJourney.journey_plan_class
+    end
+
+    def set_journey_plan
+      set_journey_plan_class
+
+      token = params[:id] || params[:journey_plan_id]
+
+      # TOFIX: Rails 6 probably has this inbuilt now and makes this much simpler - see ActiveSupport::MessageEncryptor, KeyGenerator
+      #
+      # https://github.com/robertomiranda/has_secure_token
+      # TODO: how to auto insert has_secure_token into the underlying journey plan model
+      # and add in migration thats adds the token column
+      # @journey_plan = DatashiftJourney.journey_plan_class.find_by_token!(token)
+      @journey_plan = token ? journey_plan_class.find(token) : journey_plan_class.new
+    end
+
+    def set_reform_object
+      set_journey_plan_class
+
+      token = params[:id] || params[:journey_plan_id]
+
+      journey_plan = token ? journey_plan_class.find(token) : journey_plan_class.new
+      @reform = FormObjectFactory.form_object_for(journey_plan)
+
+      @journey_plan = @reform.journey_plan
+    end
+
+    attr_reader :journey_plan_class, :journey_plan
+  end
+end

data/app/controllers/datashift_journey/page_states_controller.rb

@@ -0,0 +1,49 @@
+module DatashiftJourney
+  class FormsController < ActionController::API
+
+    include DatashiftJourney::ErrorRenderer
+
+    before_action :set_user, only: [:show, :update, :destroy]
+
+    # PageState contains details for rendering and storing a Page related to a single State
+    #
+    def index
+      @collector_forms = Collector::FormDefinition.all
+
+      render json: @collector_forms, status: :ok
+    end
+
+    def create
+      @collector_form = Collector::FormDefinition.new(page_state_params)
+
+      if @collector_form.save
+        render json: @collector_form, status: :created
+      else
+        render_error(@collector_form, :unprocessable_entity) and return
+        #render json: { errors: @collector_form.errors }, status: :unprocessable_entity
+      end
+    end
+
+    def show
+      render json: @collector_form
+    end
+
+    private
+
+    # Only allow a trusted parameter "white list" through.
+    def page_state_params
+      params.fetch(:page_state, {}).permit(:form_name)
+    end
+
+    def set_user
+      begin
+        @collector_form = Collector::FormDefinition.find params[:id]
+      rescue ActiveRecord::RecordNotFound
+        collector_form = Collector::FormDefinition.new
+        collector_form.errors.add(:id, "Wrong ID provided")
+        render_error(collector_form, 404) and return
+      end
+    end
+
+  end
+end

data/app/controllers/datashift_journey/reviews_controller.rb

@@ -0,0 +1,32 @@
+module DatashiftJourney
+
+  class ReviewsController < ApplicationController
+
+    include DatashiftJourney::ReviewRenderer
+
+    # We want this to run BEFORE other filters to ensure the current
+    # journey_plan object has been selected from the DB
+
+    prepend_before_filter :set_journey_plan, only: [:edit]
+
+    def edit
+      logger.info("Sent from REVIEW [#{params.inspect}]")
+
+      respond_to do |format|
+        format.html do
+          setup_view_data_for_state(params['state'])
+
+          render_state_under_review(params)
+        end
+      end
+    end
+
+    private
+
+    # Never trust parameters, only allow the white list through.
+    def review_params
+      params.permit(:id, :state)
+    end
+
+  end
+end

data/app/controllers/datashift_journey/state_jumper_controller.rb

@@ -0,0 +1,51 @@
+# This is a development tool - for creating and jumping straight to any State
+#
+# So that any data required for previous states can be created, it supports passing in a optional Factory
+# that creates that data for you.
+#
+# The factory should return an instance of your DatashiftJourney.journey_plan_class
+#
+# For a full list of available factories you can call :
+#
+#   FactoryGirl.definition_file_paths.inspect
+#
+#   FactoryGirl.factories.collect(&:name).inspect
+#
+module DatashiftJourney
+  class StateJumperController < ApplicationController
+
+    unless Rails.env.production?
+
+      require 'factory_girl'
+      require 'faker'
+
+      def build_and_display
+        state =   params['state']
+        factory = params['factory']
+
+        plan = if factory
+                 # Get weird problems with factories with has_many associations, when they've already been used,
+                 # so while obviously not very efficient, this seems to prevent that issue
+                 FactoryGirl.reload
+
+                 Rails.logger.debug("Building StateJumper #{DatashiftJourney.journey_plan_class} from [#{factory}]")
+
+                 FactoryGirl.create(factory)
+               else
+                 DatashiftJourney.journey_plan_class.create(state: state)
+               end
+
+        if plan.state != state
+          plan.skip_fwd(state.to_sym) until !plan.can_skip_fwd? || plan.state == state
+        end
+
+        plan.update_attribute(:state, state) if plan.state != state
+
+        Rails.logger.debug("Jumping to STATE [#{plan.state}]")
+
+        redirect_to(datashift_journey.journey_plan_state_path(state, plan)) && return
+      end
+
+    end
+  end
+end

data/app/factories/datashift_journey/form_object_factory.rb

@@ -0,0 +1,68 @@
+require 'reform/form'
+
+module DatashiftJourney
+  class FormObjectFactory
+
+    class << self
+
+      # Create a form object from the current states Form class
+      #
+      # Each form can provide a factory to drive how its constructed, or can rely on the base classes factory method
+      #
+      def form_object_for(journey_plan)
+        # Get ReForm form for current state
+        klass = form_class_for(journey_plan)
+        raise(FormObjectError, "Failed to load form class #{form_name(journey_plan.state)} for state #{journey_plan.state}") unless klass
+
+        # Create new instance of form for current journey instance
+        klass.new(journey_plan)
+      end
+
+      def form_name(state)
+        @form_name_mod ||= Configuration.call.forms_module_name
+
+        "#{@form_name_mod}::#{state.to_s.camelize}Form"
+      end
+
+      def state_name(form)
+        return form.chomp('Form').underscore if form.is_a?(String)
+        form.class.name.chomp('Form').underscore
+      end
+
+      private
+
+      def null_form_for_state(journey_plan)
+        return DatashiftJourney::NullForm if Configuration.call.use_null_form_when_no_form
+
+        return DatashiftJourney:: NullForm if null_form_requirested?(journey_plan.state)
+
+        nil
+      end
+
+      def null_form_requirested?(state)
+        null_form_list.include?(state.to_s)
+      end
+
+      def null_form_list
+        @null_form_list ||= Configuration.call.null_form_list.map!(&:to_s)
+      end
+
+      # Find the current state and its associated Form
+      def form_class_for(journey_plan)
+        form_name(journey_plan.state).constantize
+      rescue => x
+        null_form = null_form_for_state(journey_plan)
+
+        unless null_form
+          Rails.logger.debug(x.backtrace.first)
+          Rails.logger.debug(x.inspect)
+          Rails.logger.debug("No Form class found for state #{journey_plan.state} - #{x.message}")
+          return nil
+        end
+
+        null_form
+      end
+    end
+
+  end
+end

data/app/forms/datashift_journey/collector/base_collector_form.rb

@@ -0,0 +1,60 @@
+require_relative '../concerns/form_mixin'
+
+module DatashiftJourney
+  module Collector
+
+    # This class represents the View backing Form
+    #
+    # Reform API :
+    #
+    #   initialize always requires a model that the form represents.
+    #   validate(params) updates the form's fields with the input data (only the form, not the model) and then runs all validations. The return value is the boolean result of the validations.
+    #   errors returns validation messages in a classic ActiveModel style.
+    #   sync writes form data back to the model. This will only use setter methods on the model(s).
+    #   save (optional) will call #save on the model and nested models. Note that this implies a #sync call.
+    #   prepopulate! (optional) will run pre-population hooks to "fill out" your form before rendering.
+    #
+    class BaseCollectorForm < Reform::Form
+
+      include DatashiftJourney::FormMixin
+
+      feature Reform::Form::Dry # override the default.
+
+      attr_accessor :definition
+
+      # Called from CONTROLLER
+      #
+      # Creates a form object backed by the current Plan object
+      #
+      # Data is collected generically from fields defined by FormDefinition and stored
+      # in data nodes associated with current JourneyPlan instance (through polymorphic plan association)
+      #
+      def initialize(journey_plan)
+        super(journey_plan)
+
+        @journey_plan = journey_plan
+
+        @definition = DatashiftJourney::Collector::FormDefinition.where(klass: self.class.name).first
+
+        # For brand new forms, add one data node per form field - data nodes hold the COLLECTED VALUES
+        # If this page already been visited we should have a completed data node already
+        form_definition.form_fields.map(&:id).each do |id|
+          next if journey_plan.data_nodes.where('form_field_id = ?', id).exists?
+          journey_plan.data_nodes << DatashiftJourney::Collector::DataNode.new(plan: journey_plan, form_field_id: id)
+        end
+
+      end
+
+      # Over ride in your form if your view forms have non standard key field.
+      #
+      # The default naming format for form elements in the view is : "#{params_key}[data_nodes][field_value][#{i}]"
+      #
+      # For example:
+      #                 <%= select_tag "#{params_key}[data_nodes][field_value][#{i}]"....  %>
+      def params_key
+        DatashiftJourney::FormObjectFactory.state_name(self.class.name)
+      end
+
+    end
+  end
+end

data/app/forms/datashift_journey/concerns/form_mixin.rb

@@ -0,0 +1,64 @@
+require_dependency 'reform'
+
+module DatashiftJourney
+
+  # Collection of tools to support the Forms
+  module FormMixin
+
+    extend ActiveSupport::Concern
+
+    # These forms are used to back Views so need to be able to prepare and present data for views
+    include ActionView::Helpers::FormOptionsHelper
+
+    attr_reader :journey_plan
+    attr_accessor :redirection_url
+
+    def validate(params)
+      Rails.logger.debug "VALIDATING #{model.inspect} - Params - #{form_params(params)}"
+      super form_params(params)
+    end
+
+    def redirect?
+      Rails.logger.debug "Checking for REDIRECTION - [#{redirection_url}]"
+      !redirection_url.nil?
+    end
+
+    class_methods do
+
+      def form_definition
+        # In this situation self is the class of the including form eg PaymentForm, AddressFrom
+        @form_definition ||= DatashiftJourney::Collector::FormDefinition.find_or_create_by!(klass: self.name)
+      end
+
+      # Form helper to add fields inside a class definition
+      #
+      # N.B Currently this will create a permanent entry in the DB,
+      # so removing this code will not remove the Field - must be deleted from DB
+      #
+      # Usage
+      #
+      #   journey_plan_form_field name: :model_uri, category: :string
+      #   journey_plan_form_field name: :run_time,  category: :select_option
+      #   journey_plan_form_field name: :memory,    category: :number
+      #
+      def journey_plan_form_field(name:, category:)
+        DatashiftJourney::Collector::FormField.find_or_create_by!(form_definition: form_definition, name: name,  category: category)
+      end
+    end
+
+    protected
+
+    def form_params(params)
+      params.fetch(params_key, {})
+    end
+
+    def logger
+      Rails.logger
+    end
+
+    def form_definition
+      @form_definition ||= self.class.form_definition
+    end
+
+  end
+end

data/app/forms/datashift_journey/null_form.rb

@@ -0,0 +1,20 @@
+require_dependency 'reform'
+
+# A specialized Form class for use with states that do not require Form functionality,
+# just render the Partial
+
+module DatashiftJourney
+  class NullForm < BaseForm
+    def self.factory(journey_plan)
+      new(journey_plan)
+    end
+
+    def save
+      true
+    end
+
+    def validate(_params)
+      true
+    end
+  end
+end

data/app/helpers/datashift_journey/application_helper.rb

@@ -0,0 +1,50 @@
+module DatashiftJourney
+  module ApplicationHelper
+
+    # This is the main hook to insert a States partial view into the main Form
+    def render_if_exists(state, *args)
+      lookup_context.prefixes.prepend DatashiftJourney::Configuration.call.partial_location
+
+      render(state, *args) if lookup_context.exists?(state, lookup_context.prefixes, true)
+    end
+
+    # Returns true if '_state' partial exists in configured location (Configuration.partial_location)
+
+    def journey_plan_partial?(state)
+      return true if lookup_context.exists?(state, [DatashiftJourney::Configuration.call.partial_location], true)
+
+      Rails.logger.warn("DSJ - No partial found for [#{state}] in path(s) [#{lookup_context.prefixes.inspect}]")
+
+      false
+    end
+
+    # helper to return the location of a partial for a particular state
+    def journey_plan_partial_location(state)
+      Rails.logger.debug("DatashiftJourney RENDER #{DatashiftJourney::Configuration.call.partial_location}/#{state}}")
+      File.join(DatashiftJourney::Configuration.call.partial_location.to_s, state)
+    end
+
+    def error_link_id(attribute)
+      # with nested attributes can get full path e.g applicant_contact.full_name
+      # we only want the last field
+      field = attribute.to_s.split(/\./).last
+      "form_group_#{field}"
+    end
+
+    def all_errors(record)
+      record.class.reflect_on_all_associations.each do |a|
+        assoc = @journey_plan.send(a.name)
+        next unless assoc && assoc.respond_to?(:errors)
+        assoc.errors.full_messages.each do |_message|
+          "<li><a href='<%= message %>'></a></li>"
+        end
+      end
+    end
+
+    def friendly_date(date)
+      formatted_date = date && l(date.to_date, format: :long)
+      formatted_date || ''
+    end
+
+  end
+end

data/app/helpers/datashift_journey/back_link_helper.rb

@@ -0,0 +1,9 @@
+module DatashiftJourney
+  module BackLinkHelper
+
+    # Helper to create a standard Back link that will jump back to previous state
+    def back_a_state_link(journey_plan = nil, css: nil)
+      DatashiftJourney::BackLink.new(request, engine_routes: datashift_journey, journey_plan: journey_plan, css: css).tag
+    end
+  end
+end