syncano 3.1.1.beta

data/lib/syncano/packets/auth.rb

@@ -0,0 +1,7 @@
+class Syncano
+  module Packets
+    # Class representing auth packets used in communication with the Sync Server
+    class Auth < Syncano::Packets::Base
+    end
+  end
+end

data/lib/syncano/packets/base.rb

@@ -0,0 +1,64 @@
+class Syncano
+  # Module used as a scope for classes representing packets
+  module Packets
+    # Base class for representing packets used in communication with the Sync Server
+    class Base
+      attr_reader :object, :timestamp
+
+      # Constructor for Syncano::Packets::Base object
+      # @param [Hash] attributes
+      def initialize(attributes)
+        super()
+        self.timestamp = attributes[:timestamp]
+        self.object = attributes[:object]
+      end
+
+      # Proxy method for creating instance of proper subclass
+      # @param [Hash] data
+      # @return [Syncano::Packets::Base]
+      def self.instantize_packet(data)
+        mapping = {
+          auth: ::Syncano::Packets::Auth,
+          call: ::Syncano::Packets::Call,
+          callresponse: ::Syncano::Packets::CallResponse,
+          error: ::Syncano::Packets::Error,
+          message: ::Syncano::Packets::Message,
+          new: ::Syncano::Packets::Notification,
+          change: ::Syncano::Packets::Notification,
+          delete: ::Syncano::Packets::Notification,
+          ping: ::Syncano::Packets::Ping
+        }
+
+        mapping[data[:type].to_sym].new(data)
+      end
+
+      # Returns true if is a notification packet
+      # @return [TrueClass, FalseClass]
+      def notification?
+        false
+      end
+
+      # Returns true if is a ping packet
+      # @return [TrueClass, FalseClass]
+      def ping?
+        false
+      end
+
+      # Returns true if is a call response packet
+      # @return [TrueClass, FalseClass]
+      def call_response?
+        false
+      end
+
+      # Returns true if is a message packet
+      # @return [TrueClass, FalseClass]
+      def message?
+        false
+      end
+
+      private
+
+      attr_writer :object, :timestamp
+    end
+  end
+end

data/lib/syncano/packets/call.rb

@@ -0,0 +1,34 @@
+class Syncano
+  module Packets
+    # Class representing call packets used in communication with the Sync Server
+    class Call < Syncano::Packets::Base
+      attr_reader :message_id, :resource_name, :method_name, :data
+
+      # Constructor for Syncano::Packets::Call object
+      # @param [Hash] attributes
+      def initialize(attributes)
+        super(attributes)
+        self.resource_name = attributes[:resource_name]
+        self.method_name = attributes[:method_name]
+        self.data = attributes[:data]
+        self.message_id = attributes[:message_id] || rand(10**12)
+      end
+
+      # Overwritten method for preparing hash for json serialization
+      # @param [Hash] options
+      # @return [Hash]
+      def as_json(options = {})
+        {
+          type: 'call',
+          method: "#{resource_name}.#{method_name}",
+          params: data,
+          message_id: message_id.to_s
+        }
+      end
+
+      private
+
+      attr_writer :message_id, :resource_name, :method_name, :data
+    end
+  end
+end

data/lib/syncano/packets/call_response.rb

@@ -0,0 +1,33 @@
+class Syncano
+  module Packets
+    # Class representing call response packets used in communication with the Sync Server
+    class CallResponse < Syncano::Packets::Base
+      attr_reader :message_id, :data, :result
+
+      # Constructor for Syncano::Packets::CallResponse object
+      # @param [Hash] attributes
+      def initialize(attributes)
+        super(attributes)
+        self.message_id = attributes[:message_id]
+        self.data = attributes[:data]
+        self.result = attributes[:result]
+      end
+
+      # Prepares hash in response format
+      # @return [Hash]
+      def to_response
+        data.merge(result: result)
+      end
+
+      # Returns true if is a call response packet
+      # @return [TrueClass, FalseClass]
+      def call_response?
+        true
+      end
+
+      private
+
+      attr_writer :message_id, :data, :result
+    end
+  end
+end

data/lib/syncano/packets/error.rb

@@ -0,0 +1,19 @@
+class Syncano
+  module Packets
+    # Class representing error packets used in communication with the Sync Server
+    class Error < Syncano::Packets::Base
+      attr_reader :error
+
+      # Constructor for Syncano::Packets::Error object
+      # @param [Hash] attributes
+      def initialize(attributes)
+        super(attributes)
+        self.error = attributes[:error]
+      end
+
+      private
+
+      attr_writer :error
+    end
+  end
+end

data/lib/syncano/packets/message.rb

