syncano 3.1.1.beta

data/lib/syncano/resources/notifications/destroy.rb

@@ -0,0 +1,20 @@
+class Syncano
+  module Resources
+    module Notifications
+      # Notification resource about destroying data object - represents notification with type "delete"
+      class Destroy < Syncano::Resources::Notifications::Base
+
+        # Constructor for Syncano::Notifications::Create object
+        # @param [Syncano::Clients::Base] client
+        # @param [Hash] attributes
+        def initialize(client, attributes)
+          super(client, attributes)
+
+          if attributes.is_a?(::Syncano::Packets::Base)
+            self[:target] = attributes.target
+          end
+        end
+      end
+    end
+  end
+end

data/lib/syncano/resources/notifications/message.rb

@@ -0,0 +1,9 @@
+class Syncano
+  module Resources
+    module Notifications
+      # Notification resource representing general notifications
+      class Message < Syncano::Resources::Notifications::Base
+      end
+    end
+  end
+end

data/lib/syncano/resources/notifications/update.rb

@@ -0,0 +1,24 @@
+class Syncano
+  module Resources
+    module Notifications
+      # Notification resource about updating data object - represents notification with type "change"
+      class Update < Syncano::Resources::Notifications::Base
+        # Constructor for Syncano::Notifications::Update object
+        # @param [Syncano::Clients::Base] client
+        # @param [Hash] attributes
+        def initialize(client, attributes)
+          super(client, attributes)
+
+          if attributes.is_a?(::Syncano::Packets::Base)
+            self.attributes = {
+              added: attributes.data[:added],
+              updated: attributes.data[:updated],
+              deleted: attributes.data[:deleted],
+              target: attributes.target
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/syncano/resources/project.rb

@@ -0,0 +1,42 @@
+class Syncano
+  module Resources
+    # Project resource
+    class Project < ::Syncano::Resources::Base
+      # Association has_many :collections
+      # @return [Syncano::QueryBuilder] query builder for resource Syncano::Resources::Collection
+      def collections
+        ::Syncano::QueryBuilder.new(client, ::Syncano::Resources::Collection, project_id: id)
+      end
+
+      # Wrapper for api "subscription.subscribe_project" method
+      # @return [Syncano::Resource::Project]
+      def subscribe
+        perform_subscribe
+        reload!
+      end
+
+      # Wrapper for api "subscription.unsubscribe_project" method
+      # @return [Syncano::Resource::Project]
+      def unsubscribe
+        perform_unsubscribe
+        reload!
+      end
+
+      private
+
+      # Executes proper subscribe request
+      # @return [Syncano::Response]
+      def perform_subscribe
+        check_if_sync_client!
+        client.make_request(:subscription, :subscribe_project, { project_id: id })
+      end
+
+      # Executes proper unsubscribe request
+      # @return [Syncano::Response]
+      def perform_unsubscribe
+        check_if_sync_client!
+        client.make_request(:subscription, :unsubscribe_project, { project_id: id })
+      end
+    end
+  end
+end

data/lib/syncano/resources/role.rb

@@ -0,0 +1,11 @@
+class Syncano
+  module Resources
+    # Role resource
+    class Role < ::Syncano::Resources::Base
+      private
+
+      self.crud_class_methods = [:all]
+      self.crud_instance_methods = []
+    end
+  end
+end

data/lib/syncano/resources/subscription.rb

@@ -0,0 +1,12 @@
+class Syncano
+  module Resources
+    # Subscription resource
+    class Subscription < ::Syncano::Resources::Base
+
+      private
+
+      self.crud_class_methods = [:all]
+      self.crud_instance_methods = []
+    end
+  end
+end

data/lib/syncano/resources/user.rb

@@ -0,0 +1,47 @@
+class Syncano
+  module Resources
+    # User resource
+    class User < ::Syncano::Resources::Base
+      # Wrapper for api "count" method
+      # @param [Syncano::Clients::Base] client
+      # @param [Hash] scope_parameters
+      # @param [Hash] conditions
+      # @return [Integer]
+      def self.count(client, scope_parameters = {}, conditions = {})
+        response = perform_count(client, scope_parameters, conditions)
+        response.data if response.status
+      end
+
+      private
+
+      self.scope_parameters = [:project_id, :collection_id]
+
+      # Prepares hash with attributes used in synchronization with Syncano
+      # @return [Hash]
+      def self.attributes_to_sync(attributes)
+        attributes = attributes.dup
+
+        if attributes.keys.map(&:to_sym).include?(:avatar)
+          if attributes[:avatar].blank?
+            attributes[:avatar] = ''
+          elsif attributes[:avatar].is_a?(String)
+            attributes[:avatar] = Base64.encode64(File.read(attributes[:avatar]))
+          else
+            attributes.delete(:image)
+          end
+        end
+
+        attributes
+      end
+
+      # Executes proper count request
+      # @param [Syncano::Clients::Base] client
+      # @param [Hash] scope_parameters
+      # @param [Hash] conditions
+      # @return [Syncano::Response]
+      def self.perform_count(client, scope_parameters, conditions)
+        make_request(client, nil, :count, conditions.merge(scope_parameters))
+      end
+    end
+  end
+end

data/lib/syncano/response.rb

@@ -0,0 +1,22 @@
+class Syncano
+  # Represents response from Syncano API
+  class Response
+    attr_reader :status, :data, :errors
+
+    # Constructor for Syncano::Response
+    # @param [Boolean] status
+    # @param [Hash] data
+    # @param [Array] errors
+    def initialize(status = false, data = nil, errors = [])
+      super()
+
+      self.status = status
+      self.data   = data
+      self.errors = errors
+    end
+
+    private
+
+    attr_writer :status, :data, :errors
+  end
+end

data/lib/syncano/sync_connection.rb

@@ -0,0 +1,110 @@
+class Syncano
+  # Represents connection with Sync Server
+  class SyncConnection < EventMachine::Connection
+    attr_reader :client
+
+    # Constructor for Syncano::SyncConnection object
+    def initialize
+      super
+
+      self.callbacks = ::ActiveSupport::HashWithIndifferentAccess.new
+      self.callbacks_queue = []
+
+      self.responses = ::ActiveSupport::HashWithIndifferentAccess.new
+      self.responses_queue = []
+
+      self.client = ::Syncano::Clients::Sync.instance
+    end
+
+    # Eventmachine callback invoked after completing connection
+    def connection_completed
+      start_tls
+    end
+
+    # Eventmachine callback invoked completing ssl handshake
+    def ssl_handshake_completed
+      auth_data = {
+        api_key: client.api_key,
+        instance: client.instance_name
+      }
+
+      client.connection = self
+
+      send_data "#{auth_data.to_json}\n"
+    end
+
+    # Eventmachine callback invoked after receiving data from socket
+    # Data are parsed here and processed by callbacks chain
+    def receive_data(data)
+      data = ::ActiveSupport::HashWithIndifferentAccess.new(JSON.parse(data))
+      packet = ::Syncano::Packets::Base.instantize_packet(data)
+
+      if packet.notification?
+        notification = ::Syncano::Resources::Notifications::Base.instantize_notification(client, packet)
+
+        callbacks_queue.each do |callback_name|
+          callbacks[callback_name].call(notification)
+        end
+      elsif packet.call_response?
+        queue_response(packet)
+      end
+    end
+
+    # Appends callback method to the end of callbacks chain
+    # @param [Symbol, String] callback_name
+    # @param [Block] callback
+    def append_callback(callback_name, callback)
+      callbacks[callback_name] = callback
+      callbacks_queue << callback_name
+    end
+
+    # Prepends callback method to the beginning of callbacks chain
+    # @param [Symbol, String] callback_name
+    # @param [Block] callback
+    def prepend_callback(callback_name, callback)
+      callbacks[callback_name] = callback
+      callbacks_queue.unshift(callback_name)
+    end
+
+    # Removes callback from callbacks chain
+    # @param [Symbol, String] callback_name
+    def remove_callback(callback_name)
+      callbacks.delete(callback_name)
+      callbacks_queue.delete(callback_name)
+    end
+
+    # Gets call response packet from the responses queue
+    # @param [Integer, String] message_id
+    # @return [Syncano::Packets::CallResponse]
+    def get_response(message_id)
+      responses.delete(message_id)
+    end
+
+    private
+
+    attr_accessor :client, :callbacks, :callbacks_queue, :responses, :responses_queue
+
+    # Adds call response packet to the responses queue
+    # @param [Syncano::Packets::CallResponse] packet
+    def queue_response(packet)
+      prune_responses_queue
+      message_id = packet.message_id.to_i
+      responses[message_id] = packet
+      responses_queue << message_id
+    end
+
+    # Removes old call response packets from the responses queue
+    def prune_responses_queue
+      while !responses_queue.empty?
+        message_id = responses_queue.first
+
+        if responses_queue[message_id].nil? || Time.now - responses[message_id].timestamp.to_time > 2.minutes
+          responses_queue.shift
+          responses.delete(message_id)
+        else
+          break
+        end
+      end
+    end
+  end
+end

data/lib/syncano/version.rb

@@ -0,0 +1,4 @@
+class Syncano
+  # Syncano version number
+  VERSION = '3.1.1.beta'
+end

data/spec/admins_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe 'Syncano::Resource::Admin' do
+  it 'should get admins' do
+    @client.admins.all.each do |admin|
+      admin.id.should_not be_nil
+      admin[:email].should_not be_nil
+    end
+  end
+
+  it 'should get one admin' do
+    admins = @client.admins.all
+
+    @client.admins.find(admins.last.id)[:name].should == admins.last[:name]
+  end
+end

data/spec/api_keys_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+describe 'Syncano::Resource::ApiKey' do
+  it 'should create new api key in Syncano' do
+    count_before = @client.api_keys.count
+    api_key = @client.api_keys.create(role_id: '2', description: 'Just testing')
+    count_after = @client.api_keys.count
+
+    (count_after - count_before).should == 1
+    @client.api_keys.last[:description].should == 'Just testing'
+  end
+
+  it 'should get api keys' do
+    @client.api_keys.all.each do |api_key|
+      api_key.id.should_not be_nil
+      api_key[:description].should_not be_nil
+    end
+  end
+
+  it 'should get one project' do
+    api_keys = @client.api_keys.all
+
+    api_key = @client.api_keys.find(api_keys.last.id)
+    api_key[:description].should == api_keys.last[:description]
+  end
+
+  it 'should destroy project' do
+    count_before = @client.api_keys.count
+    @client.api_keys.last.destroy
+    count_after = @client.api_keys.count
+
+    (count_before - count_after).should == 1
+  end
+end

data/spec/collections_spec.rb

@@ -0,0 +1,67 @@
+require 'spec_helper'
+
+describe 'Syncano::Resource::Collection' do
+  before(:all) do
+    @project = @client.projects.last || @client.projects.create(name: 'Test project')
+  end
+
+  it 'should create a new collection in Syncano' do
+    count_before = @project.collections.count
+
+    collection = @project.collections.create(name: 'Test collection', description: 'Just testing')
+    collection.id.should_not be_nil
+
+    count_after = @project.collections.count
+
+    (count_after - count_before).should == 1
+    @project.collections.last[:name].should == 'Test collection'
+  end
+
+  it 'should get all collections' do
+    @project.collections.all.each do |collection|
+      collection.id.should_not be_nil
+      collection[:name].should_not be_nil
+    end
+  end
+
+  it 'should get a one collection' do
+    collection = @project.collections.last
+    @project.collections.find(collection.id)[:name].should == collection[:name]
+  end
+
+  it 'should activate inactive collection' do
+    collection = @project.collections.last
+
+    if collection[:status] == 'active'
+      collection.deactivate
+      collection.reload!
+    end
+    collection[:status].should == 'inactive'
+
+    collection.activate
+    collection.reload!
+    collection['status'].should == 'active'
+  end
+
+  it 'should deactivate active collection' do
+    collection = @project.collections.last
+
+    if collection[:status] == 'inactive'
+      collection.activate
+      collection.reload!
+    end
+    collection[:status].should == 'active'
+
+    collection.deactivate
+    collection.reload!
+    collection[:status].should == 'inactive'
+  end
+
+  it 'should destroy a collection' do
+    count_before = @project.collections.count
+    @project.collections.last.destroy
+    count_after = @project.collections.count
+
+    (count_before - count_after).should == 1
+  end
+end

data/spec/data_objects_spec.rb

@@ -0,0 +1,113 @@
+require 'spec_helper'
+
+describe 'Syncano::Resource::DataObject' do
+  before(:all) do
+    @project = @client.projects.last || @client.projects.create(name: 'Test project')
+    @collection = @project.collections.last || @project.collections.create(name: 'Test collection')
+  end
+
+  after(:all) do
+    @client.batch do |q|
+      @collection.data_objects.all.each do |data_object|
+        q << data_object.batch.destroy
+      end
+    end
+  end
+
+  it 'should create new data object in Syncano' do
+    count_before = @collection.data_objects.count
+    @collection.data_objects.create(title: 'Test data object', test_attribute: 'test_value')
+    count_after = @collection.data_objects.count
+
+    (count_after - count_before).should == 1
+    data_object = @collection.data_objects.last
+    data_object[:title].should == 'Test data object'
+    data_object[:test_attribute].should == 'test_value'
+  end
+
+  it 'should copy data object in Syncano' do
+    count_before = @collection.data_objects.count
+    data_object = @collection.data_objects.last
+    data_object.copy
+    data_object_copy = @collection.data_objects.last
+    count_after = @collection.data_objects.count
+
+    (count_after - count_before).should == 1
+    data_object_copy[:title].should == data_object[:title]
+    data_object_copy.id.should_not == data_object.id
+  end
+
+  it 'should get data objects' do
+    @collection.data_objects.all.each do |data_object|
+      data_object.id.should_not be_nil
+      data_object[:state].should_not be_nil
+    end
+  end
+
+  it 'should check amount of objects' do
+    @collection.data_objects.count.should == @collection.data_objects.all.count
+  end
+
+  it 'should get one data object' do
+    data_objects = @collection.data_objects.all
+
+    data_object = @collection.data_objects.find(data_objects.last.id)
+    data_object[:title].should == data_objects.last[:title]
+  end
+
+  context 'managing parents and children' do
+    before(:all) do
+      @parent = @collection.data_objects.first(include_children: true)
+      @parent = @collection.data_objects.create(title: "Parent object")
+      @child = @collection.data_objects.last
+      @child = @collection.data_objects.create(title: 'Child object') if @child.id == @parent.id
+      @parent.id.should_not == @child.id
+    end
+
+    it 'should add parent to the data object' do
+      @parent.remove_child(@child.id) if @parent[:children].present? && @parent[:children].map(&:id).include?(@child.id)
+
+      @child.add_parent(@parent.id)
+      @parent.reload!(include_children: true)
+
+      @parent[:children].should_not be_nil
+      @parent[:children].select{ |c| c.id == @child.id }.first.should_not be_nil
+    end
+
+    it 'should remove parent from the data object' do
+      @parent.add_child(@child.id) unless @parent[:children].present? && @parent[:children].map(&:id).include?(@child.id)
+
+      @child.remove_parent(@parent.id)
+      @parent.reload!(include_children: true)
+
+      @parent[:children].should be_nil
+    end
+
+    it 'should add child to the data object' do
+      @parent.remove_child(@child.id) if @parent[:children].present? && @parent[:children].map(&:id).include?(@child.id)
+
+      @parent.add_child(@child.id)
+      @parent.reload!(include_children: true)
+
+      @parent[:children].should_not be_nil
+      @parent[:children].select{ |c| c.id == @child.id }.first.should_not be_nil
+    end
+
+    it 'should remove child from the data object' do
+      @parent.add_child(@child.id) unless @parent[:children].present? && @parent[:children].map(&:id).include?(@child.id)
+
+      @parent.remove_child(@child.id)
+      @parent.reload!(include_children: true)
+
+      @parent[:children].should be_nil
+    end
+  end
+
+  it 'should destroy data object' do
+    count_before = @collection.data_objects.count
+    @collection.data_objects.last.destroy
+    count_after = @collection.data_objects.count
+
+    (count_before - count_after).should == 1
+  end
+end