rhodes 1.5.5 → 2.0.0.beta1

data/lib/framework/rho/rhoapplication.rb

@@ -39,8 +39,18 @@ module Rho
     
     def on_activate_app
     end
+
+    # works for schema sources    
+    def on_migrate_source(old_version, new_src)
+        puts "on_migrate_source; old_version :#{old_version}; new_src : #{new_src}"
+        db = ::Rho::RHO.get_src_db(new_src['name'])
+        if new_src['schema']
+            db.delete_table(new_src['name'])
+        end    
+    end
     
     def set_menu(menu=nil,back_action=nil)
+      @default_menu = {} if @default_menu.nil?
       disp_menu = menu ? menu.dup : @default_menu.dup
       disp_menu['Back'] = back_action if back_action
       puts "RhoApplication: Using menu - #{disp_menu.inspect}"

data/lib/framework/rho/rhofsconnector.rb

@@ -24,12 +24,8 @@ module Rho
         File.join(__rhoGetCurrentDir(), 'apps/'+appname+'/'+modelname+'/')
       end
 
-      def get_db_fullpathname
-        if defined? SYNC_DB_FILE
-	        File.join(SYNC_DB_FILE)
-        else
-	        File.join(__rhoGetCurrentDir(), 'db/syncdb.sqlite')
-        end
+      def get_db_fullpathname(postfix)
+          File.join(__rhoGetCurrentDir(), 'db/syncdb' + postfix + '.sqlite')
       end
     end
   end # RhoApplication

data/lib/framework/rho/rhoutils.rb

@@ -3,23 +3,31 @@ require 'rhom/rhom_source'
 module Rho
   class RhoUtils
     @@mapSrc = nil
+    @@mapSrcByIdx = nil
     def self.load_offline_data(tables=[], dir_prefix=nil)
       columns = []
       tables.each do |filename|
     
         if @@mapSrc.nil?
             @@mapSrc = {}
+            @@mapSrcByIdx = {}
             arSrcs = Rhom::RhomSource.find(:all)
             arSrcs.each do |src|
-                @@mapSrc[src.name()] = src.source_id()
+                @@mapSrc[src.name()] = src
+                @@mapSrcByIdx[src.source_id()] = src
             end
         end
-                
-        Rhom::RhomDbAdapter.delete_all_from_table(filename)
-        Rhom::RhomDbAdapter.start_transaction
+        
+        mapDeleted = {}
+        db = ::Rho::RHO.get_user_db()
+        db.delete_all_from_table(filename)
+        db.start_transaction
 
         first_row=true
         prefix = dir_prefix.nil? ? "" : dir_prefix
+        cur_src = nil
+        hashItem = {}
+        cur_objid = nil
         File.open(File.join(Rho::RhoFSConnector.get_base_app_path,'app',prefix,'fixtures',filename+'.txt')).each do |line|
           if first_row
             columns = line.chomp.split('|'); first_row = false; next;
@@ -29,15 +37,48 @@ module Rho
           row = {}
           columns.each_with_index do |col,idx| 
             if col == 'source_name'
-              row['source_id'] = @@mapSrc[parts[idx]]
+              row['source_id'] = @@mapSrc[parts[idx]].source_id()
             else
               row[col] = parts[idx]
             end
           end
-          Rhom::RhomDbAdapter.insert_into_table(filename,row)
+          
+          if ( cur_objid != row['object'] )
+            if cur_src && hashItem && hashItem.length() > 0            
+            
+                if !mapDeleted[cur_src.name()]
+                    db.delete_all_from_table(cur_src.name())
+                    mapDeleted[cur_src.name()] = 1
+                end
+                
+                hashItem['object'] = cur_objid
+                db.insert_into_table(cur_src.name(),hashItem) 
+            end
+            
+            hashItem = {}
+            cur_objid = row['object']            
+          end
+          
+          cur_src = @@mapSrcByIdx[ row['source_id'].to_i ]
+          if ( cur_src && cur_src.schema() )  
+            hashItem[ row['attrib'] ] = row['value'] if row['value']
+          else
+            db.insert_into_table(filename,row)
+          end  
         end
 
