rhoconnect 3.0.0.beta1

data/lib/rhoconnect/api/source/push_deletes.rb

@@ -0,0 +1,8 @@
+Server.api :push_deletes, :source do |params,user|
+  source = Source.load(params[:source_id],{:app_id=>APP_NAME,:user_id=>params[:user_id]})
+  # if source does not exist create one for dynamic adapter
+  source = Source.create({:name => params[:source_id]},{:app_id => APP_NAME,:user_id=>params[:user_id]}) unless source
+  source_sync = SourceSync.new(source)
+  source_sync.push_deletes(params[:objects])
+  'done'
+end

data/lib/rhoconnect/api/source/push_objects.rb

@@ -0,0 +1,8 @@
+Server.api :push_objects, :source do |params,user|
+  source = Source.load(params[:source_id],{:app_id=>APP_NAME,:user_id=>params[:user_id]})
+  # if source does not exist create one for dynamic adapter
+  source = Source.create({:name => params[:source_id]},{:app_id => APP_NAME,:user_id=>params[:user_id]}) unless source
+  source_sync = SourceSync.new(source)
+  source_sync.push_objects(params[:objects])
+  'done'
+end

data/lib/rhoconnect/api/source/save_adapter.rb

@@ -0,0 +1,3 @@
+Server.api :save_adapter, :source do |params,user|
+  Rhoconnect.appserver = params[:attributes]['adapter_url']
+end

data/lib/rhoconnect/api/source/set_db_doc.rb

@@ -0,0 +1,8 @@
+Server.api :set_db_doc, :source do |params,user|
+  if params[:data_type] and params[:data_type] == 'string'
+    Store.put_value(params[:doc],params[:data])
+  else
+    Store.put_data(params[:doc],params[:data])
+  end  
+  ''
+end

data/lib/rhoconnect/api/source/set_refresh_time.rb

@@ -0,0 +1,8 @@
+Server.api :set_refresh_time, :source do |params,user|
+  source = Source.load(params[:source_name],
+    {:app_id => APP_NAME, :user_id => params[:user_name]})
+  source.poll_interval = params[:poll_interval] if params[:poll_interval]
+  params[:refresh_time] ||= 0
+  source.read_state.refresh_time = Time.now.to_i + params[:refresh_time].to_i
+  ''
+end

data/lib/rhoconnect/api/source/upload_file.rb

@@ -0,0 +1,4 @@
+Server.api :upload_file, :source do |params,user|
+  unzip_file(Rhoconnect.app_directory,params[:upload_file]) if File.exists?(Rhoconnect.app_directory)
+  "File uploaded"
+end

data/lib/rhoconnect/api/user/create_user.rb

@@ -0,0 +1,7 @@
+Server.api :create_user, :user do |params,user|
+  app = App.load(APP_NAME)
+  u = User.create({:login => params[:attributes]['login']})
+  u.password = params[:attributes]['password']
+  app.users << u.login
+  "User created"
+end

data/lib/rhoconnect/api/user/delete_user.rb

@@ -0,0 +1,9 @@
+Server.api :delete_user, :user do |params,user|
+  User.load(params[:user_id]).delete
+  App.load(APP_NAME).users.delete(params[:user_id])
+  params = {:app_id => APP_NAME,:user_id => params[:user_id]}
+  App.load(APP_NAME).sources.each{ |source|
+    Source.load(source, params).flash_store_data
+  }
+  "User deleted"
+end

data/lib/rhoconnect/api/user/list_users.rb

@@ -0,0 +1,3 @@
+Server.api :list_users, :user do |params,user|
+  App.load(APP_NAME).users.members.to_json
+end

data/lib/rhoconnect/api/user/update_user.rb

@@ -0,0 +1,4 @@
+Server.api :update_user, :user do |params,user|
+  user.update(params[:attributes])
+  "User updated"
+end

data/lib/rhoconnect/api_token.rb

@@ -0,0 +1,19 @@
+require 'uuidtools'
+module Rhoconnect
+  class ApiToken < Model
+    field :value,:string
+    field :user_id,:string
+    validates_presence_of :user_id
+    
+    def self.create(fields)
+      fields[:value] = fields[:value] || Rhoconnect.api_token || get_random_uuid
+      fields[:id] = fields[:value]
+      object = super(fields)
+    end
+    
+    def user
+      User.load(self.user_id)
+    end
+  end
+end
+    

data/lib/rhoconnect/app.rb

