coinfresh 0.0.1

data/lib/coinfresh/http.rb

@@ -0,0 +1,106 @@
+require 'api-auth'
+
+module Coinfresh
+  
+  module Http
+    class Unauthorized < Exception; end 
+    class ResourceNotFound < Exception; end
+    class BadRequest < Exception; end
+
+    def base_uri(path, params = {})        
+      uri = URI.parse(self.class.base_scope_url)
+      uri.path = path
+      uri.query = URI.encode_www_form(params) if params.any?
+      uri
+    end
+
+    def get(path, params ={}, parse=true)
+      uri = base_uri("#{api_prefix}/#{path}", params)
+      req = Net::HTTP::Get.new(uri.request_uri)
+      make_api_request(req, uri, parse)
+    end
+
+    def put(path, body = "", parse=true)
+      uri = base_uri("#{api_prefix}/#{path}")        
+      req = Net::HTTP::Put.new(uri.request_uri)
+      req.body = body
+      req.add_field("Content-Type", "application/json")
+      make_api_request(req, uri, parse)
+    end
+
+    def multipart_post(path, params, parse = true)
+      uri = base_uri("#{api_prefix}/#{path}")        
+      req = Net::HTTP::Post::Multipart.new(uri.request_uri, params)
+      make_api_request(req, uri, parse)
+    end
+
+    def post(path, body ="", parse = true)        
+      uri = base_uri("#{api_prefix}/#{path}")        
+      req = Net::HTTP::Post.new(uri.request_uri)
+      req.body = body
+      req.add_field("Content-Type", "application/json")
+      make_api_request(req, uri, parse)
+    end
+
+    def delete(path, parse=true)
+      uri = base_uri("#{api_prefix}/#{path}")
+      req = Net::HTTP::Delete.new(uri.request_uri)
+      make_api_request(req, uri, parse)
+    end
+
+    def make_api_request(req, uri, parse = true)        
+      if self.access_token && self.secret_key
+        req = ApiAuth.sign!(req, self.access_token, self.secret_key)      
+      end
+      make_request(req, uri, parse)
+    end
+
+    def make_request(req, uri, parse = true)
+      req.add_field("Accept", "text/json")
+      n = Net::HTTP.new(uri.host, uri.port)
+      if uri.scheme == "https"
+        n.use_ssl = true        
+      end
+      res = n.start do |http|
+        http.request(req)
+      end      
+      parse_response(res, parse)
+    end
+
+    def parse_response(res, parse)
+      if res.body !~ /^\s*$/ && !res.body.nil?
+        body = parse ? JSON.parse(res.body) : res.body
+      end
+
+      case res
+      when Net::HTTPNotFound
+        raise Coinfresh::Http::ResourceNotFound.new(body["message"])
+      when Net::HTTPSuccess
+        body
+      when Net::HTTPUnauthorized
+        raise Coinfresh::Http::Unauthorized.new(body["message"])
+      when Net::HTTPBadRequest
+        message = ""
+        if body["error"] 
+          message = [body["error"].to_s, body["message"].to_s].join(" ")
+        end
+
+        if body["errors"]
+          message = body["errors"]
+        end
+
+        raise Coinfresh::Http::BadRequest.new(message)        
+      when Net::HTTPSeeOther
+        res["Location"]
+      else
+        raise "Unknown #{res.class} response. #{body["message"]}"
+      end
+    end
+
+    private
+    
+    def api_prefix; "/api/v1"; end
+
+  end
+  
+end

data/lib/coinfresh/model/base.rb