-        Rhom::RhomDbAdapter.commit
+        if cur_src && hashItem && hashItem.length() > 0            
+        
+            if !mapDeleted[cur_src.name()]
+                db.delete_all_from_table(cur_src.name())
+                mapDeleted[cur_src.name()] = 1
+            end
+            
+            hashItem['object'] = cur_objid
+            db.insert_into_table(cur_src.name(),hashItem) 
+        end
+
+        db.commit
         columns = []
       end
     end
@@ -45,9 +86,10 @@ module Rho
     def self.load_offline_data_ex(tables=[], dir_prefix=nil, commit_count=100000)
       columns = []
       tables.each do |filename|
-    
-        Rhom::RhomDbAdapter.destroy_table(filename)
-        Rhom::RhomDbAdapter.start_transaction
+
+        db = ::Rho::RHO.get_user_db()    
+        db.destroy_table(filename)
+        db.start_transaction
         
         row_index=0
         prefix = dir_prefix.nil? ? "" : dir_prefix
@@ -69,22 +111,22 @@ module Rho
           parts = line.chomp.split('|')
           
           begin
-              Rhom::RhomDbAdapter.execute_sql query, parts
+              db.execute_sql query, parts
           rescue Exception => e
             #puts "load_offline_data : exception insert data: #{e}; data : #{parts}; line : #{row_index}"
           end
           
           if row_index%commit_count == 0          
             puts "commit start"
-            Rhom::RhomDbAdapter.commit
-            Rhom::RhomDbAdapter.start_transaction
+            db.commit
+            db.start_transaction
             puts "commit : #{row_index}"
           end  
           
           row_index += 1
         end
 
-        Rhom::RhomDbAdapter.commit
+        db.commit
         puts "commit : #{row_index}"
         columns = []
       end

data/lib/framework/rho/rhoviewhelpers.rb

@@ -102,6 +102,8 @@ module Rho
       model = params[:controller] || params[:model] || @request['model'] 
       action = params[:action].nil? ? nil : params[:action].to_s
       id = params[:id].nil? ? nil : params[:id].to_s
+      id = "{#{id}}" if id and not ( id =~ /^{/ and id =~ /}$/ )
+
       if params[:query_s]
         query = params[:query_s]
       else

data/lib/framework/rhodes.rb

@@ -1,9 +1,9 @@
 module Rhodes
   unless defined? Rhodes::VERSION
-    VERSION = '1.5.5'
+    VERSION = '2.0.0'
   end
   unless defined? Rhodes::DBVERSION
-    DBVERSION = '1.5.5'
+    DBVERSION = '2.0.1'
   end
   
 end

data/lib/framework/rhom/rhom.rb

@@ -24,11 +24,9 @@ require 'rhom/rhom_object'
 require 'rhom/rhom_db_adapter'
 
 module Rhom
-  UPDATE_TYPES = ["'create'","'query'","'ask'"]
-  
   class RecordNotFound < StandardError
   end
-  
+
   class Rhom
     attr_accessor :factory
   
@@ -38,31 +36,60 @@ module Rhom
     
     class << Rhom
       def client_id
-        c_id = ::Rhom::RhomDbAdapter.select_from_table('client_info','client_id')[0]
+        c_id = ::Rho::RHO.get_user_db().select_from_table('client_info','client_id')[0]
         c_id.nil? ? nil : c_id['client_id']
       end
       
       def database_full_reset
         SyncEngine.stop_sync
         
-        ::Rhom::RhomDbAdapter.execute_sql("UPDATE client_info SET reset=1")
-        ::Rhom::RhomDbAdapter.execute_sql("UPDATE sources SET token=0")
+        ::Rho::RHO.get_user_db().execute_sql("UPDATE client_info SET reset=1")
+        if ( Rho::RhoConfig.exists?('bulksync_state') )
+            Rho::RhoConfig.bulksync_state='0'
+        end    
+        ::Rho::RHO.get_user_db().execute_sql("UPDATE sources SET token=0")
         
-        ::Rhom::RhomDbAdapter.delete_all_from_table('changed_values')
-#        if defined? RHO_DBME
-            #::Rhom::RhomAttribManager.reset_all
-            ::Rhom::RhomDbAdapter.destroy_table('object_values')
-            #::Rhom::RhomDbAdapter.delete_all_from_table('object_values')
-#        else
-#            ::Rhom::RhomDbAdapter.delete_all_from_table('object_values')
-#            ::Rhom::RhomDbAdapter.execute_sql("VACUUM")
-#        end    
+        ::Rho::RHO.get_db_partitions().each_value do |db|
+            db.destroy_tables(:exclude => ['sources','client_info'])
+        end
+      
+        ::Rho::RHO.init_schema_sources  
       end
       
       def database_full_reset_and_logout
         database_full_reset
         SyncEngine.logout
       end
