j1_template_mde 2018.4.10

data/lib/j1/utils/ansi.rb

@@ -0,0 +1,59 @@
+# Frozen-string-literal: true
+# Copyright: 2015 Jekyll - MIT License
+# Encoding: utf-8
+
+module J1
+  module Utils
+    module Ansi
+      extend self
+
+      ESCAPE = format("%c", 27)
+      MATCH = %r!#{ESCAPE}\[(?:\d+)(?:;\d+)*(j|k|m|s|u|A|B|G)|\e\(B\e\[m!ix
+      COLORS = {
+        :red     => 31,
+        :green   => 32,
+        :black   => 30,
+        :magenta => 35,
+        :yellow  => 33,
+        :white   => 37,
+        :blue    => 34,
+        :cyan    => 36,
+      }.freeze
+
+      # Strip ANSI from the current string.  It also strips cursor stuff,
+      # well some of it, and it also strips some other stuff that a lot of
+      # the other ANSI strippers don't.
+
+      def strip(str)
+        str.gsub MATCH, ""
+      end
+
+      #
+
+      def has?(str)
+        !!(str =~ MATCH)
+      end
+
+      # Reset the color back to the default color so that you do not leak any
+      # colors when you move onto the next line. This is probably normally
+      # used as part of a wrapper so that we don't leak colors.
+
+      def reset(str = "")
+        @ansi_reset ||= format("%c[0m", 27)
+        "#{@ansi_reset}#{str}"
+      end
+
+      # SEE: `self::COLORS` for a list of methods.  They are mostly
+      # standard base colors supported by pretty much any xterm-color, we do
+      # not need more than the base colors so we do not include them.
+      # Actually... if I'm honest we don't even need most of the
+      # base colors.
+
+      COLORS.each do |color, num|
+        define_method color do |str|
+          "#{format("%c", 27)}[#{num}m#{str}#{reset}"
+        end
+      end
+    end
+  end
+end

data/lib/j1/utils/exec.rb

@@ -0,0 +1,25 @@
+require "open3"
+
+module J1
+  module Utils
+    module Exec
+      extend self
+
+      # Runs a program in a sub-shell.
+      #
+      # *args - a list of strings containing the program name and arguments
+      #
+      # Returns a Process::Status and a String of output in an array in
+      # that order.
+      def run(*args)
+        stdin, stdout, stderr, process = Open3.popen3(*args)
+        out = stdout.read.strip
+        err = stderr.read.strip
+
+        [stdin, stdout, stderr].each(&:close)
+        [process.value, out + err]
+      end
+
+    end
+  end
+end

data/lib/j1/utils/platforms.rb

@@ -0,0 +1,80 @@
+module J1
+  module Utils
+    module Platforms
+      extend self
+
+      # Provides jruby? and mri? which respectively detect these two types of
+      # tested Engines we support, in the future we might probably support the
+      # other one that everyone used to talk about.
+
+      { :jruby? => "jruby", :mri? => "ruby" }.each do |k, v|
+        define_method k do
+          ::RUBY_ENGINE == v
+        end
+      end
+
+      # --
+      # Allows you to detect "real" Windows, or what we would consider
+      # "real" Windows.  That is, that we can pass the basic test and the
+      # /proc/version returns nothing to us.
+      # --
+
+      def vanilla_windows?
+        RbConfig::CONFIG["host_os"] =~ %r!mswin|mingw|cygwin!i && \
+          !proc_version
+      end
+
+      # --
+      # XXX: Remove in 4.0
+      # --
+
+      alias_method :really_windows?, \
+        :vanilla_windows?
+
+      #
+
+      def bash_on_windows?
+        RbConfig::CONFIG["host_os"] =~ %r!linux! && \
+          proc_version =~ %r!microsoft!i
+      end
+
+      #
+
+      def windows?
+        vanilla_windows? || bash_on_windows?
+      end
+
+      #
+
+      def linux?
+        RbConfig::CONFIG["host_os"] =~ %r!linux! && \
+          proc_version !~ %r!microsoft!i
+      end
+
+      # Provides windows?, linux?, osx?, unix? so that we can detect
+      # platforms. This is mostly useful for `jekyll doctor` and for testing
+      # where we kick off certain tests based on the platform.
+
+      { :osx? => %r!darwin|mac os!, :unix? => %r!solaris|bsd! }.each do |k, v|
+        define_method k do
+          !!(
+            RbConfig::CONFIG["host_os"] =~ v
+          )
+        end
+      end
+
+      #
+
+      private
+      def proc_version
+        @cached_proc_version ||= begin
+          Pathutil.new(
+            "/proc/version"
+          ).read
+        rescue Errno::ENOENT
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/j1/utils/win_tz.rb