@@ -0,0 +1,175 @@
+module Coinfresh
+  module Model
+    class ResourceNotSaved < Exception; end
+    class AttributeReadOnly < Exception; end
+
+    class Base
+
+      attr_accessor :client
+
+      def self.inspect
+        attr_list = attributes.inject([]) do |a, (attr, opts)|
+          a << "#{attr}: #{opts[:type]}"
+        end * ", "
+        "#{super}(#{attr_list})"
+      end
+      
+      def inspect
+        attr_list = self.class.attributes.inject([]) do |a, (attr, opts)|
+          if has_attribute?(attr)
+            a << "#{attr}: #{self[attr].inspect}"
+          else
+            a
+          end
+        end * ", "      
+        "#<#{self.class} #{attr_list}>"
+      end
+
+      def initialize(values = {}, client = nil)
+        self.client = client
+        values.each_pair do |k, v|
+          self.send("#{k}=", v) if respond_to?("#{k}=") && !v.nil?
+        end
+      end
+
+      def to_params
+        self.class.attributes.inject({}) do |h, (attr, opts)|
+          has_attribute?(attr) ? h.merge(attr => paramify(self[attr])) : h
+        end
+      end
+
+
+      class << self
+
+        attr_accessor :attributes
+        def set_attributes(attrs)
+          self.attributes = attrs
+          attrs.each_pair do |name, options|
+            attr_reader name
+            define_method "#{name}=" do |value|
+              if options[:readonly] && !instance_variable_get("@#{name}").nil?
+                raise AttributeReadOnly 
+              end
+              write_attribute("#{name}", convert_attribute(value, options))
+            end
+          end
+        end
+        
+        def inherited(subclass)
+          if !self.attributes.nil?
+            subclass.attributes = self.attributes
+          end
+        end
+
+        def has_association(name, klass, options = {})
+          attr_accessor "#{name}_id"
+          attr_reader name
+          self.attributes["#{name}_id".intern] = {type: :foreign_key}
+          define_method "#{name}=" do |attributes|
+            write_attribute("#{name}_id", attributes["id"])
+            if options[:polymorphic]
+              obj = polymorphic_object(attributes, options[:accepted_types])
+            else
+              obj = klass.new(attributes, client)
+            end
+            write_attribute("#{name}", obj)
+          end      
+        end
+
+        def has_many_association(name, klass, options = {})
+          attr_reader name
+          self.attributes[name.intern] = {type: :has_many_association}
+          define_method "#{name}=" do |arr|
+            many = arr.collect do |attributes| 
+              if options[:polymorphic]
+                polymorphic_object(attributes, options[:accepted_types])
+              else
+                klass.new(attributes, client)
+              end
+            end
+            write_attribute(name, many)
+          end      
+        end
+        
+      end
+        
+      def ==(o)
+        self.class == o.class && !self.id.nil? && self.id != "" && self.id == o.id
+      end
+      alias_method :eql?, :==
+
+      def [](val)
+        self.send(val)
+      end
+
+
+      def save
+        if self.id.nil?
+          #puts "saving #{self}, #{self.to_params}}"
+          item = api.create(self.to_params)          
+          puts "item: #{item.id}"
+          item
+        else
+          api.update(self.id, self.to_params)          
+        end
+      end
+
+      def reload
+        raise ResourceNotSaved if self.id.nil?      
+        api.find(self.id)
+      end
+
+      def destroy
+        raise ResourceNotSaved if self.id.nil?
+        api.destroy(self.id)
+      end
+
+      private
+      def write_attribute(name, value)
+        instance_variable_set("@#{name}", value)
+      end
+
+      def api
+        raise NotImplementedError
+      end
+
+      def has_attribute?(attr)
+        instance_variable_defined?("@#{attr}")
+      end
+
+      def paramify(val)      
+        if val.kind_of? Coinfresh::Model::Base
+          val.to_params
+        elsif val.kind_of? Array
+          val.collect{|v| paramify(v) }
+        else
+          val
+        end
+      end
+
+      def convert_attribute(val, options)
+        case options[:type]
+        when :int
+          val.to_i
+        when :string
+          val.to_s
+        when :date
+          val.kind_of?(Date) ? val : Date.parse(val)
+        when :decimal
+          val.to_f
+        when :boolean 
+          val == "true"
+        when :datetime 
+          val.kind_of?(DateTime) ? val : DateTime.parse(val)
+        when :datetime 
+          val.kind_of?(Time) ? val : Time.parse(val)
+        when :foreign_key 
+          (val == "" || val.nil?) ? nil : val.to_i
+        else 
+          val
+        end
+      end
+
+    end
+  end
+end

data/lib/coinfresh/model/cash_flow.rb

@@ -0,0 +1,17 @@
+module Coinfresh
+  module Model
+    class CashFlow < Base
+      set_attributes(id:              {type: :int, readonly: true},                  
+                   created_at:         {type: :datetime, readonly: true},
+                   cash_type:         {type: :string, readonly: true},
+                   amount:            {type: :decimal, readonly: true}                   
+                  )
+
+      private
+      def api
+        client.cash_flows
+      end
+
+    end
+  end
+end

data/lib/coinfresh/model/currency.rb

