arcadedb 0.3.3 → 0.5.0

data/lib/arcade/base.rb

@@ -5,7 +5,7 @@ module Arcade
     # schema schema.strict    #  -- throws an error if  specified keys are missing
     transform_keys{ |x|  x[0] == '@' ? x[1..-1].to_sym : x.to_sym }
     # Types::Rid -->  only accept  #000:000,  raises an Error, if rid is not present
-    attribute :rid, Types::Rid
+    attribute :rid?, Types::Rid
     # maybe there are edges   ## removed in favour of instance methods
 #    attribute :in?, Types::Nominal::Any
 #    attribute :out?, Types::Nominal::Any
@@ -27,6 +27,16 @@ module Arcade
         self.name.snake_case
       end
 
+      def begin_transaction
+        db.begin_transaction
+      end
+      def  commit
+        db.commit
+      end
+      def rollback
+        db.rollback
+      end
+
       def create_type
         the_class = nil   # declare as local var
         parent_present = ->(cl){ db.hierarchy.flatten.include? cl }
@@ -41,12 +51,7 @@ module Arcade
           if the_class.respond_to?(:demodulize)
             if [ 'Document','Vertex', 'Edge'].include?(the_class.demodulize)
               if  the_class == superclass  # no inheritance
-                ## we have to use demodulize as the_class actually is Arcade::Vertex, ...
-                unless parent_present[ to_s.snake_case ]
                   db.create_type the_class.demodulize, to_s.snake_case
-                else
-                  db.logger.warn "Type #{ to_s.snake_case } is present, process skipped"
-                end
               else
                 if superclass.is_a? Class  #  maybe its a module.
                    extended = superclass.to_s.snake_case
@@ -72,10 +77,10 @@ module Arcade
           the_command =  command[0 .. -2]  #  remove '\n'
           next if the_command == ''
         #  db.logger.info "Custom Setup:: #{the_command}"
-          db.execute { the_command }
+          db.transmit { the_command }
         end unless custom_setup.nil?
 
-        rescue Arcade::RollbackError => e
+        rescue RollbackError => e
           db.logger.warn e
         rescue RuntimeError => e
           db.logger.warn e
@@ -123,9 +128,11 @@ module Arcade
       #        (not supported (jet): [RETURN <expression>] [FROM <query>] )
 
       def insert **attributes
-        db.insert type: database_name, **attributes
+        db.insert type: database_name, session_id: attributes.delete(:session_id), **attributes
       end
 
+      alias  create insert
+
       ## ----------------------------------------- create       ---------------------------------- ##
       #
       #  Adds a record to the database
@@ -133,21 +140,21 @@ module Arcade
       #  returns the model dataset
       #  ( depreciated )
 
-      def  create **attributes
-        Api.begin_transaction db.database
-        attributes.merge!( created: DateTime.now ) if timestamps
-        record = insert **attributes
-        Api.commit db.database
-        record
-      rescue QueryError => e
-        db.logger.error "Dataset NOT created"
-        db.logger.error "Provided Attributes: #{ attributes.inspect }"
-       #  Api.rollback db.database   --->  raises "transactgion not begun"
-      rescue  Dry::Struct::Error => e
-        Api.rollback db.database
-        db.logger.error "#{ rid } :: Validation failed, record deleted."
-        db.logger.error e.message
-      end
+     # def  create **attributes
+     #   s = Api.begin_transaction db.database
+     #   attributes.merge!( created: DateTime.now ) if timestamps
+     #   record = insert **attributes
+     #   Api.commit db.database, s
+     #   record
+     # rescue HTTPX::HTTPError => e
+     #   db.logger.error "Dataset NOT created"
+     #   db.logger.error "Provided Attributes: #{ attributes.inspect }"
+     #   Api.rollback db.database  # --->  raises "transactgion not begun"
+     # rescue  Dry::Struct::Error => e
+     #   Api.rollback db.database
+     #   db.logger.error "#{ rid } :: Validation failed, record deleted."
+     #   db.logger.error e.message
+     # end
 
       def count  **args
         command = "count(*)"
@@ -222,12 +229,11 @@ module Arcade
       # Finds the first matching record providing the parameters of a `where` query
       #  Strategie.find symbol: 'Still'
       #  is equivalent to
-      #  Strategie.all.find{|y| y.symbol == 'Still'
-      #  }
+      #  Strategie.all.find{|y| y.symbol == 'Still' }
       def find **args
