iron_warbler 2.0.7.7 → 2.0.7.9

data/app/models/iro/position.rb

@@ -0,0 +1,222 @@
+
+class Iro::Position
+  include Mongoid::Document
+  include Mongoid::Timestamps
+  store_in collection: 'iro_positions'
+
+  STATUS_ACTIVE   = 'active'
+  STATUS_PROPOSED = 'proposed'
+  STATUSES = [ nil, 'active', 'inactive', 'proposed' ]
+  field :status
+  validates :status, presence: true
+  scope :active, ->{ where( status: 'active' ) }
+
+  belongs_to :purse,    class_name: 'Iro::Purse',    inverse_of: :positions
+  belongs_to :strategy, class_name: 'Iro::Strategy', inverse_of: :positions
+
+  field :ticker
+  validates :ticker, presence: true
+  index({ purse_id: 1, ticker: 1 })
+
+  KINDS = [ nil, 'covered_call', 'credit_put_spread', 'credit_call_spread' ]
+  field :kind
+
+  field :strike, type: :float
+  validates :strike, presence: true
+
+  field :expires_on
+  validates :expires_on, presence: true
+
+  field :quantity, type: :integer
+  validates :quantity, presence: true
+
+  field :begin_on
+  field :begin_price, type: :float
+  field :begin_delta, type: :float
+
+  field :end_on
+  field :end_price, type: :float
+  field :end_delta, type: :float
+
+  field :net_amount
+  field :net_percent
+
+  def current_underlying_strike
+    Iro::Stock.find_by( ticker: ticker ).last
+  end
+
+  def refresh
+    out = Tda::Option.get_quote({
+      contractType:   'CALL',
+      strike:         strike,
+      expirationDate: expires_on,
+      ticker:         ticker,
+    })
+    update({
+      end_delta: out[:delta],
+      end_price: out[:last],
+    })
+    print '_'
+  end
+
+
+  field :next_delta, type: :float
+  field :next_outcome, type: :float
+  field :next_symbol
+  field :next_mark
+  field :next_reasons, type: :array, default: []
+  field :should_rollp, type: :float
+
+  def should_roll?
+    puts! 'shold_roll?'
+
+    update({
+      next_reasons: [],
+      next_symbol: nil,
+      next_delta: nil,
+    })
+
+    if must_roll?
+      out = 1.0
+    elsif can_roll?
+
+      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
+        next_reasons.push "made enough percent profit (dubious)"
+        out = 0.61
+      else
+        next_reasons.push "neutral"
+        out = 0.33
+      end
+
+    else
+      out = 0.0
+    end
+
+    update({
+      next_delta:   next_position[:delta],
+      next_outcome: next_position[:mark] - end_price,
+      next_symbol:  next_position[:symbol],
+      next_mark:    next_position[:mark],
+      should_rollp: out,
+      # status:       Iro::Position::STATE_PROPOSED,
+    })
+
+    puts! next_reasons, 'next_reasons'
+    puts! out, 'out'
+    return out > 0.5
+  end
+
+
+  ## expires_on = cc.expires_on ; nil
+  def can_roll?
+    ## only if less than 7 days left
+    ( expires_on.to_date - Time.now.to_date ).to_i < 7
+  end
+
+  ## If I'm near below water
+  ##
+  ## expires_on = cc.expires_on ; strategy = cc.strategy ; strike = cc.strike ; nil
+  def must_roll?
+    if ( current_underlying_strike + strategy.buffer_above_water ) > strike
+      return true
+    end
+    ## @TODO: This one should not happen, I should log appropriately. _vp_ 2023-03-19
+    if ( expires_on.to_date - Time.now.to_date ).to_i < 1
+      return true
+    end
+  end
+
+  ## strike = cc.strike ; strategy = cc.strategy ; nil
+  def near_below_water?
+    strike < current_underlying_strike + strategy.buffer_above_water
+  end
+
+
+
+  ## 2023-03-18 _vp_ Continue.
+  ## 2023-03-19 _vp_ Continue.
+  ## 2023-08-05 _vp_ an Important method
+  ##
+  ## expires_on = cc.expires_on ; strategy = cc.strategy ; ticker = cc.ticker ; end_price = cc.end_price ; next_expires_on = cc.next_expires_on ; nil
+  ##
+  ## out.map { |p| [ p[:strikePrice], p[:delta] ] }
+  ##
+  def next_position
+    return @next_position if @next_position
+    return {} if ![ STATUS_ACTIVE, STATUS_PROPOSED ].include?( status )
+
+    ## 7 days ahead - not configurable so far
+    out = Tda::Option.get_quotes({
+      ticker: ticker,
+      expirationDate: next_expires_on,
+      contractType: 'CALL',
+    })
+
+    ## above_water
+    if strategy.buffer_above_water.present?
+      out = out.select do |i|
+        i[:strikePrice] > current_underlying_strike + strategy.buffer_above_water
+      end
+      # next_reasons.push "buffer_above_water above #{current_underlying_strike + strategy.buffer_above_water}"
+    end
+
+    if near_below_water?
+      msg = "Panic! climb at a loss. Skip the rest of the calculation."
+      next_reasons.push msg
+      ## @TODO: if not enough money in the purse, cannot roll? 2023-03-19
+
+      # byebug
+
+      ## Take a small loss here.
+      prev = nil
+      out.each_with_index do |i, idx|
+        next if idx == 0
+        if i[:last] < end_price
+          prev ||= i
+        end
+      end
+      out = [ prev ]
+
+    else
+      ## Normal flow, making money.
+      ## @TODO: test! _vp_ 2023-03-19
+
+      ## next_min_strike
+      if strategy.next_min_strike.present?
+        out = out.select do |i|
+          i[:strikePrice] >= strategy.next_min_strike
+        end
+        # next_reasons.push "next_min_strike above #{strategy.next_min_strike}"
+      end
+      # json_puts! out.map { |p| [p[:delta], p[:symbol]] }, 'next_min_strike'
+
+      ## max_delta
+      if strategy.next_max_delta.present?
+        out = out.select do |i|
+          i[:delta] = 0.0 if i[:delta] == "NaN"
+          i[:delta] <= strategy.next_max_delta
+        end
+        # next_reasons.push "next_max_delta below #{strategy.next_max_delta}"
+      end
+      # json_puts! out.map { |p| [p[:delta], p[:symbol]] }, 'next_max_delta'
+    end
+
+    @next_position = out[0] || {}
+  end
+
+  ## @TODO: Test this. _vp_ 2023-04-01
+  def next_expires_on
+    out = expires_on.to_time + 7.days
+    while !out.friday?
+      out = out + 1.day
+    end
+    while !out.workday?
+      out = out - 1.day
+    end
+    return out
+  end
+
+end