@@ -0,0 +1,73 @@
+module J1
+  module Utils
+    module WinTZ
+      extend self
+
+      # Public: Calculate the Timezone for Windows when the config file has a defined
+      #         'timezone' key.
+      #
+      # timezone - the IANA Time Zone specified in "_config.yml"
+      #
+      # Returns a string that ultimately re-defines ENV["TZ"] in Windows
+      def calculate(timezone)
+        External.require_with_graceful_fail("tzinfo")
+        tz = TZInfo::Timezone.get(timezone)
+        difference = Time.now.to_i - tz.now.to_i
+        #
+        # POSIX style definition reverses the offset sign.
+        #   e.g. Eastern Standard Time (EST) that is 5Hrs. to the 'west' of Prime Meridian
+        #   is denoted as:
+        #     EST+5 (or) EST+05:00
+        # Reference: http://www.gnu.org/software/libc/manual/html_node/TZ-Variable.html
+        sign = difference < 0 ? "-" : "+"
+        offset = sign == "-" ? "+" : "-" unless difference.zero?
+        #
+        # convert the difference (in seconds) to hours, as a rational number, and perform
+        # a modulo operation on it.
+        modulo = modulo_of(rational_hour(difference))
+        #
+        # Format the hour as a two-digit number.
+        # Establish the minutes based on modulo expression.
+        hh = format("%02d", absolute_hour(difference).ceil)
+        mm = modulo.zero? ? "00" : "30"
+
+        J1l.logger.debug "Timezone:", "#{timezone} #{offset}#{hh}:#{mm}"
+        #
+        # Note: The 3-letter-word below doesn't have a particular significance.
+        "WTZ#{sign}#{hh}:#{mm}"
+      end
+
+      private
+
+      # Private: Convert given seconds to an hour as a rational number.
+      #
+      # seconds - supplied as an integer, it is converted to a rational number.
+      # 3600 - no. of seconds in an hour.
+      #
+      # Returns a rational number.
+      def rational_hour(seconds)
+        seconds.to_r/3600
+      end
+
+      # Private: Convert given seconds to an hour as an absolute number.
+      #
+      # seconds - supplied as an integer, it is converted to its absolute.
+      # 3600 - no. of seconds in an hour.
+      #
+      # Returns an integer.
+      def absolute_hour(seconds)
+        seconds.abs/3600
+      end
+
+      # Private: Perform a modulo operation on a given fraction.
+      #
+      # fraction - supplied as a rational number, its numerator is divided
+      #            by its denominator and the remainder returned.
+      #
+      # Returns an integer.
+      def modulo_of(fraction)
+        fraction.numerator % fraction.denominator
+      end
+    end
+  end
+end

data/lib/j1/version.rb

@@ -0,0 +1,3 @@
+module J1
+  VERSION = '2018.4.10'
+end

