jam-cloud/ruby/lib/jam_ruby/models/email_batch_scheduled_sessions.rb

module JamRuby
  class EmailBatchScheduledSessions < EmailBatchPeriodic

    BATCH_SIZE = 500
    SINCE_DAYS = 2
    MIN_HOURS_START = 2

    TMP_SNAP = 'scheduled_session_snapshot'
    TMP_USER = 'scheduled_session_user'

    def self.subject
      "New sessions have been scheduled that may be a good match for you!"
    end

    # def fetch_sessions
    #   objs = []
    #   MusicSession.open_sessions
    #     .where(['created_at > ?', time_since_last_batch(SINCE_DAYS)])
    #     .where(['scheduled_start >= ?', Time.now() + MIN_HOURS_START.hours])
    #     .find_each do |ss|
    #     block_given? ? yield(ss) : objs << ss
    #   end
    #   objs
    # end

    # inserts eligible sessions to temp table
    def prep_tmp_table
      ActiveRecord::Base.connection.execute("DROP TABLE IF EXISTS #{TMP_SNAP}")
      sql =<<SQL
SELECT 
  rs.instrument_id AS instrument_id, 
  msess.id AS session_id, 
  msess.user_id AS creator_id,
  users.last_jam_locidispid AS creator_score_idx
INTO TEMP TABLE #{TMP_SNAP} 
FROM music_sessions msess
INNER JOIN rsvp_slots AS rs ON rs.music_session_id = msess.id
LEFT JOIN rsvp_requests_rsvp_slots AS rrrs ON rrrs.rsvp_slot_id = rs.id
INNER JOIN users ON users.id = msess.user_id
WHERE
    musician_access = 't' AND
    approval_required = 'f' AND
    msess.created_at > '#{time_since_last_batch(SINCE_DAYS)}' AND
    scheduled_start >= '#{Time.now() + MIN_HOURS_START.hours}' AND
    (rrrs.rsvp_slot_id IS NULL OR rrrs.chosen != 't')
SQL
      ActiveRecord::Base.connection.execute(sql)
    end

    def fetch_recipients
      objs = []
      # load eligible sessions into tmp table
      self.prep_tmp_table
      ActiveRecord::Base.connection.execute("DROP TABLE IF EXISTS #{TMP_USER}")

      # load eligible recipients into tmp table
      sql =<<SQL
SELECT 
  users.id AS user_id, 
  users.last_jam_locidispid AS user_score_idx,
  tmp.session_id AS session_id, 
  tmp.creator_id AS creator_id, 
  tmp.creator_score_idx AS creator_score_idx
INTO TEMP TABLE #{TMP_USER}
FROM users
INNER JOIN musicians_instruments AS mi ON mi.user_id = users.id
LEFT JOIN #{TMP_SNAP} AS tmp ON tmp.instrument_id = mi.instrument_id
WHERE
    users.musician = 't' AND
    users.subscribe_email = 't' AND
    tmp.session_id IS NOT NULL
GROUP BY users.id, tmp.session_id, tmp.creator_id, tmp.creator_score_idx
SQL
      ActiveRecord::Base.connection.execute(sql)

      # select recipients whose score is below minimum threshold
      sql =<<SQL
SELECT DISTINCT user_id, scores.score AS latency
FROM #{TMP_USER}
INNER JOIN scores ON scores.alocidispid = #{TMP_USER}.creator_score_idx AND scores.blocidispid = #{TMP_USER}.user_score_idx 
WHERE
  scores.score < #{Score::MAX_YELLOW_LATENCY}
SQL
      results = ActiveRecord::Base.connection.execute(sql) 

      # now just get the sessions/latency for each distinct mail recipient
      results.each do |result|
        sql =<<SQL
SELECT session_id
FROM #{TMP_USER} 
WHERE 
  user_id = '#{result['user_id']}'
SQL
        user = User.find_by_id(result['user_id'])
        sessions = ActiveRecord::Base.connection.execute(sql).collect do |rr| 
          msess = MusicSession.where(['id = ?',rr['session_id']])
            .limit(1)
            .includes([:genre, :creator])
            .first
          msess.latency_store = result['latency']
          msess
        end
        block_given? ? yield(user, sessions) : objs << [user, sessions]
      end
      objs
    end

    def deliver_batch_sets!
      self.opt_in_count = 0
      sent = 0
      self.fetch_recipients do |receiver, sessions_and_latency|
        self.opt_in_count += 1
        sent += 1
        bset = EmailBatchSet.scheduled_session_set(self, receiver, sessions_and_latency)
        UserMailer.scheduled_session_daily(receiver, sessions_and_latency).deliver
      end
      self.sent_count = sent
      self.save
      self.did_batch_run!
    end

    def self.send_daily_session_batch
      oo = self.create
      oo..deliver_batch
      oo
    end

  end
end