+      
+        def search(args)
+          searchParams = ""
+          
+          searchParams += '&offset=' + Rho::RhoSupport.url_encode(args[:offset]) if args[:offset]
+          searchParams += '&max_results=' + Rho::RhoSupport.url_encode(args[:max_results]) if args[:max_results]
+
+          callbackParams = args[:callback_param] ? args[:callback_param] : ""
+          
+          if args[:search_params]
+            args[:search_params].each do |key,value|
+              searchParams += '&' + "conditions[#{Rho::RhoSupport.url_encode(key)}]" + '=' + Rho::RhoSupport.url_encode(value)
+              callbackParams += '&' + "search_params[#{Rho::RhoSupport.url_encode(key)}]" + '=' + Rho::RhoSupport.url_encode(value)
+            end  
+          end
+            
+          #set_notification(args[:callback], args[:callback_param]) if args[:callback]
+          src_ar = args[:sources]
+          
+          #check sources
+          raise ArgumentError, "no sources on search" if src_ar.nil? or src_ar.length == 0
+          src_ar.each do |src_name|
+             raise ArgumentError, "no sources on search" if Rho::RhoConfig::sources[src_name].nil?
+          end
+          
+          SyncEngine.dosearch_source(src_ar, args[:from] ? args[:from] : 'search',
+            searchParams, args[:sync_changes] ? args[:sync_changes] : false, args[:progress_step] ? args[:progress_step] : -1,
+            args[:callback], callbackParams )
+        end
+      
     end #class methods
   end # Rhom
 end # Rhom

data/lib/framework/rhom/rhom_db_adapter.rb

@@ -20,90 +20,93 @@
 require 'rhodes'
 
 module Rhom
-  class RhomDbAdapter
+class RhomDbAdapter
     
-    @@database = nil
-    
-    class << self
+  @database = nil
       
-      # maintains a single database connection
-      def open(dbfile=nil)
-        unless @@database or dbfile.nil?
-          @@database = SQLite3::Database.new(dbfile)
-        end
-      end
-    
-      # closes the database if and only if it is open
-      def close
-        if @@database
-          @@database.close
-          @@database = nil
-        else
-          return false
-        end
-        return true
-      end   
+  # maintains a single database connection
+  def initialize(dbfile, partition)
+    unless @database
+      @database = SQLite3::Database.new(dbfile,partition)
+    end
+  end
 
-      def is_ui_waitfordb
-        @@database.is_ui_waitfordb
-      end
-      
-      def start_transaction
-          begin
-            @@database.start_transaction
-          rescue Exception => e
-            puts "exception when start_transaction"
-          end
+  # closes the database if and only if it is open
+  #def close
+  #  if @database
+  #    @database.close
+  #    @database = nil
+  #  else
+  #    return false
+  #  end
+  #  return true
+  #end   
+
+  def is_ui_waitfordb
+      @database.is_ui_waitfordb
+  end
+  
+  def start_transaction
+      begin
+        @database.start_transaction
+      rescue Exception => e
+        puts "exception when start_transaction: #{e}"
+        raise        
       end
+  end
 
-      def commit
-          begin
-            @@database.commit
-          rescue Exception => e
-            puts "exception when commit transaction"
-          end
+  def commit
+      begin
+        @database.commit
+      rescue Exception => e
+        puts "exception when commit transaction : #{e}"
+        raise        
       end
+  end
 
-      def rollback
-          begin
-            @@database.rollback
-          rescue Exception => e
-            puts "exception when rollback transaction"
-          end
+  def rollback
+      begin
+        @database.rollback
+      rescue Exception => e
+        puts "exception when rollback transaction : #{e}"
+        raise
       end
