j1_template_mde 2018.4.15 → 2018.4.16

data/lib/j1_app/j1_auth_manager/auth_manager.rb

@@ -41,16 +41,16 @@ module J1App
     # ==========================================================================
 
     j1_web_session = {
-        'authenticated'       => 'false',
-        'requested_page'      => '/',
-        'users_allowed'       => 'unknown',
-        'user_name'           => 'unknown',
-        'user_id'             => 'unknown',
-        'provider'            => 'unknown',
-        'provider_url'        => '/',
-        'payment_info'        => 'unknown',
-        'permissions'         => 'unknown',
-        'writer'              => 'middleware'
+        :authenticated       => 'false',
+        :requested_page      => '/',
+        :user_name           => 'unknown',
+        :users_allowed       => 'unknown',
+        :user_id             => 'unknown',
+        :provider            => 'unknown',
+        :provider_url        => '/',
+        :payment_info        => 'unknown',
+        :permissions         => 'unknown',
+        :writer              => 'middleware'
     }
 
     # Enable SSL for the rack session if configured
@@ -120,55 +120,55 @@ module J1App
       # up the session cookie (as it is limited to 4K)
       skip_extra = true
 
-      if J1App.provider.include? 'patreon'
-        scope             = J1App.provider_scope 'patreon'
-        data_collection   = J1App.provider_data 'patreon'
+      if J1App.active_providers.include? 'patreon'
+        scope             = J1App.auth_config['providers']['patreon']['scope'].join(',')
+        data_collection   = J1App.auth_config['providers']['patreon']['data_fields'].join(',')
         skip_extra        = false if data_collection =~ /raw/i
         provider :patreon,
-           ENV['PATREON_CLIENT_ID'],
-           ENV['PATREON_CLIENT_SECRET'],
-           scope: "#{scope}",
-           skip_extra: skip_extra
+                 ENV['PATREON_CLIENT_ID'],
+                 ENV['PATREON_CLIENT_SECRET'],
+                 scope: "#{scope}",
+                 skip_extra: skip_extra
       end
-      if J1App.provider.include? 'disqus'
-        scope             = J1App.provider_scope 'disqus'
-        data_collection   = J1App.provider_data 'disqus'
+      if J1App.active_providers.include? 'disqus'
+        scope             = J1App.auth_config['providers']['disqus']['scope'].join(',')
+        data_collection   = J1App.auth_config['providers']['disqus']['data_fields'].join(',')
         skip_extra        = false if data_collection =~ /raw/i
         provider :disqus,
-           ENV['DISQUS_CLIENT_ID'],
-           ENV['DISQUS_CLIENT_SECRET'],
-           scope: "#{scope}",
-           skip_extra: skip_extra
+                 ENV['DISQUS_CLIENT_ID'],
+                 ENV['DISQUS_CLIENT_SECRET'],
+                 scope: "#{scope}",
+                 skip_extra: skip_extra
       end
-      if J1App.provider.include? 'facebook'
-        scope             = J1App.provider_scope 'facebook'
-        data_collection   = J1App.provider_data 'facebook'
+      if J1App.active_providers.include? 'facebook'
+        scope             = J1App.auth_config['providers']['facebook']['scope'].join(',')
+        data_collection   = J1App.auth_config['providers']['facebook']['data_fields'].join(',')
         skip_extra        = false if data_collection =~ /raw/i
         provider :facebook,
-           ENV['FACEBOOK_CLIENT_ID'],
-           ENV['FACEBOOK_CLIENT_SECRET'],
-           scope: "#{scope}",
-           skip_extra: skip_extra
+                 ENV['FACEBOOK_CLIENT_ID'],
+                 ENV['FACEBOOK_CLIENT_SECRET'],
+                 scope: "#{scope}",
+                 skip_extra: skip_extra
       end
-      if J1App.provider.include? 'github'
-        scope             = J1App.provider_scope 'github'
-        data_collection   = J1App.provider_data 'github'
+      if J1App.active_providers.include? 'github'
+        scope             = J1App.auth_config['providers']['github']['scope'].join(',')
+        data_collection   = J1App.auth_config['providers']['github']['data_fields'].join(',')
         skip_extra        = false if data_collection =~ /raw/i
         provider :github,
-           ENV['GITHUB_CLIENT_ID'],
-           ENV['GITHUB_CLIENT_SECRET'],
-           scope: "#{scope}",
-           skip_extra: skip_extra
+                 ENV['GITHUB_CLIENT_ID'],
+                 ENV['GITHUB_CLIENT_SECRET'],
+                 scope: "#{scope}",
+                 skip_extra: skip_extra
       end
-      if J1App.provider.include? 'twitter'
-        scope             = J1App.provider_scope 'twitter'
-        data_collection   = J1App.provider_data 'twitter'
+      if J1App.active_providers.include? 'twitter'
+        scope             = J1App.auth_config['providers']['twitter']['scope'].join(',')
+        data_collection   = J1App.auth_config['providers']['twitter']['data_fields'].join(',')
         skip_extra        = false if data_collection =~ /raw/i
         provider :twitter,
-           ENV['TWITTER_CLIENT_ID'],
-           ENV['TWITTER_CLIENT_SECRET'],
-           scope: "#{scope}",
-           skip_extra: skip_extra
+                 ENV['TWITTER_CLIENT_ID'],
+                 ENV['TWITTER_CLIENT_SECRET'],
+                 scope: "#{scope}",
+                 skip_extra: skip_extra
       end
     end
 
@@ -184,11 +184,9 @@ module J1App
 
     # Load user profiles, permissions, conditions and strategies
     # --------------------------------------------------------------------------
-    # provider_permission =  J1App.get_provider_permissions "disqus"
-    users = J1App.users
+
+    providers   = J1App.auth_config['providers']
     permissions = J1App.permissions