-        f= where(**args).first
-        f= where( "#{ args.keys.first } like #{ args.values.first.to_or }" ).first if f.nil? || f.empty?
-        f
+        where(**args).first
+#        f= where( "#{ args.keys.first } like #{ args.values.first.to_or }" ).first if f.nil? || f.empty?
+#        f
       end
       # update returns a list of updated records
       #
@@ -278,14 +284,14 @@ module Arcade
                     end
         result= query( **( { kind: :upsert  }.merge statement ) ).execute do | answer|
           z=  answer[:"$current"] &.allocate_model(false)  #  do not autoload modelfiles
-          raise Arcade::LoadError "Upsert failed"   unless z.is_a?  Arcade::Base
+          raise LoadError "Upsert failed"   unless z.is_a?  Base
           z  #  return record
         end
       end
 
 
       def query **args
-        Arcade::Query.new( **{ from: self }.merge(args) )
+        Query.new( **{ from: self }.merge(args) )
       end
 
       # immutable support
@@ -332,7 +338,7 @@ module Arcade
     end
 
     def query **args
-      Arcade::Query.new( **{ from: rid }.merge(args) )
+      Query.new( **{ from: rid }.merge(args) )
     end
 
     # to JSON  controlls the serialisation of Arcade::Base Objects for the HTTP-JSON API
@@ -364,7 +370,7 @@ module Arcade
 
 		"<#{ self.class.to_s.snake_case }" + rid? ? "[#{ rid }]: " : " " + invariant_attributes.map do |attr, value|
 			v= case value
-				 when Arcade::Base
+				 when Base
 					 "< #{ self.class.to_s.snake_case }: #{ value.rid } >"
 				 when Array
            value.map{|x| x.to_s}
@@ -373,59 +379,85 @@ module Arcade
 				 end
 			"%s : %s" % [ attr, v]  unless v.nil?
 		end.compact.sort.join(', ') + ">".gsub('"' , ' ')
+
+    rescue TypeError => e
+      attributes
     end
 
-    alias to_s to_human
+
+    #  configure irb-output to to_human for all Arcade::Base-Objects
+    #
+    def inspect
+      to_human
+    end
+
+
+    def html_attributes
+      invariant_attributes
+    end
+
+    def in_and_out_attributes
+      _modul, _class =  self.class.to_s.split "::"
+      the_class =  _modul == 'Arcade' ? _class : self.class.to_s
+      the_attributes = { :"CLASS" => the_class, :"IN" => self.in.count, :"OUT" =>  self.out.count, :"RID" => rid  }
+    end
 
     def to_html  # iruby
+      in_and_out = ->(r) { "[#{r}] : {#{self.in.count}->}{->#{self.out.count }}"    }
+      the_rid =  rid? && rid != "0:0" ? in_and_out[rid] : ""
       _modul, _class =  self.class.to_s.split "::"
       the_class =  _modul == 'Arcade' ? _class : self.class.to_s
-      IRuby.display IRuby.html "<b style=\"color: #50953DFF\"><#{ the_class}</b>"
-      + rid? ? "[#{ rid }]: " : " " + invariant_attributes.map do |attr, value|
-        v= case value
-           when Arcade::Base
-             "< #{ self.class.to_s.snake_case }: #{ value.rid } >"
-           when Array
-             value.map{|x| x.to_s}
-           else
-             value.from_db
-           end
-        "%s : %s" % [ attr, v]  unless v.nil?
-      end.compact.sort.join(', ') + ">".gsub('"' , ' ')
+      #    the_attribute = ->(v) do
+      #      case v
+      #        when Base
+      #          "< #{ self.class.to_s.snake_case  }: #{ v.rid  } >"
+      #        when Array
+      #          v.map{|x| x.to_s}
+      #        else
+      #          v.to_s
+      #        end
+      #    end
+      #     last_part = invariant_attributes.map do |attr, value|
+      #       [ attr, the_attribute[value] ].join(": ")
+      #   end.join(', ') 
+
+      # IRuby.display( [IRuby.html("<span style=\"color: #50953DFF\"><b>#{the_class}</b><#{ the_class }</b>#{the_rid}</span><br/> ")  , IRuby.table(html_attributes) ] )
+      IRuby.display IRuby.html("<span style=\"color: #50953DFF\"><b>#{the_class}</b><#{ the_class }</b>#{the_rid}</span>< #{ html_attributes.map{|_,v|  v }.join(', ')  } >")
     end
 