@@ -0,0 +1,18 @@
+module Coinfresh
+  module Model
+    class Currency < Base
+      set_attributes(id:              {type: :int, readonly: true},                  
+                   name:              {type: :string, readonly: true},
+                   ticker:            {type: :string, readonly: true},
+                   withdraw_transaction_fee: {type: :decimal, readonly: true},
+                   deposit_confirmations: {type: :int, readonly: true}
+                  )
+
+      private
+      def api
+        client.currencies
+      end
+
+    end
+  end
+end

data/lib/coinfresh/model/market.rb

@@ -0,0 +1,18 @@
+module Coinfresh
+  module Model
+    class Market < Base
+      set_attributes(id:              {type: :int, readonly: true},
+                   name:              {type: :string, readonly: true},
+                   last_price:        {type: :decimal, readonly: true}                   
+                  )
+
+      has_association :base_currency,       Coinfresh::Model::Currency
+      has_association :currency,            Coinfresh::Model::Currency
+
+      private
+      def api
+        client.markets
+      end
+    end
+  end
+end

data/lib/coinfresh/model/order.rb

@@ -0,0 +1,22 @@
+module Coinfresh
+  module Model
+    class Order < Base
+      set_attributes(id:              {type: :int, readonly: true},
+                   created_at:        {type: :datetime, readonly: true},
+                   updated_at:        {type: :datetime, readonly: true},
+                   filled_amount:     {type: :decimal, readonly: true},
+                   status:            {type: :string},
+                   order_type:        {type: :string},
+                   amount:            {type: :decimal},
+                   price:             {type: :decimal},
+                   market_id:         {type: :integer}
+                  )
+
+      private
+      def api
+        client.orders
+      end
+
+    end
+  end
+end

data/lib/coinfresh/model/trade.rb

@@ -0,0 +1,18 @@
+module Coinfresh
+  module Model
+    class Trade < Base
+      set_attributes(id:              {type: :int, readonly: true},
+                   created_at:        {type: :datetime, readonly: true},                   
+                   amount:            {type: :decimal, readonly: true},
+                   price:             {type: :decimal, readonly: true},                   
+                   buy_order_id:      {type: :int, readonly: true},
+                   sell_order_id:     {type: :int, readonly: true}
+                  )
+
+      private
+      def api
+        client.markets
+      end
+    end
+  end
+end

data/lib/coinfresh/model/wallet.rb

@@ -0,0 +1,22 @@
+module Coinfresh
+  module Model
+    class Wallet < Base
+      set_attributes(id:                {type: :int, readonly: true},                                  
+                    balance:            {type: :decimal, readonly: true}, 
+                    deposit_address:    {type: :string, readonly: true},    
+                    in_escrow:          {type: :decimal, readonly: true},      
+                    total_withdraw:     {type: :decimal, readonly: true},
+                    total_deposit:      {type: :decimal, readonly: true},
+                    unconfirmed_deposit: {type: :decimal, readonly: true},
+                  )
+
+      has_association :currency,  Coinfresh::Model::Currency
+
+      private
+      def api
+        client.wallets
+      end
+
+    end
+  end
+end

data/lib/coinfresh/model/withdraw.rb

@@ -0,0 +1,21 @@
+module Coinfresh
+  module Model
+    class Withdraw < Base
+      set_attributes(id:           {type: :int, readonly: true},                                  
+                    created_at:    {type: :datetime, readonly: true},                     
+                    address:       {type: :string, readonly: true},    
+                    amount:        {type: :decimal, readonly: true},      
+                    txid:          {type: :string, readonly: true},   
+                    status:        {type: :string, readonly: true},                      
+                  )
+
+      has_association :wallet,  Coinfresh::Model::Wallet
+
+      private
+      def api
+        client.withdraws
+      end
+
+    end
+  end
+end

data/lib/coinfresh/version.rb

@@ -0,0 +1,3 @@
+module Coinfresh
+  VERSION = "0.0.1"
+end

data/spec/api/cash_flow_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+module Coinfresh
+  module Api
+    describe CashFlow, :vcr do      
+
+      describe "#list" do
+        it "gets all the cashflows for currency" do
+          cash_flows = client.cash_flows.list(limit: 2, currency: 'BTC')
+          expect(cash_flows.count).to be > 0
+          cash_flow = cash_flows.first
+          expect(cash_flow.id).not_to be_nil
+          expect(cash_flow.created_at).not_to be_nil
+          expect(cash_flow.amount).not_to be_nil
+          expect(cash_flow.cash_type).not_to be_nil          
+        end
+      end
+      
+    end
+
+  end
+
+end