@@ -0,0 +1,30 @@
+class Syncano
+  module Packets
+    # Class representing message packets used in communication with the Sync Server
+    class Message < Syncano::Packets::Base
+      attr_accessor :id, :source, :target, :data
+
+      # Constructor for Syncano::Packets::Message object
+      # @param [Hash] attributes
+      def initialize(attributes)
+        super(attributes)
+        self.id = attributes[:id]
+        self.source = attributes[:source]
+        self.target = attributes[:target]
+        self.data = attributes[:data]
+      end
+
+      # Returns true if is a notification packet
+      # @return [TrueClass, FalseClass]
+      def notification?
+        true
+      end
+
+      # Returns true if is a message packet
+      # @return [TrueClass, FalseClass]
+      def message?
+        true
+      end
+    end
+  end
+end

data/lib/syncano/packets/notification.rb

@@ -0,0 +1,39 @@
+class Syncano
+  module Packets
+    # Class representing notification packets used in communication with the Sync Server
+    class Notification < Syncano::Packets::Base
+      attr_reader :id, :type, :channel, :source, :target, :data
+
+      # Constructor for Syncano::Packets::Notification object
+      # @param [Hash] attributes
+      def initialize(attributes)
+        super(attributes)
+        self.id = attributes[:id]
+        self.type = attributes[:type]
+        self.channel = attributes[:channel]
+        self.source = attributes[:source]
+        self.target = attributes[:target]
+
+        if type == 'change'
+          self.data = {
+            added: attributes[:add],
+            updated: attributes[:replace],
+            deleted: attributes[:delete]
+          }
+        else
+          self.data = attributes[:data]
+        end
+      end
+
+      # Returns true if is a notification packet
+      # @return [TrueClass, FalseClass]
+      def notification?
+        true
+      end
+
+      private
+
+      attr_writer :id, :type, :channel, :source, :target, :data
+    end
+  end
+end

data/lib/syncano/packets/ping.rb

@@ -0,0 +1,12 @@
+class Syncano
+  module Packets
+    # Class representing ping packets used in communication with the Sync Server
+    class Ping < Syncano::Packets::Base
+      # Returns true if is a ping packet
+      # @return [TrueClass, FalseClass]
+      def ping?
+        true
+      end
+    end
+  end
+end

data/lib/syncano/query_builder.rb

@@ -0,0 +1,144 @@
+class Syncano
+  # Proxy class for creating proper requests to api through ActiveRecord pattern
+  class QueryBuilder
+    # Constructor for Syncano::QueryBuilder object
+    # @param [Syncano::Clients::Base] client
+    # @param [String] resource_class
+    # @param [Hash] scope_parameters
+    def initialize(client, resource_class, scope_parameters = {})
+      self.client = client
+      self.resource_class = resource_class
+      self.scope_parameters = scope_parameters
+    end
+
+    # Proxy for preparing batch requests
+    # ie. query_builder.batch.create will prepare BatchQueueElement
+    # which invokes batch_create method on query builder object
+    # @return [Syncano::BatchQueueElement]
+    def batch
+      ::Syncano::BatchQueueElement.new(self)
+    end
+
+    # Proxy for calling "all" method on the resource object
+    # @param [Hash] conditions
+    # @return [Array] collection of Syncano::Resources::Base objects
+    def all(conditions = {})
+      resource_class.all(client, conditions.merge(scope_parameters))
+    end
+
+    # Proxy for calling "count" method on the resource object
+    # @param [Hash] conditions
+    # @return [Integer]
+    def count(conditions = {})
+      resource_class.count(client, conditions.merge(scope_parameters))
+    end
+
+    # Returns first element from all returned by "all" method
+    # @param [Hash] conditions
+    # @return [Syncano::Resources::Base]
+    def first(conditions = {})
+      all(conditions).first
+    end
+
+    # Returns last element from all returned by "all" method
+    # @param [Hash] conditions
+    # @return [Syncano::Resources::Base]
+    def last(conditions = {})
+      all(conditions).last
+    end
+
+    # Proxy for calling "find" method on the resource object
+    # @param [Integer, String] key
+    # @param [Hash] conditions
+    # @return [Syncano::Resources::Base]
+    def find(key, conditions = {})
+      resource_class.find(client, key, scope_parameters, conditions)
+    end
+
+    # Proxy for calling "find_by_key" method on the resource object
+    # @param [String] key
+    # @param [Hash] conditions
+    # @return [Syncano::Resources::Base]
+    def find_by_key(key, conditions = {})
+      resource_class.find_by_key(client, key, scope_parameters, conditions)
+    end
+
+    # Proxy for calling "find_by_name" method on the resource object
+    # @param [String] name
+    # @param [Hash] conditions
+    # @return [Syncano::Resources::Base]
+    def find_by_name(name, conditions = {})
+      resource_class.find_by_name(client, name, scope_parameters, conditions)
+    end
+
+    # Proxy for calling "find_by_email" method on the resource object
+    # @param [String] email
+    # @param [Hash] conditions
+    # @return [Syncano::Resources::Base]
+    def find_by_email(email, conditions = {})
+      resource_class.find_by_email(client, email, scope_parameters, conditions)
+    end
+
+    # Proxy for calling "new" method on the resource object
+    # @param [Hash] attributes
+    # @return [Syncano::Resources::Base]
+    def new(attributes = {})
+      resource_class.new(client, attributes.merge(scope_parameters))
+    end
+
+    # Proxy for calling "create" method on the resource object
+    # @param [Hash] attributes
+    # @return [Syncano::Resources::Base]
+    def create(attributes)
+      resource_class.create(client, attributes.merge(scope_parameters))
+    end
+
+    # Proxy for calling "batch_create" method on the resource object
+    # @param [Jimson::Client] batch_client
+    # @param [Hash] attributes
+    # @return [Syncano::Response]
+    def batch_create(batch_client, attributes)
+      resource_class.batch_create(batch_client, client, attributes.merge(scope_parameters))
+    end
+
+    # Proxy for calling "copy" method on the resource object
+    # @param [Array] ids
+    # @return [Array] collection of Syncano::Resource objects
+    def copy(ids)
+      resource_class.copy(client, scope_parameters, ids)
+    end
+
+    # Proxy for calling "batch_copy" method on the resource object
+    # @param [Jimson::Client] batch_client
+    # @param [Array] ids
+    # @return [Syncano::Response]
+    def batch_copy(batch_client, ids)
+      resource_class.batch_copy(batch_client, scope_parameters, ids)
+    end
+
+    # Proxy for calling "move" method on the resource object
+    # @param [Array] ids
+    # @param [Hash] conditions
+    # @param [String] new_folder
+    # @param [String] new_state
+    # @return [Array] collection of Syncano::Resource objects
+    def move(ids, conditions = {}, new_folder = nil, new_state = nil)
+      resource_class.move(client, scope_parameters, ids, conditions, new_folder, new_state)
+    end
+
+    # Proxy for calling "batch_move" method on the resource object
+    # @param [Jimson::Client] batch_client
+    # @param [Array] ids
+    # @param [Hash] conditions
+    # @param [String] new_folder
+    # @param [String] new_state
+    # @return [Syncano::Response]
+    def batch_move(batch_client, ids, conditions = {}, new_folder = nil, new_state = nil)
+      resource_class.batch_move(batch_client, scope_parameters, ids, conditions, new_folder, new_state)
+    end
+
+    private
+
+    attr_accessor :client, :resource_class, :scope_parameters
+  end
+end