data/lib/j1_app.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+# NOTES
+# ------------------------------------------------------------------------------
+# frozen_string_literal
+#
+# frozen_string_literal implies that all string literals in the file
+# are implicitly frozen, as if #freeze had been called on each of them.
+# That is, if a string literal is defined in a file with this comment, and
+# you call a method on that string which modifies it, such as <<, you'll
+# get RuntimeError: can't modify frozen String.
+
+# Require RubyGems
+# ------------------------------------------------------------------------------
+require 'active_support'
+require 'active_support/core_ext'
+
+require 'dotenv'
+require 'json'
+require 'safe_yaml'
+
+require 'puma'
+
+require 'rack'
+require 'omniauth'
+require 'omniauth-oauth2'
+require 'sinatra'
+require 'warden'
+
+# Require local Rubies
+# ------------------------------------------------------------------------------
+require_relative 'j1_app/sinatra/extras/cookies'
+require_relative 'j1_app/sinatra/extras/index'
+
+require_relative 'j1_app/omniauth/strategies/patreon'
+require_relative 'j1_app/omniauth/strategies/disqus'
+require_relative 'j1_app/omniauth/strategies/facebook'
+require_relative 'j1_app/omniauth/strategies/github'
+require_relative 'j1_app/omniauth/strategies/twitter'
+
+require_relative 'j1_app/j1_auth_manager/commands'
+require_relative 'j1_app/j1_auth_manager/config'
+require_relative 'j1_app/j1_auth_manager/helpers'
+require_relative 'j1_app/j1_auth_manager/helpers_disqus'
+require_relative 'j1_app/j1_auth_manager/helpers_facebook'
+require_relative 'j1_app/j1_auth_manager/helpers_github'
+require_relative 'j1_app/j1_auth_manager/helpers_patreon'
+require_relative 'j1_app/j1_auth_manager/helpers_twitter'
+require_relative 'j1_app/j1_auth_manager/warden_omniauth'
+
+require_relative 'j1_app/j1_auth_manager/auth_manager'
+require_relative 'j1_app/j1_site_manager/static_site'
+
+# Load initial data
+# ------------------------------------------------------------------------------
+# noinspection RubyArgCount
+Dotenv.load
+
+# Main
+# ------------------------------------------------------------------------------
+module J1App
+  def self.site
+    Rack::Builder.new do
+      use Rack::ShowExceptions                                                  # Middleware. Generate web-based error pages (for Rack)
+      use J1App::AuthManager                                                    # Middleware. Support authentication methods using OmniAuth
+      run J1App::SiteManager                                                    # Run J1App Manager to manage the (static) site as an (Rack-based) Web Application:
+    end
+  end
+end

data/lib/j1_app/j1_auth_manager/auth_manager.rb