+
     def update **args
-      Arcade::Query.new( from: rid , kind: :update, set: args).execute
+      Query.new( from: rid , kind: :update, set: args).execute
       refresh
     end
 
     # inserts or updates a embedded document
     def insert_document name, obj
-      value = if obj.is_a? Arcade::Document
+      value = if obj.is_a? Document
                 obj.to_json
               else
                 obj.to_or
               end
 #      if send( name ).nil? || send( name ).empty?
-        db.execute { "update #{ rid } set  #{ name } =  #{ value }" }.first[:count]
+        db.transmit { "update #{ rid } set  #{ name } =  #{ value }" }.first[:count]
 #      end
     end
 
     # updates a single property in an embedded document
     def update_embedded embedded, embedded_property, value
-      db.execute{ " update #{rid} set `#{embedded}`.`#{embedded_property}` =  #{value.to_or}" }
+      db.transmit { " update #{rid} set `#{embedded}`.`#{embedded_property}` =  #{value.to_or}" }
     end
 
     def update_list list, value
-      value = if value.is_a? Arcade::Document
+      value = if value.is_a? Document
                 value.to_json
               else
                 value.to_or
               end
       if send( list ).nil? || send( list ).empty?
-        db.execute { "update #{ rid } set  #{ list } =  [#{ value }]" }
+        db.transmit { "update #{ rid } set  #{ list } =  [#{ value }]" }
       else
-        db.execute { "update #{ rid } set  #{ list } += #{ value }" }
+        db.transmit { "update #{ rid } set  #{ list } += #{ value }" }
       end
       refresh
     end
@@ -433,14 +465,14 @@ module Arcade
     # updates a map  property ,  actually adds the key-value pair to the property
     def update_map m, key, value
       if send( m ).nil?
-        db.execute { "update #{ rid } set #{ m } = MAP ( #{ key.to_s.to_or } , #{ value.to_or } ) "  }
+        db.transmit { "update #{ rid } set #{ m } = MAP ( #{ key.to_s.to_or } , #{ value.to_or } ) "  }
       else
-        db.execute { "update #{ rid } set #{ m }.`#{ key.to_s }` = #{ value.to_or }" }
+        db.transmit { "update #{ rid } set #{ m }.`#{ key.to_s }` = #{ value.to_or }" }
       end
       refresh
     end
     def delete
-      response = db.execute { "delete from #{ rid }" }
+      response = db.transmit { "delete from #{ rid }" }
       true if response == [{ count: 1 }]
     end
     def == arg

data/lib/{config.rb → arcade/config.rb}

@@ -3,11 +3,11 @@ module Arcade
     extend Dry::Configurable
     # central place to initialize constants
     #
-    # ProjectRoot has to be a Pathname-Object
+    # ProjectRoot should to be a Pathname-Object and has to be defined before `arcadedb`  is required
     #
     #puts "expand: #{File.expand_path(__dir__)}"
-    unless Arcade.const_defined?( :ProjectRoot )
-      Arcade::ProjectRoot = if defined?( Rails.env )
+    unless Object.const_defined?( :ProjectRoot )
+      ::ProjectRoot = if defined?( Rails.env )
                               Rails.root
                             else
                               STDERR.puts "Using default (arcadedb gem)  database credentials and settings"
@@ -15,10 +15,9 @@ module Arcade
                               Pathname.new(  File.expand_path( "../../", __FILE__ ))
       end
     else
-      STDERR.puts "Using provided database credentials and settings fron #{Arcade::ProjectRoot}"
+      STDERR.puts "Using provided database credentials and settings from #{::ProjectRoot}"
     end
 
-
     # initialised a hash  { environment => property }
     setting :username, default: :user,      reader: true,
       constructor:  ->(v) { yml(:environment).map{|x,y|  [x , y[v.to_s]] }.to_h }
@@ -48,17 +47,19 @@ module Arcade
     setting :namespace, default:  :namespace, reader: true , constructor:  ->(v) { yml(v) }
     setting :secret, reader: true,  default: 12, constructor:  ->(v) { seed(v) }
      private
-    # if a config dir exists, use it
+     # if a config dir exists, use it.
+     # Standard:  ProjectRoot/config.yml
      def self.config_file