data/app/models/iro/price_item.rb

@@ -1,4 +1,7 @@
 
-class Iro::PriceItem < Iro::ApplicationRecord
-  self.table_name = 'iro_price_items'
+class Iro::PriceItem
+  include Mongoid::Document
+  include Mongoid::Timestamps
+  store_in collection: 'iro_price_items'
+
 end

data/app/models/iro/purse.rb

@@ -0,0 +1,17 @@
+
+class Iro::Purse
+  include Mongoid::Document
+  include Mongoid::Timestamps
+  store_in collection: 'iro_purses'
+
+  field :slug
+  validates :slug, presence: true, uniqueness: true
+  index({ slug: -1 }, { unique: true })
+
+  has_many :positions, class_name: 'Iro::Position', inverse_of: :purse
+
+  def to_s
+    slug
+  end
+
+end

data/app/models/iro/stock.rb

@@ -1,18 +1,29 @@
 
-##
-## SQL
-##
-class Iro::Stock < Iro::ApplicationRecord
-  self.table_name = 'iro_stocks'
+class Iro::Stock
+  include Mongoid::Document
+  include Mongoid::Timestamps
+  store_in collection: 'iro_stocks'
 
   STATUS_ACTIVE   = 'active'
   STATUS_INACTIVE = 'inactive'
-  STATUSES        = [ 'active', 'inactive' ]
+  STATUSES        = [ nil, 'active', 'inactive' ]
+  def self.active
+    where( status: STATUS_ACTIVE )
+  end
+  field :status
 
+  field :ticker
   validates :ticker, uniqueness: true, presence: true
 
-  def self.active
-    where( status: STATUS_ACTIVE )
+  field :last, type: :float
+
+  def self.list
+  end
+
+  def self.tickers_list
+    [nil] + all.map( &:ticker )
   end
 
+  # has_many :strategies, class_name: 'Iro::Strategy', inverse_of: :stock
+
 end

data/app/models/iro/strategy.rb