-    
-      # execute a sql statement
-      # optionally, disable the factory processing 
-      # which returns the result array directly
-      def execute_sql(sql, *args)
-        result = []
-        if sql
-          #puts "RhomDbAdapter: Executing query - #{sql}"
-          # Make sure we lock the sync engine's mutex
-          # before we perform a database transaction.
-          # This prevents concurrency issues.
-            begin
-                result = @@database.execute( sql, args )
-            rescue Exception => e
-                #puts "exception when running query: #{e}"
-                #raise
-            end
-        end
-        #puts "result is: #{result.inspect}"
-        result
+  end
+
+  # execute a sql statement
+  # optionally, disable the factory processing 
+  # which returns the result array directly
+  def execute_sql(sql, *args)
+    _execute_sql(sql, false, args)
+  end
+  def execute_batch_sql(sql, *args)
+    _execute_sql(sql, true, args)
+  end
+
+  def _execute_sql(sql, is_batch, args)      
+    result = []
+    if sql
+      #puts "RhomDbAdapter: Executing query - #{sql}"
+      begin
+        result = @database.execute( sql, is_batch, args )
+      rescue Exception => e
+        puts "exception when running query: #{e}"
+        raise
       end
+    end
+    #puts "result is: #{result.inspect}"
+    result
+  end
 
+  class << self
       # generates where clause based on hash
-      def where_str(condition,select_arr=nil)
+      def where_str(condition)
         where_str = ""
         if condition
           where_str += string_from_key_vals(condition,"and")
           where_str = where_str[0..where_str.length - 5]
         end
         
-        if select_arr and select_arr.length > 0
-          where_str += " and attrib in (#{select_str(select_arr)})"
-        end
         where_str
       end
       
@@ -152,100 +155,103 @@ module Rhom
           "'#{s}'"
         end
       end
-    
-      # support for select statements
-      # this function takes table name, columns (as a comma-separated list),
-      # condition (as a hash), and params (as a hash)
-      # example usage is the following:
-      # select_from_table('object_values', '*', {"source_id"=>2,"update_type"=>'query'},
-      #                   {"order by"=>'object'})
-      # this would return all columns where source_id = 2 and update_type = 'query' ordered
-      # by the "object" column
-      def select_from_table(table=nil,columns=nil,condition=nil,params=nil,select_arr=nil)
-        query = nil
-        if table and columns and condition
-          if params and params['distinct']
-            query = "select distinct #{columns} from #{table} where #{where_str(condition,select_arr)}"
-          elsif params and params['order by']
-            query = "select #{columns} from #{table} where #{where_str(condition,select_arr)} order by #{params['order by']}"
-          else
-            query = "select #{columns} from #{table} where #{where_str(condition,select_arr)}"
-          end
-        elsif table and columns
-          query = "select #{columns} from #{table}"                     
-        end
-        execute_sql query
-      end
-    
-      # inserts a single row into the database
-      # takes the table name and values (hash) as arguments
-      # exmaple usage is the following:
-      # insert_into_table('object_values, {"source_id"=>1,"object"=>"some-object","update_type"=>'delete'})
-      # this would execute the following sql:
-      # insert into object_values (source_id,object,update_type) values (1,'some-object','delete');
-      def insert_into_table(table=nil,values=nil)
-        query = nil
-        cols = ""
-        vals = ""
-        if table and values
-          values.each do |key,val|
-            value = get_value_for_sql_stmt(val)+","
-            cols << "#{key},"
-            vals << value
-          end
-          cols = cols[0..cols.length - 2]
-          vals = vals[0..vals.length - 2]
-          query = "insert into #{table} (#{cols}) values (#{vals})"
-        end
-        execute_sql query
-      end
-    
-      # deletes rows from a table which satisfy condition (hash)
-      # example usage is the following:
-      # delete_from_table('object_values',{"object"=>"some-object"})
-      # this would execute the following sql:
-      # delete from object_values where object="some-object"
-      def delete_from_table(table=nil,condition=nil)
-        query = nil
-        if table and condition
-          query = "delete from #{table} where #{where_str(condition)}"
-        end
-        execute_sql query
+    end #self
+
+  # support for select statements
+  # this function takes table name, columns (as a comma-separated list),
+  # condition (as a hash), and params (as a hash)
+  # example usage is the following:
+  # select_from_table('object_values', '*', {"source_id"=>2,"update_type"=>'query'},
+  #                   {"order by"=>'object'})
+  # this would return all columns where source_id = 2 and update_type = 'query' ordered
+  # by the "object" column
+  def select_from_table(table=nil,columns=nil,condition=nil,params=nil)
+    query = nil
+    if table and columns and condition
+      if params and params['distinct']
+        query = "select distinct #{columns} from #{table} where #{RhomDbAdapter.where_str(condition)}"
+      elsif params and params['order by']
+        query = "select #{columns} from #{table} where #{RhomDbAdapter.where_str(condition)} order by #{params['order by']}"
+      else
+        query = "select #{columns} from #{table} where #{RhomDbAdapter.where_str(condition)}"
       end