-       if @cd.nil?
-         ( cd =  ProjectRoot + 'arcade.yml' ).exist? ||
-         ( cd =  ProjectRoot + 'config' + 'arcade.yml' ).exist? ||
-         ( cd =  ProjectRoot + "config.yml" )
-          @cd = cd
-       else
-         @cd
+
+       configdir =  -> do
+         pr =  ::ProjectRoot.is_a?(Pathname)?  ::ProjectRoot : Pathname.new( ::ProjectRoot )
+         ( cd =  pr + 'arcade.yml' ).exist? || ( cd =   pr + 'config' + 'arcade.yml' ).exist? || ( cd =   pr + 'config.yml' )
+         cd
        end
+
+       @cd ||= configdir[]
      end
+
     def self.yml key=nil
       y= YAML::load_file( config_file )
       key.nil?  ?  y : y[key]

data/lib/arcade/database.rb

@@ -17,12 +17,12 @@ module Arcade
     defines :environment
 
     def initialize  environment=:development
-      self.class.configure_logger( Config.logger ) 
-      @connection =  connect environment
+      self.class.configure_logger( Config.logger )
       if self.class.environment.nil?    # class attribute is set on the first call
                                         # further instances of Database share the same environment
         self.class.environment  environment
       end
+      @session_id = nil #  declare session_id
       self.class.namespace  Object.const_get( Config.namespace )
     end
 
@@ -39,20 +39,19 @@ module Arcade
     #
     def types refresh=false
       #  uses API
-      if $types.nil? || refresh
-       $types = Api.query(database, "select from schema:types"   )
-                   .map{ |x| x.transform_keys &:to_sym     }   #  symbolize keys
-                   .map{ |y| y.delete_if{|_,b,| b.empty? } }   #  eliminate  empty entries
+      if @types.nil? || refresh
+       @types = Api.query(database, "select from schema:types"   )
+                   .map{ |y| y.delete_if{|_,b,| b.blank? } }   #  eliminate  empty entries
       end
-      $types
-      ## upom startup, this is the first access to the database-server
+      @types
+      ## upon startup, this is the first access to the database-server
     rescue NoMethodError => e
       logger.fatal "Could not read Database Types. \n Is the database running?"
       Kernel.exit
     end
 
-    def indexes
-      DB.types.find{|x| x.key? :indexes }[:indexes]
+    def indexes refresh=false
+      types(refresh).find_all{|x| x.key? :indexes }.map{|y| y[:indexes]}.flatten
     end
 
     # ------------ hierarchy -------------
@@ -108,23 +107,56 @@ module Arcade
           "create edge type #{type} "
         end.concat( args.map{|x,y| "#{x} #{y} "}.join)
       end
-      db= Api.execute database, &exe
+      dbe= Api.execute database, &exe
       types( true )  # update cached schema
-      db
-
-    rescue Arcade::QueryError
-      Arcade::Database.logger.warn "Database type #{type} already present"
+      dbe
+
+    rescue Arcade::QueryError => e
+       if e.message  =~/Type\s+.+\salready\s+exists/
+        Arcade::Database.logger.debug "Database type #{type} already present"
+       else
+         raise
+       end
     end
 
     alias create_class create_type
 
     # ------------ drop type  -----------
     #  delete any record prior to the attempt to drop a type.
-    #  The `unsafe` option is nit implemented.
+    #  The `unsafe` option is not implemented.
     def drop_type  type
       Api.execute database, "drop type #{type} if exists"
     end
 
+    # ------------------------------  transaction ----------------------------------------------------- #
+    #  Encapsulates simple transactions
+    #
+    #  nested transactions are not supported.
+    #  * use the low-leve api.begin_tranaction for that purpose
+    #  * reuses an existing transaction
+    #
+    def begin_transaction
+      @session_id ||= Api.begin_transaction database
+    end
+    # ------------------------------  commit      ----------------------------------------------------- #
+    def commit
+     r = Api.commit( database, session_id: session)
+      @session_id = nil
+     true if r == 204
+     end
+
+    # ------------------------------  rollback    ----------------------------------------------------- #
+    #
+    def  rollback
+     r = Api.rollback( database, session_id: session)
+     @session_id = nil
+     true if r == 500
+    rescue HTTPX::HTTPError => e
+      raise
+     end
+
+
+
     # ------------ create  -----------
     # returns an rid of the successfully  created vertex or document
     #
