iron_warbler 2.0.7.19 → 2.0.7.21

data/app/controllers/iro/strategies_controller.rb

@@ -3,11 +3,6 @@ class Iro::StrategiesController < Iro::ApplicationController
 
   before_action :set_lists
 
-  def new
-    @strategy = Iro::Strategy.new
-    authorize! :new, @posision
-  end
-
   def create
     @strategy = Iro::Strategy.new params[:strategy].permit!
     authorize! :create, @strategy
@@ -37,7 +32,12 @@ class Iro::StrategiesController < Iro::ApplicationController
   def index
     authorize! :index, Iro::Strategy
     @strategies = Iro::Strategy.all
-    render '_table'
+    # render '_table'
+  end
+
+  def new
+    @strategy = Iro::Strategy.new
+    authorize! :new, @posision
   end
 
   def update
@@ -60,7 +60,7 @@ class Iro::StrategiesController < Iro::ApplicationController
 
   def set_lists
     @strategies_list = Iro::Strategy.list
-    @tickers_list = Iro::Stock.tickers_list
+    @tickers_list    = Iro::Stock.list
   end
 
 end

data/app/helpers/iro/application_helper.rb

@@ -1,4 +1,7 @@
-module Iro
-  module ApplicationHelper
+module Iro::ApplicationHelper
+
+  def pp_delta delta
+    '%.2f' % delta rescue '-'
   end
+
 end

data/app/jobs/tda_job.rb

@@ -0,0 +1,14 @@
+
+# require 'net/scp'
+# require 'open3'
+require 'sidekiq'
+
+class Iro::TdaJob
+  include Sidekiq::Job
+  sidekiq_options queue: 'iro_wor_rb'
+
+  def perform
+
+  end
+
+end

data/app/models/iro/datapoint.rb

@@ -5,15 +5,34 @@ class Iro::Datapoint
   include Mongoid::Timestamps
   store_in collection: 'iro_datapoints'
 
-  field :date
+  field :kind ## PUT, CALL, STOCK, CURRENCY, CRYPTO
+  validates :kind, presence: true
+  index({ kind: -1 })
+
+  field :symbol ## ticker, but use 'symbol' ONLY
+
+  field :date, type: Date ## @obsolete, use quote_at
   index({ kind: -1, date: -1 })
 
+  field :quote_at, type: DateTime
+  index({ kind: -1, quote_at: -1 })
+  validates :quote_at, uniqueness: { scope: [ :kind, :symbol ] }
+
+  field :open, type: Float
+  field :high, type: Float
+  field :low, type: Float
+
   field :value, type: Float
   validates :value, presence: true
+  def close
+    value
+  end
+  def close= a
+    value= a
+  end
+
+  field :volume, type: Integer
 
-  field :kind
-  validates :kind, presence: true
-  index({ kind: -1 })
 
   def self.test_0trash
     add_fields = { '$addFields':  {
@@ -21,10 +40,10 @@ class Iro::Datapoint
         '$dateToString': { 'format': "%Y-%m-%d", 'date': "$created_at" }
       }
     } }