@@ -0,0 +1,76 @@
+module Rhoconnect
+  class App < Model
+    field :name, :string
+    set   :users, :string
+    attr_reader :delegate
+    validates_presence_of :name
+    
+    @@sources = []
+    
+    class << self
+      def create(fields={})
+        fields[:id] = fields[:name]
+        begin
+          require under_score(fields[:name])
+        rescue Exception; end
+        super(fields)
+      end
+    end
+    
+    def can_authenticate?
+      # TODO: optimize it!
+      self.delegate && self.delegate.singleton_methods.map(&:to_sym).include?(:authenticate)
+    end
+
+    def authenticate(login, password, session)
+      if Rhoconnect.appserver
+        auth_result = DynamicAdapter.authenticate(login,password)
+      elsif self.delegate
+        auth_result = self.delegate.authenticate(login, password, session) 
+      end
+      
+      if auth_result
+        login = auth_result if auth_result.is_a? String
+        user = User.load(login) if User.is_exist?(login)
+        if not user
+          user = User.create(:login => login)
+          users << user.id
+        end
+        return user
+      end
+    end
+    
+    def delegate
+      @delegate.nil? ? Object.const_get(camelize(self.name)) : @delegate
+    end
+    
+    def delete
+      @@sources = []
+      super
+    end
+    
+    def delete_sources
+      @@sources = []
+    end
+    
+    def partition_sources(partition,user_id)
+      names = []
+      @@sources.each do |source|
+        s = Source.load(source,{:app_id => self.name,
+          :user_id => user_id})
+        if s.partition == partition
+          names << s.name
+        end
+      end
+      names
+    end
+    
+    def store_blob(obj,field_name,blob)
+      self.delegate.send :store_blob, obj,field_name,blob
+    end
+        
+    def sources
+      @@sources.uniq! || @@sources
+    end
+  end
+end

data/lib/rhoconnect/bulk_data/bulk_data.rb

@@ -0,0 +1,88 @@
+require 'resque'
+require 'rhoconnect/jobs/bulk_data_job'
+
+module Rhoconnect
+  class BulkData < Model
+    field :name, :string
+    field :state, :string
+    field :app_id, :string
+    field :user_id, :string
+    field :refresh_time, :integer
+    field :dbfile,:string
+    set   :sources, :string
+    validates_presence_of :app_id, :user_id, :sources
+    
+    def completed?
+      if state.to_sym == :completed
+        return true
+      end
+      false
+    end
+    
+    def delete
+      sources.members.each do |source|
+        s = Source.load(source,{:app_id => app_id, :user_id => user_id})
+        Store.flash_data(s.docname(:md_copy)) if s
+      end
+      super
+    end
+    
+    def process_sources
+      sources.members.each do |source|
+        s = Source.load(source,{:app_id => app_id, :user_id => user_id})
+        if s
+          SourceSync.new(s).process_query(nil)
+          s.clone(:md,:md_copy) unless s.sync_type.to_sym == :bulk_sync_only
+        end
+      end
+    end
+    
+    def url
+      zippath = dbfile.gsub(Regexp.compile(Regexp.escape(Rhoconnect.data_directory)), "")
+      URI.escape(File.join('/data',zippath))
+    end
+    
+    def dbfiles_exist?
+      files = [dbfile,dbfile+'.rzip']
+      if Rhoconnect.blackberry_bulk_sync
+        files << dbfile+'.hsqldb.data'
+        files << dbfile+'.hsqldb.script'
+        files << dbfile+'.hsqldb.properties'
+      end
+      files.each do |file|
+        return false unless File.exist?(file)
+      end
+      true
+    end
+    
+    class << self
+      def create(fields={})
+        fields[:id] = fields[:name]
+        fields[:state] ||= :inprogress
+        fields[:sources] ||= []
+        super(fields)
+      end
+      
+      def enqueue(params={})
+        Resque.enqueue(BulkDataJob,params)
+      end
+      
+      def get_name(partition,user_id)
+        if partition == :user
+          File.join(APP_NAME,user_id,user_id)
+        else
+          File.join(APP_NAME,APP_NAME)
+        end
+      end
+      
+      def schema_file
+        File.join(File.dirname(__FILE__),'syncdb.schema')
+      end
+      
+      def index_file
+        File.join(File.dirname(__FILE__),'syncdb.index.schema')
+      end
+    end
+  end
+end
+

data/lib/rhoconnect/bulk_data/syncdb.index.schema

@@ -0,0 +1,4 @@
+CREATE INDEX by_src_id on object_values ("source_id");
+CREATE UNIQUE INDEX by_src_object ON object_values ("object", "attrib", "source_id");
+CREATE INDEX by_src_value ON object_values ("attrib", "source_id", "value");
+

data/lib/rhoconnect/bulk_data/syncdb.schema