+    elsif table and columns
+      query = "select #{columns} from #{table}"                     
+    end
     
-      # deletes all rows from a given table
-      def delete_all_from_table(table=nil)
-        query = nil
-        if table
-          query = "delete from #{table}"
-        end
-        execute_sql query
-      end
+    execute_sql query
+  end
 
-      # deletes all rows from a given table by recreating db-file and save all other tables
-      def destroy_table(table)
-          @@database.destroy_table table
+  # inserts a single row into the database
+  # takes the table name and values (hash) as arguments
+  # exmaple usage is the following:
+  # insert_into_table('object_values, {"source_id"=>1,"object"=>"some-object","update_type"=>'delete'})
+  # this would execute the following sql:
+  # insert into object_values (source_id,object,update_type) values (1,'some-object','delete');
+  def insert_into_table(table=nil,values=nil)
+    query = nil
+    cols = ""
+    vals = ""
+    if table and values
+      values.each do |key,val|
+        value = RhomDbAdapter.get_value_for_sql_stmt(val)+","
+        cols << "#{key},"
+        vals << value
       end
-      
-      # updates values (hash) in a given table which satisfy condition (hash)
-      # example usage is the following:
-      # update_into_table('object_values',{"value"=>"Electronics"},{"object"=>"some-object", "attrib"=>"industry"})
-      # this executes the following sql:
-      # update table object_values set value='Electronics' where object='some-object' and attrib='industry';
-      def update_into_table(table=nil,values=nil,condition=nil)
-        query = nil
-        vals = values.nil? ? nil : vals_str(values)
-        if table and condition and vals
-          query = "update #{table} set #{vals} where #{where_str(condition)}"
-        elsif table and vals
-          query = "update #{table} set #{vals}"          
-        end
-        execute_sql query
-      end
-    end # class methods
-  end # RhomDbAdapter
-end # Rhom
+      cols = cols[0..cols.length - 2]
+      vals = vals[0..vals.length - 2]
+      query = "insert into #{table} (#{cols}) values (#{vals})"
+    end
+    execute_sql query
+  end
 
-at_exit do
-	::Rhom::RhomDbAdapter.close
-end
+  # deletes rows from a table which satisfy condition (hash)
+  # example usage is the following:
+  # delete_from_table('object_values',{"object"=>"some-object"})
+  # this would execute the following sql:
+  # delete from object_values where object="some-object"
+  def delete_from_table(table,condition)
+    execute_sql "delete from #{table} where #{RhomDbAdapter.where_str(condition)}"
+  end
+
+  # deletes all rows from a given table
+  def delete_all_from_table(table)
+    execute_sql "delete from #{table}"
+  end
+
+  def table_exist?(table_name)
+    @database.table_exist?(table_name)
+  end
+
+  def delete_table(table)
+    execute_sql "DROP TABLE IF EXISTS #{table}"
+  end
+  
+  #destroy one table  
+  def destroy_table(name)
+    destroy_tables(:include => [name])
+  end
+  
+  # deletes all rows from all tables, except list of given tables by recreating db-file and save all other tables
+  # arguments - :include, :exclude
+  def destroy_tables(*args)
+      @database.destroy_tables args.first[:include], args.first[:exclude]
+  end
+  
+  # updates values (hash) in a given table which satisfy condition (hash)
+  # example usage is the following:
+  # update_into_table('object_values',{"value"=>"Electronics"},{"object"=>"some-object", "attrib"=>"industry"})
+  # this executes the following sql:
+  # update table object_values set value='Electronics' where object='some-object' and attrib='industry';
+  def update_into_table(table=nil,values=nil,condition=nil)
+    query = nil
+    vals = values.nil? ? nil : RhomDbAdapter.vals_str(values)
+    if table and condition and vals
+      query = "update #{table} set #{vals} where #{RhomDbAdapter.where_str(condition)}"
+    elsif table and vals
+      query = "update #{table} set #{vals}"          
+    end
+    execute_sql query
+  end
+end # RhomDbAdapter
+end # Rhom