Controll

gem 'imperator-ext'
gem 'controll'

def create
  # get the service parameter from the Rails router
  params[:service] ? service_route = params[:service] : service_route = 'No service recognized (invalid callback)'

  # get the full hash from omniauth
  omniauth = request.env['omniauth.auth']
  
  # continue only if hash and parameter exist
  if omniauth and params[:service]

    # map the returned hashes to our variables first - the hashes differs for every service
    
    # create a new hash
    @authhash = Hash.new
    
    extract_auth_data!
           
    if unknown_auth?       
      # debug to output the hash that has been returned when adding new services
      render :text => omniauth.to_yaml
      return
    end 
    
    if @authhash[:uid] != '' and @authhash[:provider] != ''
      
      auth = Service.find_by_provider_and_uid(@authhash[:provider], @authhash[:uid])

      # if the user is currently signed in, he/she might want to add another account to signin
      if user_signed_in?
        if auth
          flash[:notice] = 'Your account at ' + @authhash[:provider].capitalize + ' is already connected with this site.'
          redirect_to services_path
        else
          current_user.services.create!(:provider => @authhash[:provider], :uid => @authhash[:uid], :uname => @authhash[:name], :uemail => @authhash[:email])
          flash[:notice] = 'Your ' + @authhash[:provider].capitalize + ' account has been added for signing in at this site.'
          redirect_to services_path
        end
      else
        if auth
          # signin existing user
          # in the session his user id and the service id used for signing in is stored
          session[:user_id] = auth.user.id
          session[:service_id] = auth.id
        
          flash[:notice] = 'Signed in successfully via ' + @authhash[:provider].capitalize + '.'
          redirect_to root_url
        else
          # this is a new user; show signup; @authhash is available to the view and stored in the sesssion for creation of a new user
          session[:authhash] = @authhash
          render signup_services_path
        end
      end
    else
      flash[:error] =  'Error while authenticating via ' + service_route + '/' + @authhash[:provider].capitalize + '. The service returned invalid data for the user id.'
      redirect_to signin_path
    end
  else
    flash[:error] = 'Error while authenticating via ' + service_route.capitalize + '. The service did not return valid data.'
    redirect_to signin_path
  end
end

class ServicesController < ApplicationController
  include Controll::Enabler

  def create
    execute # action.perform
  end
end

class ServicesController < ApplicationController
  before_filter :authenticate_user!, :except => accessible_actions
  protect_from_forgery :except => :create

  # see 'controll' gem
  include Controll::Enabler
end

class ApplicationController
  include Controll::Enabler
end

class ApplicationController
  include Controll::Macros
end

class ServicesController < ApplicationController
  enable_controll
end

class ServicesController < ApplicationController
  enable_controll

  ...

  protected

  notifier :services
  commander :services

  # or simply (using naming convention)
  controll :notifier, :commander

  def create
    create_action.perform
  end

  protected

  def create_action
    @create_action ||= Flows::CreateService.new(self)
  end

  fallback do |event|
    event == :no_auth ? render(:text => omniauth.to_yaml) : fallback_action
  end        

  def fallback_action
    redirect_to root_url
  end
end

class ServicesController

  # could be extracted into "global" namespace for reuse across controllers...
  module ControllAction
    extend ActiveSupport::Concern

    included do
      controll :notifier, :commander, :flow
    end

    def fallback_action
      redirect_to root_url
    end
  end

  class Create < FocusedAction
    include ControllAction

    run do
      execute
    end

    protected

    fallback do |event|
      event == :no_auth ? render(:text => omniauth.to_yaml) : fallback_action
    end        
  end
end

module Commanders
  class Services < Commander
    # create basic command methods
    command_methods :cancel_commit, :create_account, :signout

    # create custom command method with custom argument hash
    def sign_in_command
      @sign_in_command ||= SignInCommand.new auth_hash: auth_hash, user_id: user_id, service_id: service_id, service_hash: service_hash, initiator: self
    end

    command_method :sign_out do
      @sign_out_command ||= SignOutCommand.new user_id: user_id, service_id: service_id, service_hash: service_hash, initiator: self
    end

    # delegations (alias for initiator_methods )
    controller_methods :auth_hash, :user_id, :service_id, :service_hash
  end
end

module Flows
  class CreateService < Flow

    # event method that returns the event to be processed by the flow handler
    event do
      Executors::Authenticator.new(controller).execute
    end

    # configuration of the Renderer ActionHandler
    # will return a Renderer Action if it matches the event
    renderer :simple do
      events :signed_in_new_user, :signed_in do
        signup_services_path
      end
    end

    # configuration of the Redirecter ActionHandler
    # will return a Redirecter Action if it matches the event
    redirecter :complex do
      # redirection mappings for :notice events
      event_map :notice do
        {        
          signup_services_path: :signed_in_new_user
          services_path:        [:signed_in_connect, :signed_in_new_connect]
          root_url:             [:signed_in_user, :other]
        }
      end

      # redirection mappings for :error events
      event_map :error, signin_path: [:error, :invalid, :auth_error]
    end  
  end
end

module Executors
  class Authenticator < Controlled

    # ensures pattern:
    # - perform validations and only execute command if no error
    def execute
      super      
      result      
    end

    protected

    controller_methods :omniauth, :service, :auth_hash, :auth_valid?

    def do_command
      command! :sign_in
    end

    def validations
      # creates an error notification named :error
      error and return unless valid_params?

      # creates an error notification named :auth_invalid
      error(:auth_invalid) and return unless auth_valid?
    end    

    def valid_params?
      omniauth and service and auth_hash
    end
  end
end

execute do
  # error/validation checks? ...
  command! :sign_in
end

module Notifiers
  class Services < Typed
    handler :error do
      messages do
        {
          must_sign_in: 'You need to sign in before accessing this page!',
          
          auth_service_error: %q{There was an error at the remote authentication service.
You have not been signed in.},
          
          cant_delete_current_account: 'You are currently signed in with this account!',
          user_save_error: 'This is embarrassing! There was an error while creating your account from which we were not able to recover.',
        }
      end

      msg :auth_error! do
        "Error while authenticating via #{service_name}. The service did not return valid data."
      end

      msg :auth_invalid! do
        'Error while authenticating via {{full_route}}. The service returned invalid data for the user id.'
      end
    end


    handler :notice do
      # for :signed_in and :signed_out - defined in locale file under:
      # notifiers:
      #   services:
      #     notice:
      #       signed_in:  'Your account has been created and you have been signed in!'
      #       signed_out: 'You have been signed out!'

      msg :already_connected do
        'Your account at {{provider_name}} is already connected with this site.'
      end

      msg :account_added do
        'Your {{provider_name}} account has been added for signing in at this site.'
      end

      msg :sign_in_success do
        'Signed in successfully via {{provider_name}}.'
      end
    end
  end
end