@@ -136,21 +168,34 @@ module Arcade
     #
     def create type, **params
       #  uses API
-      Api.create_document database, type,  **params
+      Api.create_document database, type,  session_id: session, **params
     end
 
+    # ------------------------------  insert     ------------------------------------------------------ #
+    #
+    # translates the given parameters to
+    # INSERT INTO [TYPE:]<type>|BUCKET:<bucket>|INDEX:<index>
+    #   [(<field>[,]*) VALUES (<expression>[,]*)[,]*]|
+    #   [CONTENT {<JSON>}|[{<JSON>}[,]*]]
+    #
+    #   :from and :return are not supported
+    #
+    # If a transaction is active, the insert is executed in that context.
+    # Nested transactions are not supported
     def insert  **params
 
-      content_params = params.except( :type, :bucket, :index, :from, :return )
+      content_params = params.except( :type, :bucket, :index, :from, :return, :session_id )
       target_params = params.slice( :type, :bucket, :index )
+#      session_id = params[:session_id]   # extraxt session_id  --> future-use? 
       if  target_params.empty?
-        logger.error "Could not insert: target mising (type:, bucket:, index:)"
+        raise "Could not insert: target missing (type:, bucket:, index:)"
       elsif content_params.empty?
         logger.error "Nothing to Insert"
       else
         content =  "CONTENT #{ content_params.to_json }"
         target =  target_params.map{|y,z|  y==:type ?  z : "#{y.to_s} #{ z } "}.join
-        Api.execute( database, "INSERT INTO #{target} #{content} ") &.first.allocate_model(false)
+        result = Api.execute( database, session_id: session ){ "INSERT INTO #{target} #{content} "}
+        result &.first.allocate_model(false)
       end
     end
 
@@ -173,89 +218,61 @@ module Arcade
       rid =  rid.join(':')
       rid = rid[1..-1] if rid[0]=="#"
       if rid.rid?
-        Api.query( database, "select from #{rid}" ).first &.allocate_model(autocomplete)
+        Api.query( database, "select from #{rid}", session_id: session ).first &.allocate_model(autocomplete)
       else
         raise Arcade::QueryError "Get requires a rid input", caller
       end
     end
 
-    # ------------------------------  property        ------------------------------------------------- #
-    # Adds properties to the type
+    # ------------------------------  get        ------------------------------------------------------ #
     #
-    #  call via
-    #  Api.property <database>, <type>, name1: a_format , name2: a_format
+    #  Delete the specified rid
     #
-    #  Format is one of
-    #   Boolean, Integer, Short, Long, Float, Double, String
-    #   Datetime, Binary, Byte, Decimal, Link
-    #   Embedded, EmbeddedList, EmbeddedMap
+    def delete rid
+      r =  Api.execute( database, session_id: session ){ "delete from #{rid}" }
+      success =  r == [{ :count => 1 }]
+    end
+
+    # ------------------------------  transmit   ------------------------------------------------------ #
+    # transmits a command  which potentially modifies the database
     #
-    #   In case of an Error,  anything is rolled back and nil is returned
+    # Uses the given session_id for transaction-based operations
     #
-    def self.property database, type, **args
-
-      begin_transaction database
-      success = args.map do | name, format |
-        r= execute(database) {" create property #{type.to_s}.#{name.to_s} #{format.to_s} " } &.first
-        if r.nil?
-          false
-        else
-          r.keys == [ :propertyName, :typeName, :operation ] && r[:operation] == 'create property'
-        end
-      end.uniq
-      if success == [true]
-        commit database
-        true
+    # Otherwise just performs the operation
+
+    def transmit   &block
+      response = Api.execute database,  session_id: session, &block
+      if  response.is_a? Hash
+           _allocate_model res
       else
-        rollback database
+           response
       end
-
-
-    end
-
-    # ------------------------------ index            ------------------------------------------------- #
-    def self.index database, type,  name ,  *properties
-      properties = properties.map( &:to_s )
-      unique_requested = "unique" if properties.delete("unique")
-      unique_requested = "notunique" if  properties.delete("notunique" )
-      automatic = true if
-      properties << name  if properties.empty?
     end
-
-    def delete rid
-      r =  Api.execute( database ){ "delete from #{rid}" }
-      success =  r == [{ :count => 1 }]
-    end
-
+    # ------------------------------  execute    ------------------------------------------------------ #
     # execute a command  which modifies the database
     #
     # The operation is performed via Transaction/Commit
     # If an Error occurs, its rolled back
     #