@@ -0,0 +1,418 @@
+# frozen_string_literal: true
+
+module J1App
+  class AuthManager < Sinatra::Base
+
+    include J1App::Helpers
+
+
+    # ==========================================================================
+    # Base App and Framework settings
+    # ==========================================================================
+
+    j1_web_session = {
+        'authenticated'   => 'unknown',
+        'requested_page'  => '/',
+        'user_name'       => 'unknown',
+        'user_id'         => 'unknown',
+        'user_details'    => 'unknown',
+        'user_pledges'    => 'unknown',
+        'provider'        => 'unknown',
+        'provider_url'    => '/',
+        'writer'          => 'middleware'
+    }
+
+    # Enable SSL for the rack session if configured
+    # --------------------------------------------------------------------------
+    configure :production do
+      require 'rack-ssl-enforcer'
+      use Rack::SslEnforcer if J1App.ssl?
+    end
+
+    # Set the session cookie used by Rack to track all relevant data
+    # for the authentication service
+    # --------------------------------------------------------------------------
+    use Rack::Session::Cookie,
+        http_only: true,
+        key: 'j1.app.session',
+        secret: ENV['J1_SESSION_SECRET'] || SecureRandom.hex
+
+
+    # ==========================================================================
+    # Warden Framework initialisation
+    # ==========================================================================
+
+    # Define what (user) data should be put (serialized) into the session
+    # on requests and responses from Rack environment into the warden
+    # environment (env['warden']).
+    # --------------------------------------------------------------------------
+    Warden::Manager.serialize_into_session do |user|
+      user
+    end
+    Warden::Manager.serialize_from_session do |user|
+      user
+    end
+
+
+    # ==========================================================================
+    # OmniAuth|Warden Framework initialisation
+    # ==========================================================================
+
+    # Set the 'default' authentication strategy and exception handler
+    # (for warden) if the user was not explicitly signed in (signin dialog).
+    # If 'signin' fails, the default exception 'signin_failure' is thrown
+    # (used for all OmniAuth strategies registered).
+    # --------------------------------------------------------------------------
+    signin_failure = ->(_e) { Rack::Response.new("Can't login", 401).finish }
+    use Warden::Manager do |config|
+      # OmniAuth strategies are name-spaced by 'omni' (see: warden_omniauth.rb)
+      # ------------------------------------------------------------------------
+      config.default_strategies :"omni_#{J1App.default_provider}"
+      config.failure_app = signin_failure
+    end
+
+    use OmniAuth::Builder do |config|
+      # Workaround to rescue OmniAuth::Strategies::OAuth2::CallbackError?
+      # for chromium based browsers (e.g. google-chrome)
+      # ------------------------------------------------------------------------
+      config.on_failure do
+        new_path = '/redirect_requested_page'
+        Rack::Response.new(['302 Moved'], 302, 'Location' => new_path).finish
+      end
+
+      # Detect and set supported authentication strategies for OmniAuth
+      # ------------------------------------------------------------------------
+      if J1App.provider.include? 'patreon'
+        scope = J1App.provider_scope 'patreon'
+        provider :patreon,
+           ENV['PATREON_CLIENT_ID'],
+           ENV['PATREON_CLIENT_SECRET'],
+           scope: "#{scope}"
+      end
+      if J1App.provider.include? 'disqus'
+        scope = J1App.provider_scope 'disqus'
+        provider :disqus,
+           ENV['DISQUS_CLIENT_ID'],
+           ENV['DISQUS_CLIENT_SECRET'],
+           scope: "#{scope}"
+      end
+      if J1App.provider.include? 'facebook'
+        scope = J1App.provider_scope 'facebook'
+        provider :facebook,
+           ENV['FACEBOOK_CLIENT_ID'],
+           ENV['FACEBOOK_CLIENT_SECRET'],
+           scope: "#{scope}"
+      end
+      if J1App.provider.include? 'github'
+        scope = J1App.provider_scope 'github'
+        provider :github,
+           ENV['GITHUB_CLIENT_ID'],
+           ENV['GITHUB_CLIENT_SECRET'],
+           scope: "#{scope}"
+      end
+      if J1App.provider.include? 'twitter'
+        scope = J1App.provider_scope 'twitter'
+        provider :twitter,
+           ENV['TWITTER_CLIENT_ID'],
+           ENV['TWITTER_CLIENT_SECRET'],
+           scope: "#{scope}"
+      end
+    end
+
+    # Set the (internal) endpoint if a user is successfully authenticated
+    # --------------------------------------------------------------------------
+    use J1WardenOmniAuth do |config|
+      config.redirect_after_callback = '/redirect_after_callback'
+    end
+
+    # Add the internal logger from Rack to the middleware's of the stack
+    # --------------------------------------------------------------------------
+    use Rack::Logger
+
+
+    # ==========================================================================
+    # Sinatra (before) FILTER to preprocess all page requests
+    # ==========================================================================
+
+    # Check auth status for content of type "pages"
+    # --------------------------------------------------------------------------
+    before '/pages/*' do
+
+      # read existing/current cookie 'j1.web.session'
+      # to update all data of j1_web_session (hash)
+      # 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: read J1 web session data as: #{session_decoded}"
+        j1_web_session = JSON.parse(session_decoded)
+      else
+        requested_page = env['REQUEST_URI']
+        j1_web_session['requested_page'] = "#{env['REQUEST_URI']}"
+      end
+
+      # Create|Initialize the J1 web session cookie
+      # ------------------------------------------------------------------------
+      j1_web_session['authenticated'] = warden.authenticated? ? 'true' : 'false'
+      session_json = j1_web_session.to_json
+      session_encoded = Base64.encode64(session_json)
+      response.set_cookie(
+          'j1.web.session',
+          domain: false,
+          value: session_encoded.to_s,
+          path: '/'
+      )
+
+      # Content and user detection schema (page and authentication logic)
+      # ------------------------------------------------------------------------
+      #
+      # j1_web_session['provider_url']    = J1App.provider_url warden.user[:provider]
+
+      if warden.authenticated?
+        my_provider                     = warden.user[:provider]
+        provider_url                    = J1App.provider_url my_provider
+        j1_web_session['provider_url']  = provider_url
+      end
+
+      pass if authentication_enabled? == false
+      pass if public_content?
+      pass if warden.authenticated?
+
+      logger.info "STRATEGY: #{authentication_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."
+        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."
+        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."
+        when :member
+          logger.info 'STRATEGY: go for authentication'
+
+        # Set selected page for redirect
+        # ----------------------------------------------------------------------
+        logger.info "STRATEGY: set redirect to: #{j1_web_session['requested_page']}"
+        #j1_web_session['provider_url']    = J1App.provider_url warden.user[:provider]
+        j1_web_session['requested_page']  = env['REQUEST_URI']
+        j1_web_session['writer']          = 'middleware'
+        # write updated J1 session cookie
+        # session_json = j1_web_session.to_json
+        # session_encoded = Base64.encode64(session_json)
+        # logger.info "STRATEGY: write J1 web session data as: #{session_json}"
+        # response.set_cookie('j1.web.session', value: session_encoded.to_s)        
+        warden.authenticate!
+
+      else
+        raise J1App::ConfigError
+      end
+
+    end
+
+
+    # ==========================================================================
+    # APP|API ENDPOINTS (Sinatra HANDLERS)
+    # ==========================================================================
+
+    # Authentication ENDPOINT called from the web (auth client)
+    # --------------------------------------------------------------------------
+    get '/authentication' do
+      # collect (common) GET parameter|s
+      #
+      request  =  params.fetch('request')
+      provider =  params.fetch('provider')
+
+      if request === 'signin'
+        if warden.authenticated?
+          logger.info "SIGNIN: #{warden.user[:info]['nickname']} already signed in"
+        else
+          logger.info "SIGNIN: going for signing in at: #{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']}"
+        redirect j1_web_session['requested_page']
+      elsif request === 'signout'
+        # collect (additional) GET parameter|s
+        # ----------------------------------------------------------------------
+        provider_signout = params.fetch('provider_signout')
+
+        if warden.authenticated?
+          user         = warden.user[:info]['nickname']
+          provider     = warden.user[:provider]
+          provider_url = j1_web_session['provider_url']
+          warden.logout
+          session.clear
+
+          # Read current J1 web 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 "SIGNOUT: read J1 web session data as: #{session_decoded}"
+            j1_web_session = JSON.parse(session_decoded)
+          else
+            j1_web_session['requested_page'] = env['REQUEST_URI']
+          end
+
+          # Update J1 web session data
+          # --------------------------------------------------------------------
+          j1_web_session['user_name']     = 'unknown'
+          j1_web_session['user_id']       = 'unknown'
+          j1_web_session['user_details']  = 'unknown'
+          j1_web_session['user_pledges']  = 'unknown'
+          j1_web_session['provider']      = 'unknown'
+          j1_web_session['provider_url']  = 'unknown'
+          j1_web_session['authenticated'] = 'false'
+          j1_web_session['writer']        = 'middleware'
+
+          # Write updated J1 session data to cookie
+          # --------------------------------------------------------------------
+          session_json = j1_web_session.to_json
+          session_encoded = Base64.encode64(session_json)
+          response.set_cookie('j1.web.session', value: session_encoded.to_s)
+
+          if provider_signout === 'true'
+            logger.info "SIGNOUT: for #{user} completely at provider: #{provider}"
+            redirect "#{provider_url}"
+          else
+            logger.info "SIGNOUT: for #{user} from current session at provider: #{provider}"
+            if redirect_whitelisted?j1_web_session['requested_page']
+              logger.info 'SIGNOUT: redirect whitelisted'
+              logger.info "SIGNOUT: redirect to #{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: /'
+              redirect '/'
+            end
+          end
+        else
+          # THIS condition should NEVER REACHED because NO logout dialog
+          # (modal) is provided by the auth client if a user isn't signed in.
+          # Kept this alternative for cases something went wrong.
+          # --------------------------------------------------------------------
+          logger.info 'SIGNOUT: 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 "SIGNOUT: read J1 web session data as: #{session_decoded}"
+            j1_web_session = JSON.parse(session_decoded)
+          else
+            j1_web_session['requested_page'] = env['REQUEST_URI']
+          end
+
+          # Update J1 web session data
+          # --------------------------------------------------------------------
+          j1_web_session['user_name']     = 'unknown'
+          j1_web_session['user_id']       = 'unknown'
+          j1_web_session['user_details']  = 'unknown'
+          j1_web_session['user_pledges']  = 'unknown'
+          j1_web_session['provider']      = 'unknown'
+          j1_web_session['provider_url']  = 'unknown'
+          j1_web_session['authenticated'] = 'false'
+          j1_web_session['writer']        = 'middleware'
+
+          # Write updated J1 session data to cookie
+          # --------------------------------------------------------------------
+          session_json = j1_web_session.to_json
+          session_encoded = Base64.encode64(session_json)
+          response.set_cookie('j1.web.session', value: session_encoded.to_s)
+          logger.info "SIGNOUT: redirect to #{j1_web_session['requested_page']}"
+          redirect j1_web_session['requested_page']
+        end
+      else
+        raise J1App::ConfigError
+      end
+    end
+
+    # Post-processing ENDPOINT called after a user is authenticated
+    # --------------------------------------------------------------------------
+    get '/redirect_after_callback' do
+      user = warden.user
+
+      # update web session data
+      #
+      j1_web_session['user_name']       = user[:info]['nickname']
+      j1_web_session['user_id']         = user[:uid]
+      if user[:provider] == 'patreon'
+        j1_web_session['user_details']  = user[:extra]['raw_info']['data']['attributes']
+        j1_web_session['user_pledges']  = user[:extra]['raw_info']['data']['relationships']['pledges'] unless user[:extra]['raw_info']['data']['relationships'].nil?
+      end
+      j1_web_session['provider']        = user[:provider]
+      j1_web_session['authenticated']   = warden.authenticated? ? 'true' : 'false'
+      j1_web_session['writer']          = 'middleware'
+
+      # write updated J1 session data to cookie
+      #
+      session_json = j1_web_session.to_json
+      session_encoded = Base64.encode64(session_json)
+      logger.info "AFTER AUTHENTICATION: write J1 web session data as: #{session_json}"
+      response.set_cookie('j1.web.session', value: session_encoded.to_s)
+
+      # redirect to selected page
+      #
+      logger.info "AFTER AUTHENTICATION: redirect to #{j1_web_session['requested_page']}"
+      redirect j1_web_session['requested_page']
+    end
+
+    get '/redirect_requested_page' do
+      logger.info "REDIRECT REQUESTED PAGE: redirect to #{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'
+
+      # if request.warden.user.respond_to?(:info)
+      #
+      if warden.authenticated?
+        user = warden.user[:info]['nickname']
+        user_id = warden.user[:uid]
+        user_info = warden.user[:info]
+        provider = warden.user[:provider]
+        logger.info "Detected #{user} as: signed in"
+      else
+        user = 'unknown'
+        logger.info 'STATUS: detected user as: signed out'
+      end
+
+      # if request.warden.authenticated?
+      #
+      if user != 'unknown'
+        logger.info 'STATUS: send SIGNED_IN data'
+        content_type 'application/json'
+        {
+            provider:   provider,
+            user:       user,
+            user_id:    user_id,
+            status:     'signed in'
+        }.to_json
+      else
+        logger.info 'STATUS: send SIGNED_OUT data'
+        content_type 'application/json'
+        {
+            provider:   'unknown',
+            user:       'unknown',
+            user_id:    'unknown',
+            status:     'signed out'
+        }.to_json
+      end
+    end
+  end
+end