-    group = { '$group': {
-      '_id': "$date_string",
-      'my_doc': { '$first': "$$ROOT" }
-    } }
+    # group = { '$group': {
+    #   '_id': "$date_string",
+    #   'my_doc': { '$first': "$$ROOT" }
+    # } }
     group = { '$group': {
       '_id': "$date",
       'my_doc': { '$first': "$$ROOT" }
@@ -113,4 +132,25 @@ class Iro::Datapoint
     # puts! outs.to_a, 'result'
   end
 
+  def self.import_stock symbol:, path:
+    csv = CSV.read(path, headers: true)
+    csv.each do |row|
+      flag = create({
+        kind:    'STOCK',
+        symbol:   symbol,
+        date:     row['date'],
+        quote_at: row['date'],
+
+        volume: row['volume'],
+
+        open:  row['open'],
+        high:  row['high'],
+        low:   row['low'],
+        value: row['close'],
+      })
+      print '.' if flag.persisted?
+    end
+    puts 'ok'
+  end
+
 end

data/app/models/iro/position.rb

@@ -4,6 +4,8 @@ class Iro::Position
   include Mongoid::Timestamps
   store_in collection: 'iro_positions'
 
+  attr_accessor :gain_loss_amount
+
   STATUS_ACTIVE   = 'active'
   STATUS_PROPOSED = 'proposed'
   STATUSES = [ nil, 'active', 'inactive', 'proposed' ]
@@ -12,34 +14,48 @@ class Iro::Position
   scope :active, ->{ where( status: 'active' ) }
 
   belongs_to :purse,    class_name: 'Iro::Purse',    inverse_of: :positions
+  index({ purse_id: 1, ticker: 1 })
+
+  belongs_to :stock,   class_name: 'Iro::Stock',    inverse_of: :positions
+  def ticker
+    stock&.ticker || '-'
+  end
+
   belongs_to :strategy, class_name: 'Iro::Strategy', inverse_of: :positions
 
-  field :ticker
-  validates :ticker, presence: true
-  index({ purse_id: 1, ticker: 1 })
+  # field :ticker
+  # validates :ticker, presence: true
 
-  KINDS = [ nil, 'covered_call', 'credit_put_spread', 'credit_call_spread' ]
-  field :kind
+  field     :outer_strike, type: :float
+  # validates :outer_strike, presence: true
 
-  field :strike, type: :float
-  validates :strike, presence: true
+  field     :inner_strike, type: :float
+  validates :inner_strike, presence: true
 
   field :expires_on
   validates :expires_on, presence: true
 
   field :quantity, type: :integer
   validates :quantity, presence: true
+  def q; quantity; end
 
   field :begin_on
-  field :begin_price, type: :float
-  field :begin_delta, type: :float
+  field :begin_outer_price, type: :float
+  field :begin_outer_delta, type: :float
+
+  field :begin_inner_price, type: :float
+  field :begin_inner_delta, type: :float
 
   field :end_on
-  field :end_price, type: :float
-  field :end_delta, type: :float
+  field :end_outer_price, type: :float
+  field :end_outer_delta, type: :float
 
-  field :net_amount
-  field :net_percent
+  field :end_inner_price, type: :float
+  field :end_inner_delta, type: :float
+
+  def breakeven
+    strategy.breakeven(self)
+  end
 
   def current_underlying_strike
     Iro::Stock.find_by( ticker: ticker ).last
@@ -59,6 +75,19 @@ class Iro::Position
     print '_'
   end
 
+  def net_percent
+    net_amount / max_gain
+  end
+  def net_amount # each
+    strategy.send("net_amount_#{strategy.kind}", self)
+  end
+  def max_gain # each
+    strategy.send("max_gain_#{strategy.kind}", self)
+  end
+  def max_loss # each
+    strategy.send("max_loss_#{strategy.kind}", self)
+  end
+
 
   field :next_delta, type: :float
   field :next_outcome, type: :float
@@ -67,6 +96,10 @@ class Iro::Position
   field :next_reasons, type: :array, default: []
   field :should_rollp, type: :float
 
+  ##
+  ## decisions
+  ##
+
   def should_roll?
     puts! 'shold_roll?'
 
@@ -83,7 +116,7 @@ class Iro::Position
       if end_delta < strategy.threshold_delta
         next_reasons.push "delta is lower than threshold"
         out = 0.91
-      elsif 1 - end_price/begin_price > strategy.threshold_netp
+      elsif 1 - end_outer_price/begin_outer_price > strategy.threshold_netp
         next_reasons.push "made enough percent profit (dubious)"
         out = 0.61
       else
@@ -219,4 +252,12 @@ class Iro::Position
     return out
   end
 
+  def to_s
+    out = "#{stock} (#{q}) #{expires_on.to_datetime.strftime('%b %d')} #{strategy.kind_short} ["
+    if outer_strike
+      out = out + "$#{outer_strike}->"
+    end
+    out = out + "$#{inner_strike}] "
+    return out
+  end
 end

data/app/models/iro/price_item.rb

@@ -4,6 +4,7 @@ class Iro::PriceItem
   include Mongoid::Timestamps
   store_in collection: 'iro_price_items'
 
+  ## PUT, CALL, STOCK
   field :putCall,         type: String
   field :symbol,          type: String
   field :ticker,          type: String
@@ -15,9 +16,9 @@ class Iro::PriceItem
   field :last,            type: Float
 
   field :openPrice,       type: Float
-  field :closePrice,      type: Float
   field :lowPrice,        type: Float
   field :highPrice,       type: Float
+  field :closePrice,      type: Float
 
   field :quoteTimeInLong, type: Integer
   field :timestamp,       type: Integer
@@ -26,4 +27,53 @@ class Iro::PriceItem
   field :exchangeName,    type: String
   field :volatility,      type: Float
 
+  def self.my_find props={}
+    lookup = { '$lookup': {
+      'from':         'iro_price_items',
+      'localField':   'date',
+      'foreignField': 'date',
+      'pipeline': [
+        { '$sort': { 'value': -1 } },
+      ],
+      'as':           'dates',
+    } }
+    lookup_merge = { '$replaceRoot': {
+      'newRoot': { '$mergeObjects': [
+        { '$arrayElemAt': [ "$dates", 0 ] }, "$$ROOT"
+      ] }
+    } }
+
+
+    match = { '$match': {
+      'date': {
+        '$gte': props[:begin_on],
+        '$lte': props[:end_on],
+      }
+    } }
+
+    group = { '$group': {
+      '_id': "$date",
+      'my_doc': { '$first': "$$ROOT" }
+    } }
+
+    outs = Iro::Date.collection.aggregate([
+      match,
+
+      lookup,
+      lookup_merge,
+
+      group,
+      { '$replaceRoot': { 'newRoot': "$my_doc" } },
+      # { '$replaceRoot': { 'newRoot': "$my_doc" } },
+
+
+      { '$project': { '_id': 0, 'date': 1, 'value': 1 } },
+      { '$sort': { 'date': 1 } },
+    ])
+
+    puts! 'result'
+    pp outs.to_a
+    # puts! outs.to_a, 'result'
+  end
+
 end

data/app/models/iro/purse.rb

@@ -10,6 +10,10 @@ class Iro::Purse
 
   has_many :positions, class_name: 'Iro::Position', inverse_of: :purse
 
+  field :unit,             type: :integer
+  field :height,           type: :integer
+  field :mark_every_n_usd, type: :float
+
   def to_s
     slug
   end

data/app/models/iro/stock.rb

@@ -18,13 +18,16 @@ class Iro::Stock
 
   field :last, type: :float
 
-
-  # has_many :strategies, class_name: 'Iro::Strategy', inverse_of: :stock
+  has_many :positions,  class_name: 'Iro::Position', inverse_of: :stock
+  has_many :strategies, class_name: 'Iro::Strategy', inverse_of: :stock
 
   def to_s
     ticker
   end
   def self.list
+    [[nil,nil]] + all.map { |sss| [ sss.ticker, sss.id ] }
+  end
+  def self.tickers_list
     [[nil,nil]] + all.map { |sss| [ sss.ticker, sss.ticker ] }
   end
 end

data/app/models/iro/strategy.rb

@@ -7,17 +7,43 @@ class Iro::Strategy
   field :slug
   validates :slug, presence: true, uniqueness: true
 
+  LONG = 'is_long'
+  SHORT = 'is_short'
+  field     :long_or_short, type: :string
+  validates :long_or_short, presence: true
+
+  field :description
+
   has_many :positions, class_name: 'Iro::Position', inverse_of: :strategy
 
-  ## multiple strategies per ticker
-  field :ticker
-  validates :ticker, presence: true
-  index({ ticker: 1 })
-  # belongs_to :stock, class_name: 'Iro::Stock', inverse_of: :strategies
+  belongs_to :stock, class_name: 'Iro::Stock', inverse_of: :strategies
 
+  KIND_COVERED_CALL = 'covered_call'
+  KIND_LONG_DEBIT_CALL_SPREAD = 'long_debit_call_spread'
+  KIND_SHORT_DEBIT_PUT_SPREAD = 'long_debit_call_spread'
+  KINDS = [ nil,
+    KIND_COVERED_CALL,
+    KIND_LONG_DEBIT_CALL_SPREAD,
+    KIND_SHORT_DEBIT_PUT_SPREAD,
+  ]
+  field :kind
+
+  def kind_short
+    case kind
+    when KIND_COVERED_CALL
+      'cc'
+    when KIND_LONG_DEBIT_CALL_SPREAD
+      'long-spread'
+    when KIND_SHORT_DEBIT_PUT_SPREAD
+      'short-spread'
+    else
+      '@TODO-zez'
+    end
+  end
 
   field :buffer_above_water, type: :float
-  field :next_max_delta, type: :float
+  field :next_max_inner_delta, type: :float
+  field :next_max_outer_delta, type: :float
   field :next_min_strike, type: :float
   field :threshold_delta, type: :float
   field :threshold_netp, type: :float
@@ -26,13 +52,61 @@ class Iro::Strategy
     where( ticker: ticker )
   end
 
+  def breakeven p
+    p.inner_strike - p.begin_outer_price + p.begin_inner_price
+  end
 
-  def to_s
-    slug
+  def breakeven p
+    p.inner_strike + p.begin_inner_price
   end
 
-  def self.list
-    [[nil,nil]] + all.map { |ttt| [ ttt.slug, ttt.id ] }
+  def max_gain_covered_call p
+    # return p.begin_inner_price
+    p.begin_inner_price * 100 - 0.66
+  end
+  def max_gain_long_debit_call_spread p
+    ## 100 * disalloed for gameui
+    ( p.inner_strike - p.outer_strike - p.begin_outer_price + p.begin_inner_price ) # - 2*0.66
+  end
+  def max_gain_short_debit_put_spread p
+    ## 100 * disalloed for gameui
+    ( p.outer_strike - p.inner_strike - p.begin_outer_price + p.begin_inner_price ) # - 2*0.66
+  end
+
+  def max_loss_covered_call p
+    return 'infinity'
+  end
+  def max_loss_long_debit_call_spread p
+    out = 100 * ( p.outer_strike - p.inner_strike )
+  end
+  def max_loss_short_debit_put_spread p
+    out = -100 * ( p.outer_strike - p.inner_strike )
   end
 
+  def net_amount_covered_call p
+    ( p.begin_inner_price - p.end_inner_price ) * 100
+  end
+  def net_amount_long_debit_call_spread p
+    outer = p.end_outer_price - p.begin_outer_price
+    inner = p.begin_inner_price - p.end_inner_price
+    out = ( outer + inner ) * 100
+  end
+  alias_method :net_amount_short_debit_put_spread, :net_amount_long_debit_call_spread
+
+
+  def net_amount_long_debit_call_spread p
+    outer = p.end_outer_price - p.begin_outer_price
+    inner = p.begin_inner_price - p.end_inner_price
+    out = ( outer + inner ) * 100
+  end
+
+
+
+  def to_s
+    slug
+  end
+  def self.list long_or_short = nil
+    these = long_or_short ? where( long_or_short: long_or_short ) : all
+    [[nil,nil]] + these.map { |ttt| [ ttt.slug, ttt.id ] }
+  end
 end

data/app/models/iro/trash/position_covered_call.rb

@@ -0,0 +1,4 @@
+
+class Iro::PositionCoveredCall < Iro::Position
+
+end