-    conditions = J1App.conditions
-    strategies = J1App.strategies
 
 
     # ==========================================================================
@@ -198,7 +196,8 @@ module J1App
     # Prepare root (index) page for app detection
     #
     before '/' do
-      logger.info "ROOT PAGE: Prepare J1 web session data"
+      log_info! "RootPage", "PrepareCookie", 'j1.web.session'
+      #logger.info "ROOT PAGE: Prepare J1 web session data"
 
       # read existing/current cookie 'j1.web.session' to update all data
       # of j1_web_session (hash) otherwise set initial data
@@ -217,35 +216,37 @@ module J1App
       # Create|Initialize the J1 web session cookie
       # ------------------------------------------------------------------------
       if warden.authenticated?
+        log_info! "RootPage", 'UpdateCookie', 'Set current user data'
+
         user = warden.user
-        logger.info "ROOT PAGE: User detected as signed in at provider: #{user[:provider]}"
+        log_info! "RootPage", 'AuthCheck', 'User detected as signed in', "#{user[:provider]}"
         j1_web_session['authenticated']   = 'true'
         j1_web_session['requested_page']  = '/'
-        j1_web_session['users_allowed']   = users["#{user[:provider]}"]
+        j1_web_session['users_allowed']   = providers["#{user[:provider]}"]['users']
         j1_web_session['user_name']       = user[:info]['nickname']
         j1_web_session['user_id']         = user[:uid]
         j1_web_session['provider']        = user[:provider]
-        j1_web_session['provider_url']    = J1App.provider_url user[:provider]
-        j1_web_session['permissions']     = J1App.get_provider_permissions "#{user[:provider]}"
+        j1_web_session['provider_url']    = providers["#{user[:provider]}"]['home_url']
+        j1_web_session['permissions']     = providers["#{user[:provider]}"]['permissions']
         j1_web_session['payment_info']    = user[:info]['payment_info']['attributes'] unless user[:info]['payment_info'].nil?
       else
-        logger.info "ROOT PAGE: User detected as signed out"
+        log_info! "RootPage", 'AuthCheck', 'User detected', 'signed out'
         j1_web_session['authenticated']   = 'false'
         j1_web_session['requested_page']  = '/'
         j1_web_session['users_allowed']   = 'all'
         j1_web_session['user_name']       = 'unknown'
         j1_web_session['user_id']         = 'unknown'
         j1_web_session['payment_info']    = 'unknown'
-        j1_web_session['provider']        = 'unknown'        
+        j1_web_session['provider']        = 'unknown'
         j1_web_session['provider_url']    = 'unknown'
         j1_web_session['permissions']     = 'unknown'
       end
       j1_web_session['writer']            = 'middleware'
 
       session_json = j1_web_session.to_json
+      log_info! "RootPage", 'WriteCookie', 'j1.web.session' # "#{session_json}"
+
       session_encoded = Base64.encode64(session_json)