data/lib/syncano/resources/admin.rb

@@ -0,0 +1,26 @@
+class Syncano
+  module Resources
+    # Admin resource
+    class Admin < ::Syncano::Resources::Base
+      # Wrapper for api "get_one" method with admin_email as a key
+      # @param [Syncano::Clients::Base] client
+      # @param [String] email
+      # @param [Hash] scope_parameters
+      # @param [Hash] conditions
+      # @return [Syncano::Resources::Admin]
+      def self.find_by_email(client, email, scope_parameters = {}, conditions = {})
+        perform_find(client, :admin_email, email, scope_parameters, conditions)
+      end
+
+      # Wrapper for api "new" method
+      # Creates object in Syncano
+      # @param [Syncano::Clients::Base] client
+      # @param [Hash] attributes
+      # @return [Syncano::Resources::Base]
+      def self.create(client, attributes)
+        perform_create(client, nil, attributes)
+        all(client, map_to_scope_parameters(attributes)).last
+      end
+    end
+  end
+end

data/lib/syncano/resources/api_key.rb

@@ -0,0 +1,46 @@
+class Syncano
+  module Resources
+    # Api key resource
+    class ApiKey < ::Syncano::Resources::Base
+      # Overwritten constructor with initializing associated role object
+      # @param [Syncano::Clients::Base] client
+      # @param [Hash] attributes
+      def initialize(client, attributes = {})
+        super(client, attributes)
+        if @attributes[:role].is_a?(Hash)
+          @attributes[:role] = ::Syncano::Resources::Role.new(@attributes[:role])
+        end
+
+        if @saved_attributes[:role].is_a?(Hash)
+          @saved_attributes[:role] = ::Syncano::Resources::Role.new(@saved_attributes[:role])
+        end
+      end
+
+      private
+
+      # Prepares attributes to synchronizing with Syncano
+      # @param [Hash] attributes
+      # @return [Hash] prepared attributes
+      def self.attributes_to_sync(attributes)
+        attributes = attributes.dup
+        attributes.delete(:role)
+
+        attributes
+      end
+
+      # Name of attribute used as primary key
+      # @return [Symbol]
+      def self.primary_key_name
+        :api_client_id
+      end
+
+      # Executes proper update request
+      # @param [Jimson::BatchClient] batch_client
+      # @param [Hash] attributes
+      # @return [Syncano::Response]
+      def perform_update(batch_client, attributes)
+        self.class.make_request(client, batch_client, :update_description, self.class.attributes_to_sync(attributes).merge(self.class.primary_key_name.to_sym => primary_key))
+      end
+    end
+  end
+end