@@ -0,0 +1,38 @@
+
+class Iro::Strategy
+  include Mongoid::Document
+  include Mongoid::Timestamps
+  store_in collection: 'iro_strategies'
+
+  field :slug
+  validates :slug, presence: true, uniqueness: true
+
+  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
+
+
+  field :buffer_above_water, type: :float
+  field :next_max_delta, type: :float
+  field :next_min_strike, type: :float
+  field :threshold_delta, type: :float
+  field :threshold_netp, type: :float
+
+  def self.for_ticker ticker
+    where( ticker: ticker )
+  end
+
+
+  def to_s
+    slug
+  end
+
+  def self.list
+    [[nil,nil]] + all.map { |ttt| [ ttt.slug, ttt.id ] }
+  end
+
+end

data/app/models/tda/option.rb

@@ -0,0 +1,137 @@
+
+require 'httparty'
+
+class Tda::Option
+
+  include ::HTTParty
+  base_uri 'https://api.tdameritrade.com'
+
+
+  ##
+  ## 2023-02-05 _vp_ :: Gets the entire chain
+  ##
+  def self.get_chain params
+    opts = { symbol: params[:ticker] } ## use 'GME' as symbol here even though a symbol is eg 'GME_021023P2.5'
+    query = { apikey: ::TD_AMERITRADE[:apiKey] }.merge opts
+    # puts! query, 'input opts'
+
+    path = "/v1/marketdata/chains"
+    out = self.get path, { query: query }
+    timestamp = DateTime.parse out.headers['date']
+    out = out.parsed_response.deep_symbolize_keys
+
+
+    outs = []
+    %w| put call |.each do |contractType|
+      tmp_sym = "#{contractType}ExpDateMap".to_sym
+      _out = out[tmp_sym]
+      _out.each do |date, vs| ## date="2023-02-10:5"
+        vs.each do |strike, _v| ## strike="18.5"
+          v = _v[0] ## v={} many attrs
+          v = v.except( :lastSize, :optionDeliverablesList, :settlementType,
+            :deliverableNote, :pennyPilot, :mini )
+          v.each do |k, i|
+            if i == 'NaN'
+              v[k] = nil
+            end
+          end
+
+          v[:timestamp] = timestamp
+          v[:ticker] = params[:ticker]
+          outs.push( v )
+        end
+      end
+    end
+
+    outs.each do |x|
+      opi = ::Iro::OptionPriceItem.create( x )
+      if !opi.persisted?
+        puts! opi.errors.full_messages, "Cannot create OptionPriceItem"
+      end
+    end
+  end
+
+  ##
+  ## 2023-03-18 _vp_ This is what I should be using to check if a position should be rolled.
+  ##
+  def self.get_quote params
+    ::Tda::Option.get_quotes(params)[0]
+  end
+
+  ##
+  ## params: contractType, strike, expirationDate, ticker
+  ##
+  ## ow = { contractType: 'PUT', ticker: 'GME', date: '2022-12-09' }
+  ## query = {:apikey=>"<>", :toDate=>"2022-12-09", :fromDate=>"2022-12-09", :symbol=>"GME"}
+  ##
+  ## 2023-02-04 _vp_ :: Too specific, but I want the entire chain, every 1-min
+  ## 2023-02-06 _vp_ :: Continue.
+  ##
+  def self.get_quotes params
+    puts! params, 'Tda::Option#get_quotes'
+    opts = {}
+
+    #
+    # Validate input ???
+    #
+    validOpts = %i| contractType |
+    validOpts.each do |s|
+      if params[s]
+        opts[s] = params[s]
+      else
+        raise Iwa::InputError.new("Invalid input, missing '#{s}'.")
+      end
+    end
+    if params[:expirationDate]
+      opts[:fromDate] = opts[:toDate] = params[:expirationDate]
+    else
+      raise Iwa::InputError.new("Invalid input, missing 'date'.")
+    end
+    if params[:ticker]
+      opts[:symbol] = params[:ticker].upcase
+    else
+      raise Iwa::InputError.new("Invalid input, missing 'ticker'.")
+    end
+
+    if params[:strike]
+      opts[:strike] = params[:strike]
+    end
+
+    query = { apikey: ::TD_AMERITRADE[:apiKey] }.merge opts
+    # puts! query, 'input opts'
+
+    path = "/v1/marketdata/chains"
+    out = self.get path, { query: query }
+    timestamp = DateTime.parse out.headers['date']
+    ## out = HTTParty.get "https://api.tdameritrade.com#{path}", { query: query }
+    out = out.parsed_response.deep_symbolize_keys
+
+
+    tmp_sym = "#{opts[:contractType].to_s.downcase}ExpDateMap".to_sym
+    outs = []
+    out = out[tmp_sym]
+    out.each do |date, vs|
+      vs.each do |strike, _v|
+        v = _v[0]
+        v = v.except( :lastSize, :optionDeliverablesList, :settlementType,
+          :deliverableNote, :pennyPilot, :mini )
+        v[:timestamp] = timestamp
+        outs.push( v )
+      end
+    end
+
+    # puts! outs, 'outs'
+    return outs
+  end
+
+
+end
+
+=begin
+
+outs = Tda::Option.get_quotes({
+  contractType: 'CALL', strike: 20.0, expirationDate: '2024-01-12',
+  ticker: 'GME',
+})
+
+=end