@@ -0,0 +1,41 @@
+CREATE TABLE client_info (
+ "client_id" VARCHAR(255) default NULL,
+ "session" VARCHAR(255) default NULL,
+ "token" VARCHAR(255) default NULL,
+ "token_sent" BIGINT default 0,
+ "reset" BIGINT default 0,
+ "port" VARCHAR(10) default NULL,
+ "last_sync_success" VARCHAR(100) default NULL);
+CREATE TABLE object_values (
+ "source_id" BIGINT default NULL,
+ "attrib" varchar(255) default NULL,
+ "object" varchar(255) default NULL,
+ "value" varchar default NULL);
+CREATE TABLE changed_values (
+ "source_id" BIGINT default NULL,
+ "attrib" varchar(255) default NULL,
+ "object" varchar(255) default NULL,
+ "value" varchar default NULL,
+ "attrib_type" varchar(255) default NULL,
+ "update_type" varchar(255) default NULL,
+ "sent" BIGINT default 0);
+CREATE TABLE sources (
+ "source_id" BIGINT PRIMARY KEY,
+ "name" VARCHAR(255) default NULL,
+ "token" BIGINT default NULL,
+ "sync_priority" BIGINT,
+ "partition" VARCHAR(255),
+ "sync_type" VARCHAR(255),
+ "metadata" varchar default NULL, 
+ "last_updated" BIGINT default 0,
+ "last_inserted_size" BIGINT default 0,
+ "last_deleted_size" BIGINT default 0,
+ "last_sync_duration" BIGINT default 0,
+ "last_sync_success" BIGINT default 0,
+ "backend_refresh_time" BIGINT default 0,
+ "source_attribs" varchar default NULL,
+ "schema" varchar default NULL,
+ "schema_version" varchar default NULL,
+ "associations" varchar default NULL,
+ "blob_attribs" varchar default NULL);
+

data/lib/rhoconnect/bulk_data.rb

@@ -0,0 +1,2 @@
+$:.unshift File.dirname(__FILE__)
+require 'bulk_data/bulk_data'

data/lib/rhoconnect/client.rb

@@ -0,0 +1,96 @@
+module Rhoconnect  
+  class InvalidSourceNameError < RuntimeError; end
+  
+  class Client < Model
+    field :device_type, :string
+    field :device_pin,  :string
+    field :device_port, :string
+    field :phone_id,    :string
+    field :user_id,     :string
+    field :last_sync,   :datetime
+    field :app_id,      :string
+    attr_accessor :source_name
+    validates_presence_of :app_id, :user_id
+    
+    include Document
+    include LockOps
+    
+    def self.create(fields,params={})
+      Rhoconnect.license.check_and_use_seat
+      fields[:id] = get_random_uuid
+      res = super(fields,params)
+      user = User.load(fields[:user_id])
+      user.clients << res.id
+      if Rhoconnect.stats
+        Rhoconnect::Stats::Record.set('clients') { Store.incr('client:count') }
+      else
+        Store.incr('client:count')
+      end
+      res
+    end
+    
+    def self.load(id,params)
+      params.merge!(:last_sync => Time.now)
+      validate_attributes(params)
+      super(id,params)
+    end
+    
+    def app
+      @app ||= App.load(app_id)
+    end
+    
+    def doc_suffix(doctype)
+      doctype = doctype.to_s
+      if doctype == '*'
+        "#{self.user_id}:#{self.id}:*"
+      elsif self.source_name 
+        "#{self.user_id}:#{self.id}:#{self.source_name}:#{doctype}"
+      else
+        raise InvalidSourceNameError.new('Invalid Source Name For Client')   
+      end          
+    end
+    
+    def delete
+      flash_data('*')
+      Rhoconnect.license.free_seat
+      if Rhoconnect.stats
+        Rhoconnect::Stats::Record.set('clients') { Store.decr('client:count') }
+      else
+        Store.decr('client:count')
+      end
+      super
+    end
+    
+    def switch_user(new_user_id)
+      flash_data('*')
+      User.load(self.user_id).clients.delete(self.id)
+      User.load(new_user_id).clients << self.id
+      self.user_id = new_user_id
+    end
+    
+    def update_clientdoc(sources)
+      # TODO: We need to store schema info and data info in bulk data
+      # source masterdoc and source schema might have changed!
+      sources.each do |source|
+        s = Source.load(source,{:app_id => app_id,:user_id => user_id})
+        unless s.sync_type.to_sym == :bulk_sync_only
+          self.source_name = source
+          Store.clone(s.docname(:md_copy),self.docname(:cd))
+        end
+        self.put_value(:schema_sha1,s.get_value(:schema_sha1))
+      end
+    end
+    
+    def update_fields(params)
+      [:device_type,:device_pin,:device_port,:phone_id].each do |setting|
+        self.send "#{setting}=".to_sym, params[setting].to_s if params[setting]
+      end
+    end
+    
+    private
+    
+    def self.validate_attributes(params)
+      raise ArgumentError.new('Missing required attribute source_name') unless params[:source_name]
+    end
+  end
+end