+    # If a transaction is already active, a nested transation is initiated
+    #
     def execute   &block
-      Api.begin_transaction database
-      response = Api.execute database, &block
-      # puts response.inspect  # debugging
+      # initiate a new transaction
+     s= Api.begin_transaction database
+      response = Api.execute database,  session_id: s,  &block
       r= if  response.is_a? Hash
-           _allocate_model res
-#         elsif response.is_a? Array
-           # remove empty results
-#           response.delete_if{|y| y.empty?}
-          # response.map do | res |
-          #   if res.key? :"@rid"
-          #     allocate_model res
-          #   else
-          #     res
-          #   end
-          # end
+           _allocate_model response
          else
            response
          end
-     Api.commit database
-     r # return associated array of Arcade::Base-objects
+     if Api.commit( database, session_id: s) == 204
+        r # return associated array of Arcade::Base-objects
+     else
+       []
+     end
     rescue  Dry::Struct::Error, Arcade::QueryError => e
-      Api.rollback database
-      logger.error "Execution  FAILED --> #{e.exception}"
+      Api.rollback database, session_id: s, log: false
+      logger.info "Execution  FAILED -->  Status #{e.status}"
       []  #  return empty result
     end
 
@@ -264,7 +281,7 @@ module Arcade
     # detects database-records and  allocates them as model-objects
     #
     def query  query_object
-      Api.query database, query_object.to_s
+      Api.query database, query_object.to_s, session_id: session
     end
 
     #  returns an array of rid's   (same logic as create)
@@ -272,11 +289,13 @@ module Arcade
 
       content = attributes.empty? ?  "" : "CONTENT #{attributes.to_json}"
       cr = ->( f, t ) do
-        edges = Api.execute( database, "create edge #{edge_class} from #{f.rid} to #{t.rid} #{content}").allocate_model(false) 
-        #else
-        #  logger.error "Could not create Edge  #{edge_class} from #{f} to #{t}"
-        ##  logger.error edges.to_s
-        #end
+        begin
+          cmd = -> (){  "create edge #{edge_class} from #{f.rid} to #{t.rid} #{content}" }
+        edges = transmit( &cmd ).allocate_model(false)
+        rescue Arcade::QueryError => e
+          raise unless e.message =~ /Found duplicate key/
+         puts "#"+e.detail.split("#").last[0..-3]
+        end
       end
       from =  [from] unless from.is_a? Array
       to =  [to] unless to.is_a? Array
@@ -287,52 +306,12 @@ module Arcade
 
     end
 
-
-    # query all:  select @rid, *  from {database}
-
-#  not used
- #  def get_schema
- #    query( "select from schema:types" ).map do |a|
- #      puts "a: #{a}"
- #      class_name = a["name"]
- #      inherent_class =  a["parentTypes"].empty? ? [Object,nil] : a["parentTypes"].map(&:camelcase_and_namespace)
- #       namespace, type_name = a["type"].camelcase_and_namespace
- #       namespace= Arcade if namespace.nil?
- #      klass=  Dry::Core::ClassBuilder.new(  name: type_name,
- #                                          parent: nil,
- #                                          namespace:  namespace).call
- #    end
- #  rescue NameError
- #    logger.error "Dataset type #{e} not defined."
- #    raise
- #  end
-   #  Postgres is not implemented
-   # connects to the database and initialises @connection
-    def connection
-      @connection
+    def session
+      @session_id
     end
 
-    def connect environment=:development   # environments:  production devel test
-      if [:production, :development, :test].include? environment
-
-        #  connect through the ruby  postgres driver
-#       c= PG::Connection.new  dbname: Config.database[environment],
-#         user: Config.username[environment],
-#         password: Config.password[environment],
-#         host:  Config.pg[:host],
-#         port:  Config.pg[:port]
-#
-     end
-    rescue PG::ConnectionBad => e
-      if e.to_s  =~  /Credentials/
-        logger.error  "NOT CONNECTED ! Either Database is not present or credentials (#{ Config.username[environment]} / #{Config.password[environment]}) are wrong"
-        nil
-      else
-        raise
-      end
-    end  # def
-
-
-
+    def session?
+      !session.nil?
+    end
   end  # class
 end  #  module