data/app/views/iro/_analytics.erb

@@ -0,0 +1,16 @@
+
+<!-- Matomo -->
+<script>
+  var _paq = window._paq = window._paq || [];
+  /* tracker methods like "setCustomDimension" should be called before "trackPageView" */
+  _paq.push(['trackPageView']);
+  _paq.push(['enableLinkTracking']);
+  (function() {
+    var u="//analytics.wasya.co/";
+    _paq.push(['setTrackerUrl', u+'matomo.php']);
+    _paq.push(['setSiteId', '13']); /* 13 :: email.wasya.co */
+    var d=document, g=d.createElement('script'), s=d.getElementsByTagName('script')[0];
+    g.async=true; g.src=u+'matomo.js'; s.parentNode.insertBefore(g,s);
+  })();
+</script>
+<!-- End Matomo Code -->

data/app/views/iro/_main_header.haml

@@ -0,0 +1,23 @@
+
+.main-header.maxwidth
+
+  %i.fa.fa-compress.collapse-expand#collapseHeaderEmail
+    Iron Warbler
+
+  -# .header.collapse-expand#IroMenu
+  -#   %h5.title Iron Warbler
+
+  %ul
+    %li= link_to 'ROOT', root_path
+    %li
+      = link_to "Stocks (#{Iro::Stock.all.length})", stocks_path
+    -# %li= link_to 'Options', options_path
+    -# %li Max Pain
+    %li
+      = link_to "Alerts (#{Iro::Alert.all.length})", alerts_path
+    %li
+      = link_to "Purses (#{Iro::Purse.all.length})", purses_path
+    %li
+      = render '/iro/strategies/header'
+
+

data/app/views/iro/alerts/index.haml

@@ -1,5 +1,5 @@
 
-.iro-alerts--index
+.iro-alerts--index.maxwidth
   %h5 Iro Alerts
 
   %ul

data/app/views/iro/positions/_form.haml

@@ -0,0 +1,59 @@
+
+.positions--form
+  = form_for position do |f|
+    .actions
+      = f.submit
+
+    .field
+      %label Purse
+      -# = f.select :purse_id, options_for_select( @
+      = f.text_field :purse_id
+
+      %label Status
+      = f.select :status, options_for_select( Iro::Position::STATUSES, selected: position.status )
+
+    %br
+    %br
+
+    .field
+      %label Ticker
+      = f.select :ticker, options_for_select( @tickers_list, selected: position.ticker )
+
+
+      %label Kind
+      = f.select :kind, options_for_select( Iro::Position::KINDS, selected: position.kind )
+      %label Strategy
+      = f.select :strategy_id, options_for_select( @strategies_list, selected: position.strategy_id )
+
+
+      %label Strike
+      = f.text_field :strike
+
+    .field
+      %label Expires on
+      = f.text_field :expires_on
+
+
+      %label Quantity
+      = f.text_field :quantity
+
+    %br
+    %br
+
+    .flex-row
+      %label Begin on
+      = f.text_field :begin_on
+      %label Begin price
+      = f.text_field :begin_price
+      %label Begin delta
+      = f.text_field :begin_delta
+    .flex-row
+      %label End on
+      = f.text_field :end_on
+      %label End price
+      = f.text_field :end_price
+      %label End delta
+      = f.text_field :end_delta
+
+    .actions
+      = f.submit

data/app/views/iro/positions/_reasons.haml

@@ -0,0 +1,4 @@
+
+%ul.positions--reasons.modal-absolute.hide
+  - reasons.each do |nnn|
+    %li= nnn