-      logger.info "ROOT PAGE: Write J1 web session data to cookie"
-      #logger.info "ROOT PAGE: write J1 web session data as: #{session_json}"
       response.set_cookie(
           'j1.web.session',
           domain: false,
@@ -265,115 +266,185 @@ module J1App
       # if request.warden.user.respond_to?(:info)
       # ------------------------------------------------------------------------
       if env['HTTP_COOKIE'].include? 'j1.web.session'
-        session_encoded = request.cookies['j1.web.session']
-        session_decoded = Base64.decode64(session_encoded)
-        logger.info "BEFORE AUTHENTICATION: Read J1 web session data"
-        #logger.info "BEFORE AUTHENTICATION: Read J1 web session data as: #{session_decoded}"
-        j1_web_session = JSON.parse(session_decoded)
+        session_encoded     = request.cookies['j1.web.session']
+        session_decoded     = Base64.decode64(session_encoded)
+        j1_web_session      = JSON.parse(session_decoded)
+
+        log_info! 'Authorisation', 'ReadCookie', 'j1.web.session' # "#{session_decoded}"
       else
-        requested_page = env['REQUEST_URI']
+        requested_page      = env['REQUEST_URI']
         j1_web_session['requested_page'] = "#{env['REQUEST_URI']}"
       end
 
       # Create|Initialize the J1 web session cookie
       # ------------------------------------------------------------------------
       if warden.authenticated?
+        log_info! 'Authorisation', 'UpdateCookie', 'Set current user data'
+
         user = warden.user
         j1_web_session['authenticated']   = 'true'
         j1_web_session['user_name']       = user[:info]['nickname']
         j1_web_session['user_id']         = user[:uid]
         j1_web_session['provider']        = user[:provider]
-        j1_web_session['provider_url']    = J1App.provider_url user[:provider]
-        j1_web_session['users_allowed']   = users["#{user[:provider]}"]
-        j1_web_session['permissions']     = J1App.get_provider_permissions "#{user[:provider]}"
+        j1_web_session['provider_url']    = providers["#{user[:provider]}"]['home_url']
+        j1_web_session['users_allowed']   = providers["#{user[:provider]}"]['users']#
+        j1_web_session['permissions']     = providers["#{user[:provider]}"]['permissions']
         j1_web_session['payment_info']    = user[:info]['payment_info']['attributes'] unless user[:info]['payment_info'].nil?
         j1_web_session['writer']          = 'middleware'
-      end
 
-      session_json = j1_web_session.to_json
-      session_encoded = Base64.encode64(session_json)
-      logger.info "INITIALISATION: Write J1 web session data to cookie"
-      response.set_cookie(
-          'j1.web.session',
-          domain: false,
-          value: session_encoded.to_s,
-          path: '/'
-      )
+        session_json = j1_web_session.to_json
+        log_info! 'Authorisation', 'WriteCookie', 'j1.web.session' # "#{session_json}"
+
+        session_encoded = Base64.encode64(session_json)
+        response.set_cookie(
+            'j1.web.session',
+            domain: false,
+            value: session_encoded.to_s,
+            path: '/'
+        )
+      end
 
       # User state|content detection for implicit authentication
       # ------------------------------------------------------------------------
+      log_info! 'Authorisation', 'CheckConfig', 'Authentication enabled', "false" if authentication_enabled? == false
+      log_info! 'Authorisation', 'CheckConfig', 'Pass for all pages' if authentication_enabled? == false
       pass if authentication_enabled? == false
-      logger.info "AUTORISATION: Authentication enabled. Check for public content."
+      log_info! 'Authorisation', 'CheckConfig', 'Authentication enabled', "true"
+      log_info! 'Authorisation', 'DetectContent', 'Check for public content' if public_content?
+      log_info! 'Authorisation', 'DetectContent', 'Pass all public content' if public_content?
       pass if public_content?
-      logger.info "AUTORISATION: Protected content detected. Check for authorisation."
+      log_info! 'Authorisation', 'DetectContent', 'Check for protected content'
 
-      env['REQUEST_URI'].scan(/(private|premium)/) do |match|
+      requested_page      = env['REQUEST_URI']
+
+      requested_page.scan(/(private|premium)/) do |match|
 
         category = match[0]
-        logger.info "AUTORISATION: Content category detected: #{category}"
+        log_info! 'Authorisation', 'DetectContent', 'Content detected', "#{category}"
 
         if warden.authenticated?
-          logger.info "AUTORISATION: User detected as signed in."
-
-          current_provider                  = warden.user[:provider]
-          provider_strategy                 = strategies["#{current_provider}"]
-          provider_url                      = J1App.provider_url current_provider
-          j1_web_session['provider_url']    = provider_url
-          j1_web_session['users_allowed']   = users["#{current_provider}"]
-          j1_web_session['permissions']     = J1App.get_provider_permissions "#{user[:provider]}"
-
-          logger.info "AUTORISATION: Current provider detected: #{current_provider}"
-          if permissions[category].include? current_provider
-            logger.info "AUTORISATION: Current provider #{current_provider} support category: #{category}"
+          log_info! 'Authorisation', 'UpdateCookie', 'Set current user data'
+
+          user_name = user[:info]['nickname']
+          log_info! 'Authorisation', 'AuthCheck', 'User detected', "#{user_name}"
+
+          current_provider  = warden.user[:provider]
+
+          # provider_strategy = strategies["#{default_provider}"]
+          strategy          = providers["#{current_provider}"]['strategy']
+          provider_strategy = :"#{strategy}"
+
+          j1_web_session['user_name']       = user_name
+          j1_web_session['provider_url']    = providers["#{current_provider}"]['home_url']
+          j1_web_session['users_allowed']   = providers["#{current_provider}"]['users']
+          j1_web_session['permissions']     = providers["#{user[:provider]}"]['permissions']
+          j1_web_session['requested_page']  = requested_page
+
+          if permissions[:"#{category}"].include? current_provider
+            log_info! 'Authorisation', 'ContentCheck', 'Provider detected', "#{current_provider}"
+            log_info! 'Authorisation', 'ContentCheck', 'Category supported', "yes - #{category}"
+            # Check permissions
+            #
+            log_info! 'Authorisation', 'ConditionCheck', 'Check permissions for provider', "#{current_provider}"
+            conditions = J1App.conditions current_provider
+            if conditions["#{category}"]
+              log_info! 'Authorisation', 'ConditionCheck', 'Conditions detected for', "#{category}"
+              conditions["#{category}"].each do |k, v|
+                case k
+                when 'enabled'
+                  log_info! 'Authorisation', 'ConditionCheck', "#{k}", "#{v}"
+                when 'users'
+                  log_info! 'Authorisation', 'ConditionCheck', 'users'
+                  v.each do |k, v|
+                    log_info! 'Authorisation', 'ConditionCheck', "users - #{k}", "#{v}"
+                  end
+                when 'payment'
+                  log_info! 'Authorisation', 'ConditionCheck', 'payment'
+                  v.each do |k, v|
+                    case k
+                    when 'tiers'
+                      log_info! 'Authorisation', 'ConditionCheck', "payment - #{k}", "#{v}"
+                    when 'tier'
+                      v.each do |k, v|
+                        log_info! 'Authorisation', 'ConditionCheck', 'payment - tiers - tier : ' "#{k}", "#{v}"
+                      end
+                    end
+                  end
+                end
+              end
+            end
           else
-            logger.info "AUTORISATION: SignIn to provider #{permissions[category][0]} for category: #{category}"
+            provider  = permissions[:"#{category}"][0]
+            log_info! 'Authorisation', 'ContentCheck', 'Provider detected', "#{current_provider}"
+            log_info! 'Authorisation', 'ContentCheck', 'Category supported', "no - #{category}"
+            log_info! 'Authorisation', 'SignIn', 'Provider', "#{provider}"
             warden.logout
             session.clear
 
-            allowed_users = users["#{current_provider}"].join(',')
+            session_json = j1_web_session.to_json
+            log_info! 'Authorisation', 'WriteCookie', 'j1.web.session' # "#{session_json}"
+
+            session_encoded = Base64.encode64(session_json)
+            response.set_cookie(
+                'j1.web.session',
+                domain: false,
+                value: session_encoded.to_s,
+                path: '/'
+            )
 
-            redirect "/access_protected_content?provider=#{permissions[category][0]}&category=#{category}&page=#{env['REQUEST_URI']}&allowed_users=#{allowed_users}"
-            # warden.authenticate! :"omni_#{permissions[category][0]}"
+            log_info! 'Authorisation', 'AuthManager', 'Request for authentication'
+
+            allowed_users = providers["#{provider}"]['users'].join(',')
+            redirect "/access_protected_content?provider=#{provider}&category=#{category}&page=#{requested_page}&allowed_users=#{allowed_users}"
           end
+          log_info! 'Authorisation', 'AuthCheck', 'Pass to requested page', "#{requested_page}"
           pass
         else
-          logger.info "AUTORISATION: User detected as signed out."
-          default_provider = permissions[category][0]
-          logger.info "AUTORISATION: Set default provider: #{default_provider}"
+          log_info! 'Authentication', 'AuthCheck', 'User detected', 'signed out'
+          default_provider = permissions[:"#{category}"][0]
+          log_info! 'Authentication', 'ContentCheck', 'Set default provider', "#{default_provider}"
+
+          # provider_strategy = strategies["#{default_provider}"]
+          strategy          = providers["#{default_provider}"]['strategy']
+          provider_strategy = :"#{strategy}"
 
-          authentication_strategy = strategies["#{default_provider}"]
-          logger.info "AUTHENTICATION: Set authentication strategy: #{authentication_strategy}"
-          logger.info "AUTHENTICATION: SignIn provider #{permissions[category][0]} for category: #{category}"
+          log_info! 'Authentication', 'SignIn', 'Default provider detected', "#{default_provider}"
+          log_info! 'Authentication', 'SignIn', 'Set authentication strategy', "#{provider_strategy}"
+
+          case provider_strategy
 
-          case authentication_strategy
           when :org
             warden.authenticate!
             github_organization_authenticate! ENV['GITHUB_ORG_NAME']
-            logger.info "Hi There, #{j1_web_session[:user_name]}! You have access to the #{params['id']} organization."
+            logger.info "Hi There, #{j1_web_session[:user_name]}! You have access to the #{params['id']} organization"
+
           when :team
             warden.authenticate!
             github_team_authenticate! ENV['GITHUB_TEAM_ID']
-            logger.info "Hi There, #{j1_web_session[:user_name]}! You have access to the #{params['id']} team."
+            logger.info "Hi There, #{j1_web_session[:user_name]}! You have access to the #{params['id']} team"
+
           when :teams
             warden.authenticate!
             github_teams_authenticate! ENV['GITHUB_TEAM_IDS'].split(',')
-            logger.info "Hi There, #{j1_web_session[:user_name]}! You have access to the #{params['id']} team."
+            logger.info "Hi There, #{j1_web_session[:user_name]}! You have access to the #{params['id']} team"
+
           when :member
+            log_info! 'Authentication', 'SignIn', "Strategy detected", "member"
 
             if env['HTTP_COOKIE'].include? 'j1.web.session'
-              session_encoded = request.cookies['j1.web.session']
-              session_decoded = Base64.decode64(session_encoded)
-              logger.info "BEFORE AUTHENTICATION: Read J1 web session data"
-              #logger.info "BEFORE AUTHENTICATION: Read J1 web session data as: #{session_decoded}"
-              j1_web_session = JSON.parse(session_decoded)
+              session_encoded   = request.cookies['j1.web.session']
+              session_decoded   = Base64.decode64(session_encoded)
+              log_info! 'Authentication', 'ReadCookie', 'j1.web.session' # "#{session_decoded}"
+              j1_web_session    = JSON.parse(session_decoded)
             end
 
-            # Get access to protected content
+            # Update cookie data
             # ----------------------------------------------------------------------
-            logger.info "STRATEGY: set redirect to: #{j1_web_session['requested_page']}"
-            j1_web_session['provider_url']    = J1App.provider_url default_provider
-            j1_web_session['users_allowed']   = users["#{default_provider}"]
-            j1_web_session['permissions']     = J1App.get_provider_permissions "#{default_provider}"
+            log_info! 'Authentication', 'UpdateCookie', 'Set current user data'
+
+            j1_web_session['provider_url']    = providers["#{default_provider}"]['home_url']
+            j1_web_session['users_allowed']   = providers["#{default_provider}"]['users']
+            j1_web_session['permissions']     = providers["#{default_provider}"]['permissions']
             j1_web_session['requested_page']  = env['REQUEST_URI']
             j1_web_session['writer']          = 'middleware'
 
@@ -381,8 +452,8 @@ module J1App
             #
             session_json = j1_web_session.to_json
             session_encoded = Base64.encode64(session_json)
-            logger.info "STRATEGY: Write J1 web session data to cookie"
-            #logger.info "STRATEGY: write J1 web session data as: #{session_json}"
+            log_info! 'Authentication', 'WriteCookie', 'j1.web.session' # "#{session_json}"
+
             response.set_cookie(
                 'j1.web.session',
                 domain: false,
@@ -390,13 +461,16 @@ module J1App
                 path: '/'
             )
 
-            allowed_users = users["#{default_provider}"].join(',')
-            redirect "/access_protected_content?provider=#{permissions[category][0]}&category=#{category}&page=#{env['REQUEST_URI']}&allowed_users=#{allowed_users}"
+            allowed_users   = providers["#{default_provider}"]['users'].join(',')
+            requested_page  = env['REQUEST_URI']
+
+            log_info! 'Authorisation', 'AuthManager', 'Request for authentication'
+            redirect "/access_protected_content?provider=#{default_provider}&category=#{category}&page=#{requested_page}&allowed_users=#{allowed_users}"
           else
             raise J1App::ConfigError
           end
-        end
 
+        end
       end
     end
 
@@ -410,13 +484,16 @@ module J1App
     get '/authentication' do
       # collect (common) GET parameter|s
       #
-      request       =  params.fetch('request')
-      provider      =  params.fetch('provider')
+      request                           =  params.fetch('request')
+      provider                          =  params.fetch('provider')
 
       if request === 'signin'
+
+        log_info! 'Authentication', 'RestApi', 'Called for SignIn'
+
         # collect (additional) GET parameter|s
         # ----------------------------------------------------------------------
-        allowed_users =  params.fetch('allowed_users')
+        allowed_users                   =  params.fetch('allowed_users')
 
         j1_web_session['users_allowed'] = allowed_users
         j1_web_session['writer']        = 'middleware'
@@ -424,8 +501,9 @@ module J1App
         # Write updated J1 session data to cookie
         # --------------------------------------------------------------------
         session_json = j1_web_session.to_json
+        log_info! 'Authentication', 'RestApi', 'Write J1 web session data to cookie' # #{session_json}"
+
         session_encoded = Base64.encode64(session_json)
-        logger.info "SIGNIN: Write J1 web session data to cookie"
         response.set_cookie(
             'j1.web.session',
             domain: false,
@@ -434,18 +512,21 @@ module J1App
         )
 
         if warden.authenticated?
-          logger.info "SIGNIN: #{warden.user[:info]['nickname']} already signed in"
+          log_info! 'Authentication', 'RestApi', 'Already signed in', "#{warden.user[:info]['nickname']} "
         else
-          logger.info "SIGNIN: going for authentication at: #{provider}"
+          log_info! 'Authentication', 'RestApi', 'Go for authentication', "#{provider}"
           # Make (really) sure that old session is cleared before login
           # --------------------------------------------------------------------
           warden.logout
           session.clear
           warden.authenticate! :"omni_#{provider}"
         end
-        logger.info "SIGNIN: redirect to #{j1_web_session['requested_page']}"
+        log_info! 'Authentication', 'RestApi', 'Requested page', "#{j1_web_session['requested_page']}"
         redirect j1_web_session['requested_page']
       elsif request === 'signout'
+
+        log_info! 'Authentication', 'RestApi', 'Called for sign out'
+
         # collect (additional) GET parameter|s
         # ----------------------------------------------------------------------
         provider_signout = params.fetch('provider_signout')
@@ -462,8 +543,7 @@ module J1App
           if env['HTTP_COOKIE'].include? 'j1.web.session'
             session_encoded = env['rack.request.cookie_hash']['j1.web.session']
             session_decoded = Base64.decode64(session_encoded)
-            #logger.info "SIGNOUT: read J1 web session data as: #{session_decoded}"
-            logger.info "SIGNOUT: read J1 web session data"
+            log_info! 'Authentication', 'RestApi', 'Read J1 web session data from cookie' # #{session_decoded}"
             j1_web_session = JSON.parse(session_decoded)
           else
             j1_web_session['requested_page'] = env['REQUEST_URI']
@@ -484,8 +564,9 @@ module J1App
           # Write updated J1 session data to cookie
           # --------------------------------------------------------------------
           session_json = j1_web_session.to_json
+          log_info! 'Authentication', 'RestApi', 'Write J1 web session data to cookie' # #{session_json}"
+
           session_encoded = Base64.encode64(session_json)
-          logger.info "SIGNOUT: Write J1 web session data to cookie"
           response.set_cookie(
               'j1.web.session',
               domain: false,
@@ -494,20 +575,26 @@ module J1App
           )
 
           if provider_signout === 'true'
-            logger.info "SIGNOUT: for #{user} completely at provider: #{provider}"
+            log_info! 'Authentication', 'RestApi', 'Sign out user', "#{user}"
+            log_info! 'Authentication', 'RestApi', 'Sign out provider', "#{provider}"
+            log_info! 'Authentication', 'RestApi', 'Sign out from', "#{provider}"
+            log_info! 'Authentication', 'RestApi', 'Redirect to provider', "#{provider_url}"
             redirect "#{provider_url}"
           else
-            logger.info "SIGNOUT: for #{user} from current session at provider: #{provider}"
+            log_info! 'Authentication', 'RestApi', 'Sign out user', "#{user}"
+            log_info! 'Authentication', 'RestApi', 'Sign out provider', "#{provider}"
+            log_info! 'Authentication', 'RestApi', 'Sign out from', "session"
+            log_info! 'Authentication', 'RestApi', 'Redirect to page', "#{j1_web_session['requested_page']}"
 
             # If signed out, redirect ONLY for PUBLIC pages
             # ------------------------------------------------------------------
             if redirect_whitelisted?j1_web_session['requested_page']
-              logger.info 'SIGNOUT: redirect whitelisted'
-              logger.info "SIGNOUT: redirect to #{j1_web_session['requested_page']}"
+              log_info! 'Authentication', 'RestApi', 'Redirect detetced as', "whitelisted"
+              log_info! 'Authentication', 'RestApi', 'Requested page', "#{j1_web_session['requested_page']}"
               redirect j1_web_session['requested_page']
             else
-              logger.info "SIGNOUT: redirect NOT whitelisted: #{j1_web_session['requested_page']}"
-              logger.info 'SIGNOUT: redirect to web root: /'
+              log_info! 'Authentication', 'RestApi', 'Redirect detetced as', "NOT whitelisted"
+              log_info! 'Authentication', 'RestApi', 'Redirect to', "/"
               redirect '/'
             end
           end
@@ -516,16 +603,16 @@ module J1App
           # (modal) is provided by the auth client if a user isn't signed in.
           # Kept this alternative for cases something went wrong.
           # --------------------------------------------------------------------
-          logger.info 'DEAD PATH SIGNOUT: not signed in'
+          log_info! 'Authentication', 'RestApi', 'DEAD PATH: Called for sign out', 'NOT signed in'
 
           # Read current J1 session cookie
           # --------------------------------------------------------------------
           if env['HTTP_COOKIE'].include? 'j1.web.session'
-            session_encoded = env['rack.request.cookie_hash']['j1.web.session']
-            session_decoded = Base64.decode64(session_encoded)
-            # logger.info "DEAD PATH SIGNOUT: read J1 web session data as: #{session_decoded}"
-            logger.info "DEAD PATH SIGNOUT: read J1 web session data"
-            j1_web_session = JSON.parse(session_decoded)
+            session_encoded   = env['rack.request.cookie_hash']['j1.web.session']
+            session_decoded   = Base64.decode64(session_encoded)
+            j1_web_session  = JSON.parse(session_decoded)
+
+            log_info! 'Authentication', 'RestApi', 'DEAD PATH: Read J1 web session data from cookie' # #{session_decoded}"
           else
             j1_web_session['requested_page'] = env['REQUEST_URI']
           end
@@ -545,15 +632,17 @@ module J1App
           # Write updated J1 session data to cookie
           # --------------------------------------------------------------------
           session_json = j1_web_session.to_json
+          log_info! 'Authentication', 'RestApi', 'DEAD PATH: Write J1 web session data to cookie' # #{session_json}"
+
           session_encoded = Base64.encode64(session_json)
-          logger.info "DEAD PATH SIGNOUT: Write J1 web session data to cookie"
           response.set_cookie(
               'j1.web.session',
               domain: false,
               value: session_encoded.to_s,
               path: '/'
           )
-          logger.info "DEAD PATH SIGNOUT: redirect to #{j1_web_session['requested_page']}"
+
+          log_info! 'Authentication', 'RestApi', 'DEAD PATH: Redirect to requested page', "#{j1_web_session['requested_page']}"
           redirect j1_web_session['requested_page']
         end
       else
@@ -565,60 +654,112 @@ module J1App
     # --------------------------------------------------------------------------
     get '/redirect_after_callback' do
 
-      session_encoded = request.cookies['j1.web.session']
-      session_decoded = Base64.decode64(session_encoded)
-      j1_web_session = JSON.parse(session_decoded)
+      reward = {
+          :id       => 'unknown',
+          :name     => 'unknown',
+          :link     => 'javascript:void(0)'
+      }
+
+      campaign = {
+          :id       => 'unknown',
+          :link     => 'javascript:void(0)'
+      }
+
+      session_encoded   = request.cookies['j1.web.session']
+      session_decoded   = Base64.decode64(session_encoded)
+      j1_web_session    = JSON.parse(session_decoded)
 
-      #logger.info "AFTER AUTHENTICATION: read J1 web session data as: #{j1_web_session}"
-      logger.info "AFTER AUTHENTICATION: read J1 web session data"
+      log_info! 'Authentication', 'Callback', 'Update web session data' # "#{j1_web_session}"
+
+      user              = warden.user
+      user_json         = user.to_json
+
+      if user[:provider] === 'disqus'
+        user[:info][:urls][:site]   = "https://disqus.com"
+        user[:info][:urls][:home]   = user[:info]['urls']['profileUrl']
+        user[:info][:urls][:blog]   = "https://disqus.com/by/juergen_adams/"
+        user[:info][:urls][:member] = user[:info]['urls']['profileUrl']
+      end
+
+      if user[:provider] === 'github'
+        user[:info][:urls][:site]   = "https://github.com"
+        user[:info][:urls][:home]   = user[:info]['urls']['GitHub']
+        user[:info][:urls][:blog]   = "https://github.com/jekyll-one"
+        user[:info][:urls][:member] = user[:info]['urls']['Blog']
+      end
+
+      if user[:provider] === 'patreon'
+        reward_url                  = user[:info]['payment_info']['relationships']['reward']['links']['related']
+        reward_json                 = RestClient.get "#{reward_url}", {:content_type => :json, :accept => :json}
+        reward_data                 = JSON.parse(reward_json)
+
+        user[:info][:urls][:site]   = "https://patreon.com"
+        user[:info][:urls][:home]   = "https://patreon.com/home"
+        user[:info][:urls][:blog]   = "https://patreon.com/jekyll_one"
+#       user[:info][:urls][:member] = reward_data['included'][0]['attributes']['url']
+        user[:info][:urls][:member] = "https://patreon.com" + reward_data['data']['attributes']['url']
+
+        reward[:id]                 = reward_data['data']['id']
+        reward[:name]               = reward_data['data']['attributes']['title']
+        reward[:link]               = "https://patreon.com" + reward_data['data']['attributes']['url']
+
+        campaign[:id]               = reward_data['data']['relationships']['campaign']['data']['id']
+        campaign[:link]             = reward_data['data']['relationships']['campaign']['links']['related']
+      end
+
+      user[:extra][:reward]         = reward
+      user[:extra][:campaign]       = campaign
+
+      if user.nil?
+        # Collection of session data failed (e.g cookie > 4K)
+        #
+        log_info! 'Authentication', 'Callback', 'Internal error', 'User authentication failed'
 
-      user = warden.user
-      user_json = user.to_json
+        warden.logout
+        session.clear
+        redirect "/access_denied?provider=unknown&user=unknown&category=unknown"
+      else
+        log_info! 'Authentication', 'Callback', 'Set current user data'
 
-      unless user.nil?
         j1_web_session['user_name']       = user[:info]['nickname']
         j1_web_session['user_id']         = user[:uid]
         j1_web_session['provider']        = user[:provider]
-        j1_web_session['permissions']     = J1App.get_provider_permissions "#{user[:provider]}"
+        j1_web_session['permissions']     = providers["#{user[:provider]}"]['permissions']
         j1_web_session['authenticated']   = 'true'
         j1_web_session['payment_info']    = user[:info]['payment_info']['attributes'] unless user[:info]['payment_info'].nil?
         j1_web_session['writer']          = 'middleware'
 
-        current_user = user[:info]['nickname'] = user[:info]['nickname']
-        current_provider = user[:provider]
+        current_user                      = user[:info]['nickname']  = user[:info]['nickname']
+        current_provider                  = user[:provider]
 
         j1_web_session['requested_page'].scan(/(private|premium)/) do |match|
           category = match[0]
           unless j1_web_session['users_allowed'].include? 'all'
             unless j1_web_session['users_allowed'].include? "#{current_user}"
-              logger.info "AFTER AUTHENTICATION: User #{current_user} not allowed. Allowed users: #{j1_web_session['users_allowed']}"
+              log_info! 'Authentication', 'Callback', 'User not allowed', "#{current_user}"
+              log_info! 'Authentication', 'Callback', 'Allowed users', "#{j1_web_session['users_allowed']}"
               warden.logout
               session.clear
-              logger.info "AFTER AUTHENTICATION: User #{current_user} signed out."
+              log_info! 'Authentication', 'Callback', 'User signed out', "#{current_user}"
               redirect "/access_denied?provider=#{current_provider}&user=#{current_user}&category=#{category}"
             end
           end
         end
-      else
-        # Collection of session data failed (e.g cookie > 4K)
-        #
-        logger.info "AFTER AUTHENTICATION: Internal error, user authentication failed.}"
-        warden.logout
-        session.clear
-        redirect "/access_denied?provider=unknown&user=unknown&category=unknown"
+
       end
 
       j1_web_session['provider']      = current_provider
-      j1_web_session['users_allowed'] = users["#{current_provider}"]
+      j1_web_session['users_allowed'] = providers["#{current_provider}"]['users']
 
       if j1_web_session['requested_page'] == '/'
         category = 'any protected content'
         unless j1_web_session['users_allowed'].include? 'all'
           unless j1_web_session['users_allowed'].include? "#{current_user}"
-            logger.info "AFTER AUTHENTICATION: User #{current_user} not allowed. Allowed users: #{j1_web_session['users_allowed']}"
+            log_info! 'Authentication', 'Callback', 'User not allowed', "#{current_user}"
+            log_info! 'Authentication', 'Callback', 'Allowed users', "#{j1_web_session['users_allowed']}"
             warden.logout
             session.clear
-            logger.info "AFTER AUTHENTICATION: User #{current_user} signed out."
+            log_info! 'Authentication', 'Callback', 'User signed out', "#{current_user}"
             redirect "/access_denied?provider=#{current_provider}&user=#{current_user}&category=#{category}"
           end
         end
@@ -627,9 +768,9 @@ module J1App
       # write updated J1 session data to cookie
       #
       session_json = j1_web_session.to_json
+      log_info! 'Authentication', 'Callback', 'Write J1 web session data to cookie' # "#{session_json}"
+
       session_encoded = Base64.encode64(session_json)
-      logger.info "AFTER AUTHENTICATION: Write J1 web session data to cookie"
-      #logger.info "AFTER AUTHENTICATION: Write J1 web session data as: #{session_json}"
       response.set_cookie(
           'j1.web.session',
           domain: false,
@@ -639,62 +780,82 @@ module J1App
 
       # redirect to requested page
       #
-      logger.info "AFTER AUTHENTICATION: Signed in at provider #{user[:provider]} as user: #{user[:info]['nickname']}"
-      logger.info "AFTER AUTHENTICATION: Redirect to requested page:  #{j1_web_session['requested_page']}"
+      log_info! 'Authentication', 'Callback', 'Signed in at provider', "#{user[:provider]}"
+      log_info! 'Authentication', 'Callback', 'Signed in as user', "#{user[:info]['nickname']}"
+      log_info! 'Authentication', 'Callback', 'Requested page', "#{j1_web_session['requested_page']}"
       redirect j1_web_session['requested_page']
     end
 
     get '/redirect_requested_page' do
-      logger.info "AFTER AUTHENTICATION: Redirect to #{j1_web_session['requested_page']}"
+      log_info! 'Authentication', 'RedirectPage', 'Requested page', "#{j1_web_session['requested_page']}"
       redirect j1_web_session['requested_page']
     end
 
     # Status|Info ENDPOINT called from the web to get current state on an user
     # --------------------------------------------------------------------------
     get '/status' do
-      logger.info 'STATUS: info request detected'
-
-      session_encoded = request.cookies['j1.web.session']
-      session_decoded = Base64.decode64(session_encoded)
-      j1_web_session = JSON.parse(session_decoded)
+      log_info! 'Status', 'RestApi', 'Info request detected'
+      session_encoded   = request.cookies['j1.web.session']
+      session_decoded   = Base64.decode64(session_encoded)
+      j1_web_session    = JSON.parse(session_decoded)
 
       # if request.warden.user.respond_to?(:info)
       #
       if warden.authenticated?
-        user_json = warden.user.to_json
-        user = warden.user[:info]['nickname']
-        user_id = warden.user[:uid]
-        user_info = warden.user[:info]
-        provider = warden.user[:provider]
-        provider_permissions = j1_web_session['permissions']
-        # provider_permissions = J1App.get_provider_permissions "#{provider}"
-        logger.info "Detected #{user} as: signed in"
+        user_name               = warden.user[:info]['nickname']
+        user_id                 = warden.user[:uid]
+        provider                = warden.user[:provider]
+        provider_permissions    = j1_web_session['permissions']
+        provider_site_url       = warden.user[:info][:urls][:site]
+        provider_home_url       = warden.user[:info][:urls][:home]
+        provider_blog_url       = warden.user[:info][:urls][:blog]
+        provider_member_url     = warden.user[:info][:urls][:member]
+
+        if provider == 'patreon'
+          provider_membership   = warden.user[:extra][:reward][:name]
+          provider_member_url   = warden.user[:extra][:reward][:link]
+        else
+          provider_membership   = 'unknown'
+          provider_member_url   = 'javascript:void(0)'
+        end
+
+        log_info! 'Status', 'RestApi', 'User detected as signed in', "#{user_name}"
       else
-        user = 'unknown'
-        logger.info 'STATUS: detected user as: signed out'
+        user_name = 'unknown'
+        log_info! 'Status', 'RestApi', 'User detected', 'signed out'
       end
 
       # if request.warden.authenticated?
       #
-      if user != 'unknown'
-        logger.info 'STATUS: send SIGNED_IN data'
+      if user_name != 'unknown'
+        log_info! 'Status', 'RestApi', 'Send data for', 'SIGNED_IN'
         content_type 'application/json'
         {
-            provider:     provider,
-            user:         user,
-            user_id:      user_id,
-            permissions:  provider_permissions,
-            status:       'signed in'
+            user_name:                user_name,
+            user_id:                  user_id,
+            provider:                 provider,
+            provider_membership:      provider_membership,
+            provider_permissions:     provider_permissions,
+            provider_site_url:        provider_site_url,
+            provider_home_url:        provider_home_url,
+            provider_blog_url:        provider_blog_url,
+            provider_member_url:      provider_member_url,
+            status:                   'signed in'
         }.to_json
       else
-        logger.info 'STATUS: send SIGNED_OUT data'
+        log_info! 'Status', 'RestApi', 'Send data for', 'SIGNED_OUT'
         content_type 'application/json'
         {
-            provider:     'unknown',
-            user:         'unknown',
-            user_id:      'unknown',
-            permissions:  'unknown',
-            status:       'signed out'
+            user_name:                'unknown',
+            user_id:                  'unknown',
+            provider:                 'unknown',
+            provider_membership:      'unknown',
+            provider_permissions:     'unknown',
+            provider_site_url:        'javascript:void(0)',
+            provider_home_url:        'javascript:void(0)',
+            provider_blog_url:        'javascript:void(0)',
+            provider_member_url:      'javascript:void(0)',
+            status:                   'signed out'
         }.to_json
       end
     end
@@ -703,13 +864,13 @@ module J1App
     # --------------------------------------------------------------------------
     get '/access_denied' do
 
-      provider      =  params.fetch('provider')
-      category      =  params.fetch('category')
-      user          =  params.fetch('user')
+      provider        =  params.fetch('provider')
+      category        =  params.fetch('category')
+      user            =  params.fetch('user')
 
       session_encoded = request.cookies['j1.web.session']
       session_decoded = Base64.decode64(session_encoded)
-      j1_web_session = JSON.parse(session_decoded)
+      j1_web_session  = JSON.parse(session_decoded)
 
       # Update J1 web session data
       # --------------------------------------------------------------------
@@ -725,10 +886,13 @@ module J1App
 
       # write updated J1 session data to cookie
       #
+
+      log_info! "AccessControl", 'RestApi', 'Exception', 'Access Denied'
+
       session_json = j1_web_session.to_json
+      log_info! "AccessControl", 'RestApi', 'Write J1 web session data to cookie' # "#{session_json}"
+
       session_encoded = Base64.encode64(session_json)
-      logger.info "ACCESS DENIED: Write J1 web session data to cookie"
-#     logger.info "ACCESS DENIED: Write J1 web session data as: #{session_json}"
       response.set_cookie(
           'j1.web.session',
           domain: false,
@@ -738,6 +902,9 @@ module J1App
 
       route = '/'
 
+      # Capitalize first char
+      provider                =  provider.sub(/^./, &:upcase) 
+
       @route                  = route
       @provider               = provider
       @modal                  = "centralModalInfo"
@@ -748,17 +915,19 @@ module J1App
       @modal_description      = "<h4>Access denied</h4></br></br> User <b>#{user}</b> from provider <b>#{provider}</b> is not allowed to access <b>#{category}</b> pages."
 
       erb :auth_manager_ui
-
     end
 
     # access_protected_content ENDPOINT called from the app (auth manager)
     # --------------------------------------------------------------------------
     get '/access_protected_content' do
 
-      provider      =  params.fetch('provider')
-      allowed_users =  params.fetch('allowed_users')
-      page          =  params.fetch('page')
-      category      =  params.fetch('category')
+      provider        =  params.fetch('provider')    
+      allowed_users   =  params.fetch('allowed_users')
+      page            =  params.fetch('page')
+      category        =  params.fetch('category')
+
+      # Capitalize first char
+      # provider        =  provider.sub(/^./, &:upcase) 
 
       if warden.authenticated?
         route = page
@@ -766,13 +935,16 @@ module J1App
         route = "/authentication?request=signin&provider=#{provider}&allowed_users=#{allowed_users}"
       end
 
+      # Capitalize first char
+      provider                =  provider.sub(/^./, &:upcase)
+
       @provider               = provider
       @route                  = route
       @modal                  = "signInProtectedContent"
       @modal_icon             = "login"
       @modal_agreed_text      = "Yes, please"
       @modal_disagreed_text   = "No, thanks"
-      @modal_title            = "Authentication Manager"
+      @modal_title            = "SignIn"
       @modal_image            = "/assets/images/master_header/admin-dashboard-bootstrap-1280x600.png"
       @modal_description      = "The page <b>#{page}</b> you requested belongs to <b>#{category}</b> content. You'll be redirected to authenticate with the provider <b>#{provider}</b>. If signed in successfully, you get access to all <b>#{category} pages</b>."