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

require 'kickbox'
include Devise::Models

module JamRuby
  class User < ActiveRecord::Base

    include Geokit::ActsAsMappable::Glue unless defined?(acts_as_mappable)
    include HtmlSanitize
    html_sanitize strict: [:first_name, :last_name, :city, :state, :country, :biography]

    #devise: for later: :trackable

    @@log = Logging.logger[User]

    VALID_EMAIL_REGEX = /\A[\w+\-.]+@([a-z\d\-]+\.)+[a-z]+\z/i
    JAM_REASON_REGISTRATION = 'r'
    JAM_REASON_NETWORK_TEST = 'n'
    JAM_REASON_FTUE = 'g'
    JAM_REASON_JOIN = 'j'
    JAM_REASON_IMPORT = 'i'
    JAM_REASON_LOGIN = 'l'

    # MOD KEYS
    MOD_GEAR = "gear"
    MOD_GEAR_FRAME_OPTIONS = "show_frame_options"

    MOD_NO_SHOW = "no_show"
    HOWTO_USE_VIDEO_NOSHOW = 'how-to-use-video'
    CONFIGURE_VIDEO_NOSHOW = 'configure-video'

    # MIN/MAX AUDIO LATENCY
    MINIMUM_AUDIO_LATENCY = 2
    MAXIMUM_AUDIO_LATENCY = 10000

    ONBOARDING_STATUS_UNASSIGNED = "Unassigned"
    ONBOARDING_STATUS_ASSIGNED = "Assigned"
    ONBOARDING_STATUS_EMAILED = "Emailed"
    ONBOARDING_STATUS_ONBOARDED = "Onboarded"
    ONBOARDING_STATUS_LOST = "Lost"
    ONBOARDING_STATUS_ESCALATED = "Escalated"
    ONBOARDING_STATUS_FREE_LESSON = "One Free Lesson Taken"
    ONBOARDING_STATUS_PAID_LESSON = "Paid Lesson Taken"
    ONBOARDING_STATUES = [ONBOARDING_STATUS_UNASSIGNED, ONBOARDING_STATUS_ASSIGNED, ONBOARDING_STATUS_EMAILED, ONBOARDING_STATUS_ONBOARDED, ONBOARDING_STATUS_LOST, ONBOARDING_STATUS_ESCALATED, ONBOARDING_STATUS_FREE_LESSON, ONBOARDING_STATUS_PAID_LESSON ]
    SESSION_OUTCOME_SUCCESSFUL = "Successful"
    SESSION_OUTCOME_SETUP_WIZARD_FAILURE = "Setup Wizard Failure"
    SESSION_OUTCOME_NO_AUDIO_STREAM = "No Audio Stream in Session"
    SESSION_OUTCOME_NO_VIDEO_STREAM = "No Video Stream In Session"
    SESSION_OUTCOME_OTHER = "Other"
    SESSION_OUTCOMES = [SESSION_OUTCOME_SUCCESSFUL, SESSION_OUTCOME_SETUP_WIZARD_FAILURE, SESSION_OUTCOME_NO_AUDIO_STREAM, SESSION_OUTCOME_NO_VIDEO_STREAM, SESSION_OUTCOME_OTHER]
    LOST_REASON_LOST_INTEREST = "Lost Interest"
    LOST_REASON_NO_COMPUTER = "No Win/Mac Computer"
    LOST_REASON_NO_BROADBAND = "No Broadband Internet"
    LOST_REASON_NO_WEBCAM = "No Webcam"
    LOST_REASON_BAD_INTERNET = "Bad Internet"
    LOST_REASON_SETUP_WIZARD_FAILURE  = "Setup Wizard Failure"
    LOST_REASON_NO_AUDIO_STREAM = "No Audio Stream In Session"
    LOST_REASON_NO_VIDEO_STREAM = "No Video Stream In Session"
    LOST_REASON_OTHER = "Other"
    LOST_REASONS = [LOST_REASON_LOST_INTEREST, LOST_REASON_NO_COMPUTER, LOST_REASON_NO_BROADBAND, LOST_REASON_NO_WEBCAM, LOST_REASON_BAD_INTERNET, LOST_REASON_SETUP_WIZARD_FAILURE, LOST_REASON_NO_AUDIO_STREAM, LOST_REASON_NO_VIDEO_STREAM, LOST_REASON_OTHER]
    ESCALATION_REASON_NO_AUDIO_STREAM = "No Audio Stream In Session"
    ESCALATION_REASON_NO_VIDEO_STREAM = "No Video Stream In Session"
    ESCALATION_REASON_SETUP_WIZARD_FAILURE  = "Setup Wizard Failure"
    ESCALATION_REASON_OTHER = "Other"
    ESCALATION_REASONS = [ESCALATION_REASON_NO_AUDIO_STREAM, ESCALATION_REASON_NO_VIDEO_STREAM, ESCALATION_REASON_SETUP_WIZARD_FAILURE, ESCALATION_REASON_OTHER]


    devise :database_authenticatable, :recoverable, :rememberable

    acts_as_mappable

    after_save :update_teacher_pct

    attr_accessible :first_name, :last_name, :email, :city, :password, :password_confirmation, :state, :country, :birth_date, :subscribe_email, :terms_of_service, :original_fpfile, :cropped_fpfile, :cropped_large_fpfile, :cropped_s3_path, :cropped_large_s3_path, :photo_url, :large_photo_url, :crop_selection

    # updating_password corresponds to a lost_password
    attr_accessor :test_drive_packaging, :validate_instruments, :updating_password, :updating_email, :updated_email, :update_email_confirmation_url, :administratively_created, :current_password, :setting_password, :confirm_current_password, :updating_avatar, :updating_progression_field, :mods_json, :expecting_gift_card, :purchase_required
    belongs_to :icecast_server_group, class_name: "JamRuby::IcecastServerGroup", inverse_of: :users, foreign_key: 'icecast_server_group_id'

    has_many :controlled_sessions, :class_name => "JamRuby::MusicSession", inverse_of: :session_controller, foreign_key: :session_controller_id

    # authorizations (for facebook, etc -- omniauth)
    has_many :user_authorizations, :class_name => "JamRuby::UserAuthorization"

    has_many :reviews, :class_name => "JamRuby::Review"
    has_one :review_summary, :class_name => "JamRuby::ReviewSummary", as: :target

    # calendars (for scheduling NOT in music_session)
    has_many :calendars, :class_name => "JamRuby::Calendar"

    # connections (websocket-gateway)
    has_many :connections, :class_name => "JamRuby::Connection"

    # friend requests
    has_many :sent_friend_requests, :class_name => "JamRuby::FriendRequest", :foreign_key => 'user_id'
    has_many :received_friend_requests, :class_name => "JamRuby::FriendRequest", :foreign_key => 'friend_id'

    # instruments
    has_many :musician_instruments, :class_name => "JamRuby::MusicianInstrument", :foreign_key => 'player_id'
    has_many :instruments, :through => :musician_instruments, :class_name => "JamRuby::Instrument"

    # bands
    has_many :band_musicians, :class_name => "JamRuby::BandMusician"
    has_many :bands, :through => :band_musicians, :class_name => "JamRuby::Band"
    belongs_to :teacher, :class_name => "JamRuby::Teacher", foreign_key: :teacher_id, inverse_of: :user

    # genres
    has_many :genre_players, as: :player, class_name: "JamRuby::GenrePlayer", dependent: :destroy
    has_many :genres, through: :genre_players, class_name: "JamRuby::Genre"

    # recordings
    has_many :owned_recordings, :class_name => "JamRuby::Recording", :foreign_key => "owner_id"
    has_many :recordings, :through => :claimed_recordings, :class_name => "JamRuby::Recording"
    has_many :claimed_recordings, :class_name => "JamRuby::ClaimedRecording", :inverse_of => :user
    has_many :playing_claimed_recordings, :class_name => "JamRuby::ActiveMusicSession", :inverse_of => :claimed_recording_initiator
    has_many :playing_jam_tracks, :class_name => "JamRuby::ActiveMusicSession", :inverse_of => :jam_track_initiator

    # VRFS-2916 jam_tracks.id is varchar: REMOVE
    # has_many :jam_tracks_played, :class_name => "JamRuby::PlayablePlay", :foreign_key => 'player_id', :conditions => "jam_track_id IS NOT NULL"
    # VRFS-2916 jam_tracks.id is varchar: ADD
    has_many :jam_tracks_played, -> { where("playable_type = 'JamRuby::JamTrack'") }, :class_name => "JamRuby::PlayablePlay", :foreign_key => 'player_id'

    # self.id = user_id in likes table
    has_many :likings, :class_name => "JamRuby::Like", :inverse_of => :user, :dependent => :destroy

    # self.id = likable_id in likes table
    has_many :likers, :as => :likable, :class_name => "JamRuby::Like", :dependent => :destroy

    # self.id = user_id in follows table
    has_many :followings, :class_name => "JamRuby::Follow", :inverse_of => :user, :dependent => :destroy

    # self.id = followable_id in follows table
    has_many :followers, :as => :followable, :class_name => "JamRuby::Follow", :dependent => :destroy

    # text messages
    has_many :text_messages, :class_name => "JamRuby::TextMessage", :foreign_key => "target_user_id"

    # notifications
    has_many :notifications, :class_name => "JamRuby::Notification", :foreign_key => "target_user_id"

    # chats
    has_many :chats, :class_name => "JamRuby::ChatMessage", :foreign_key => "user_id"

    # friends
    has_many :friendships, :class_name => "JamRuby::Friendship", :foreign_key => "user_id"
    has_many :friends, :through => :friendships, :class_name => "JamRuby::User"
    has_many :inverse_friendships, :class_name => "JamRuby::Friendship", :foreign_key => "friend_id"
    has_many :inverse_friends, :through => :inverse_friendships, :source => :user, :class_name => "JamRuby::User"

    # connections / music sessions
    has_many :created_music_sessions, :foreign_key => "user_id", :inverse_of => :user, :class_name => "JamRuby::ActiveMusicSession" # sessions *created* by the user
    has_many :music_sessions, :through => :connections, :class_name => "JamRuby::ActiveMusicSession"

    # invitations
    has_many :received_invitations, :foreign_key => "receiver_id", :inverse_of => :receiver, :class_name => "JamRuby::Invitation"
    has_many :sent_invitations, :foreign_key => "sender_id", :inverse_of => :sender, :class_name => "JamRuby::Invitation"

    # fan invitations
    has_many :received_fan_invitations, :foreign_key => "receiver_id", :inverse_of => :receiver, :class_name => "JamRuby::FanInvitation"
    has_many :sent_fan_invitations, :foreign_key => "sender_id", :inverse_of => :sender, :class_name => "JamRuby::FanInvitation"

    # band invitations
    has_many :received_band_invitations, :inverse_of => :receiver, :foreign_key => "user_id", :class_name => "JamRuby::BandInvitation"
    has_many :sent_band_invitations, :inverse_of => :sender, :foreign_key => "creator_id", :class_name => "JamRuby::BandInvitation"

    # session history
    has_many :music_session_histories, :foreign_key => "user_id", :class_name => "JamRuby::MusicSession", :inverse_of => :user
    has_many :music_session_user_histories, :foreign_key => "user_id", :class_name => "JamRuby::MusicSessionUserHistory", :inverse_of => :user

    # saved tracks
    has_many :recorded_tracks, :foreign_key => "user_id", :class_name => "JamRuby::RecordedTrack", :inverse_of => :user
    has_many :recorded_videos, :foreign_key => "user_id", :class_name => "JamRuby::RecordedVideo", :inverse_of => :user
    has_many :recorded_backing_tracks, :foreign_key => "user_id", :class_name => "JamRuby::RecordedBackingTrack", :inverse_of => :user
    has_many :quick_mixes, :foreign_key => "user_id", :class_name => "JamRuby::QuickMix", :inverse_of => :user
    has_many :recorded_jam_track_tracks, :foreign_key => "user_id", :class_name => "JamRuby::RecordedJamTrackTrack", :inverse_of => :user

    # jam track recordings started
    has_many :initiated_jam_track_recordings, :foreign_key => 'jam_track_initiator_id', :class_name => "JamRuby::Recording", :inverse_of => :jam_track_initiator

    # invited users
    has_many :invited_users, :foreign_key => "sender_id", :class_name => "JamRuby::InvitedUser"

    # crash dumps
    has_many :crash_dumps, :foreign_key => "user_id", :class_name => "JamRuby::CrashDump"

    # events
    has_many :event_sessions, :class_name => "JamRuby::EventSession"

    # gift cards
    has_many :gift_cards, :class_name => "JamRuby::GiftCard"
    has_many :gift_card_purchases, :class_name => "JamRuby::GiftCardPurchase"


    # affiliate_partner
    has_one :affiliate_partner, :class_name => "JamRuby::AffiliatePartner", :foreign_key => :partner_user_id, inverse_of: :partner_user
    belongs_to :affiliate_referral, :class_name => "JamRuby::AffiliatePartner", :foreign_key => :affiliate_referral_id, :counter_cache => :referral_user_count
    # diagnostics
    has_many :diagnostics, :class_name => "JamRuby::Diagnostic"

    # jam_tracks
    has_many :jam_track_rights, :class_name => "JamRuby::JamTrackRight", :foreign_key => "user_id"
    has_many :purchased_jam_tracks, -> { order(:created_at) }, :through => :jam_track_rights, :class_name => "JamRuby::JamTrack", :source => :jam_track

    # lessons
    has_many :lesson_purchases, :class_name => "JamRuby::LessonPackagePurchase", :foreign_key => "user_id", inverse_of: :user
    has_many :student_lesson_bookings, :class_name => "JamRuby::LessonBooking", :foreign_key => "user_id", inverse_of: :user
    has_many :teacher_lesson_bookings, :class_name => "JamRuby::LessonBooking", :foreign_key => "teacher_id", inverse_of: :teacher
    has_many :teacher_distributions, :class_name => "JamRuby::TeacherDistribution", :foreign_key => "teacher_id", inverse_of: :teacher
    has_many :teacher_payments, :class_name => "JamRuby::TeacherPayment", :foreign_key => "teacher_id", inverse_of: :teacher
    has_many :test_drive_package_choice_teachers, :class_name => "JamRuby::TestDrivePackageChoiceTeacher", :foreign_key => "teacher_id"
    has_many :test_drive_package_choices, :class_name => "JamRuby::TestDrivePackageChoice", :foreign_key => "user_id", inverse_of: :user
    belongs_to :desired_package, :class_name => "JamRuby::LessonPackageType", :foreign_key => "lesson_package_type_id", inverse_of: :user_desired_packages # used to hold whether user last wanted test drive 4/2/1
    belongs_to :lesson_package_needs_purchase, :class_name => "JamRuby::LessonPackageType", :foreign_key => "lesson_package_needs_purchase_id", inverse_of: :users_needing_purchase
    # Shopping carts
    has_many :shopping_carts, :class_name => "JamRuby::ShoppingCart"

    # score history
    has_many :from_score_histories, :class_name => "JamRuby::ScoreHistory", foreign_key: 'from_user_id'
    has_many :to_score_histories, :class_name => "JamRuby::ScoreHistory", foreign_key: 'to_user_id'
    has_many :sales, :class_name => 'JamRuby::Sale', dependent: :destroy
    has_many :recurly_transaction_web_hooks, :class_name => 'JamRuby::RecurlyTransactionWebHook', dependent: :destroy

    # This causes the authenticate method to be generated (among other stuff)
    #has_secure_password

    has_many :online_presences, :class_name => "JamRuby::OnlinePresence", :foreign_key => 'player_id'
    has_many :performance_samples, :class_name => "JamRuby::PerformanceSample", :foreign_key => 'player_id'

    has_one :musician_search, :class_name => 'JamRuby::MusicianSearch'
    has_one :band_search, :class_name => 'JamRuby::BandSearch'
    belongs_to :teacher, :class_name => 'JamRuby::Teacher', foreign_key: :teacher_id

    has_many :jam_track_session, :class_name => "JamRuby::JamTrackSession"

    has_many :taken_lessons, :class_name => "JamRuby::LessonSession", inverse_of: :user, foreign_key: :user_id
    has_many :taught_lessons, :class_name => "JamRuby::LessonSession", inverse_of: :teacher, foreign_key: :teacher_id
    belongs_to :school, :class_name => "JamRuby::School", inverse_of: :students
    belongs_to :onboarder, :class_name => "JamRuby::User", inverse_of: :onboarding_users, foreign_key: :onboarder_id
    has_many :onboarding_users, :class_name => "JamRuby::User", inverse_of: :onboarder, foreign_key: :onboarder_id
    has_one :owned_school, :class_name => "JamRuby::School", inverse_of: :user
    has_one :owned_retailer, :class_name => "JamRuby::Retailer", inverse_of: :user
    has_many :test_drive_package_choices, :class_name =>"JamRuby::TestDrivePackageChoice"
    has_many :jamblasters_users, class_name: "JamRuby::JamblasterUser"
    has_many :jamblasters, class_name: 'JamRuby::Jamblaster', through: :jamblasters_users
    has_many :proposed_slots, class_name: 'JamRuby::LessonBookingSlot', inverse_of: :proposer, dependent: :destroy, foreign_key: :proposer_id
    has_many :charges, class_name: 'JamRuby::Charge', dependent: :destroy
    has_many :posa_cards, class_name: 'JamRuby::PosaCard', dependent: :destroy

    before_save :default_anonymous_names
    before_save :create_remember_token, :if => :should_validate_password?
    before_save :stringify_avatar_info, :if => :updating_avatar

    after_save :after_save

    validates :first_name, length: {maximum: 50}, no_profanity: true
    validates :last_name, length: {maximum: 50}, no_profanity: true
    validates :biography, length: {maximum: 4000}, no_profanity: true
    validates :email, presence: true, format: {with: VALID_EMAIL_REGEX}
    validates :update_email, presence: true, format: {with: VALID_EMAIL_REGEX}, :if => :updating_email

    validates_length_of :password, minimum: 6, maximum: 100, :if => :should_validate_password?
    validates_presence_of :password_confirmation, :if => :should_validate_password?
    validates_confirmation_of :password, :if => :should_validate_password?

    validates :terms_of_service, :acceptance => {:accept => true, :on => :create, :allow_nil => false}
    validates :reuse_card, :inclusion => {:in => [true, false]}
    validates :is_a_student, :inclusion => {:in => [true, false]}
    validates :is_a_teacher, :inclusion => {:in => [true, false]}
    validates :has_redeemable_jamtrack, :inclusion => {:in => [true, false]}
    validates :gifted_jamtracks, presence: true, :numericality => {:less_than_or_equal_to => 100}
    validates :subscribe_email, :inclusion => {:in => [nil, true, false]}
    validates :musician, :inclusion => {:in => [true, false]}
    validates :show_whats_next, :inclusion => {:in => [nil, true, false]}
    validates :is_a_student, :inclusion => {:in => [true, false]}
    validates :is_a_teacher, :inclusion => {:in => [true, false]}
    validates :is_onboarder, :inclusion => {:in => [true, false, nil]}
    #validates :mods, json: true
    validates_numericality_of :last_jam_audio_latency, greater_than: MINIMUM_AUDIO_LATENCY, less_than: MAXIMUM_AUDIO_LATENCY, :allow_nil => true
    validates :last_jam_updated_reason, :inclusion => {:in => [nil, JAM_REASON_REGISTRATION, JAM_REASON_NETWORK_TEST, JAM_REASON_FTUE, JAM_REASON_JOIN, JAM_REASON_IMPORT, JAM_REASON_LOGIN]}

    # stored in cents
    validates_numericality_of :paid_sessions_hourly_rate, greater_than: 0, less_than: 200000, :if => :paid_sessions
    # stored in cents
    validates_numericality_of :paid_sessions_daily_rate, greater_than: 0, less_than: 5000000, :if => :paid_sessions

    # custom validators
    validate :validate_musician_instruments, if: :validate_instruments
    validate :validate_current_password
    validate :validate_update_email
    validate :validate_avatar_info
    validate :email_case_insensitive_uniqueness
    validate :update_email_case_insensitive_uniqueness, :if => :updating_email
    validate :validate_mods
    validate :presence_gift_card, :if => :expecting_gift_card

    scope :musicians, -> { where(:musician => true) }
    scope :fans, -> { where(:musician => false) }
    scope :geocoded_users, -> { where(User.arel_table[:last_jam_locidispid].not_eq(nil)) }
    scope :musicians_geocoded, -> { musicians.geocoded_users }
    scope :email_opt_in, -> { where(:subscribe_email => true) }
    scope :came_through_amazon, -> { joins(:posa_cards).where('posa_cards.lesson_package_type_id in (?)', LessonPackageType::AMAZON_PACKAGES + LessonPackageType::LESSON_PACKAGE_TYPES)}

    def after_save
      if school_interest && !school_interest_was
        if education_interest
            AdminMailer.partner({body: "#{email} signed up via the https://www.jamkazam.com/landing/jamclass/education page.\n\nFull list is here: https://www.jamkazam.com/admin/admin/education_interests", subject: "#{email} is interested in education"}).deliver_now
        else
          AdminMailer.partner({body: "#{email} signed up via the https://www.jamkazam.com/landing/jamclass/schools page.\n\nFull list is here: https://www.jamkazam.com/admin/admin/school_interests", subject: "#{email} is interested in schools"}).deliver_now
        end
        if owned_school.nil?
          school = School.new
          school.user = self
          school.education = education_interest
          school.save!
        end
      end

      if retailer_interest && !retailer_interest_was
          AdminMailer.partner({body: "#{email} signed up via the https://www.jamkazam.com/landing/jamclass/retailers page.\n\nFull list is here: https://www.jamkazam.com/admin/admin/retailer_interests", subject: "#{email} is interested in retailer program"}).deliver_now
        if owned_retailer.nil?
          retailer = Retailer.new
          retailer.user = self
          retailer.save!
        end
      end

      if onboarding_lost_reason_changed? ||
          onboarding_escalation_reason_changed? ||
          onboarder_id_changed? ||
          onboarding_email_5_sent_at_changed? ||
          first_onboarding_free_lesson_at_changed? ||
          first_onboarding_paid_lesson_at_changed? ||
          second_onboarding_free_lesson_at_changed? ||
          onboarding_onboarded_at_changed?

        updates = {onboarding_status: self.computed_onboarding_status}

        if onboarder_id_changed? && onboarder_id
          begin
          AdminMailer.ugly({to: onboarder.email, cc: APP_CONFIG.email_support_alias,
                            subject:'New student assigned to you',
                            body: "Hi #{onboarder.first_name},\n\nA new student has been assigned to you for onboarding. Please send the first introductory email to this student ASAP, and update the onboarding console to start tracking.\n\nNew User Email: #{email}\n\nOnboarding Management: https://www.jamkazam.com/client#/account/onboarder\n\nThanks!\n\nRegards,\nTeam JamKazam"}).deliver_now
          rescue
            puts "UNABLE TO INDICATE ONBOARDER ASSIGNED"
          end

        end

        if onboarding_onboarded_at_changed? && onboarding_onboarded_at
          begin
          body = "A new student has been onboarded!\n\nUser: #{name}, #{email}\nUser Admin URL:#{admin_url}\n\n"
          if onboarder
            body += "Onboarder: #{onboarder.name}, #{onboarder.email}\nOnboarder Admin URL: #{onboarder.admin_url}\n\n"
          end
          body += "Onboarding Management: https://www.jamkazam.com/client#/account/onboarder\n\n"
          AdminMailer.ugly({to: APP_CONFIG.email_support_alias,
                            subject:"Student '#{name}' successfully onboarded!",
                            body: body}).deliver_now
          rescue
            puts "UNABLE TO INDICATE ONBOARDED AT"
          end

        end

        if first_onboarding_free_lesson_at_changed? || first_onboarding_paid_lesson_at_changed? || second_onboarding_free_lesson_at?
          updates[:stuck_take_flesson] = false
          updates[:stuck_take_2nd_flesson] = false
          updates[:stuck_take_plesson] = false
        end

        if updates[:onboarding_status] == ONBOARDING_STATUS_ONBOARDED || updates[:onboarding_status] == ONBOARDING_STATUS_LOST || updates[:onboarding_status] == ONBOARDING_STATUS_ESCALATED
          updates[:send_onboarding_survey] = true
        end

        User.where(id: self.id).update_all(updates)
      end
    end

    def self.hourly_check
      send_onboarding_surveys
      send_take_lesson_poke
      first_lesson_instructions
    end

    def self.first_lesson_instructions
      User.came_through_amazon.joins(taken_lessons: [:music_session, :lesson_booking])
          .where('lesson_bookings.recurring = FALSE')
          .where('lesson_sessions.status = ?', LessonSession::STATUS_APPROVED)
          .where("scheduled_start - (INTERVAL '2 days') < ?", Time.now)
          .where('sent_first_lesson_instr_email_at is null')
          .where('second_onboarding_free_lesson_at is null').each do |user|

        UserMailer.amazon_first_lesson_instructions(user).deliver_now
        User.where(id: user.id).update_all(sent_first_lesson_instr_email_at: Time.now)
      end


    end

    def self.send_onboarding_surveys
      User.where(send_onboarding_survey: true, sent_onboarding_survey_at: nil).each do |user|
        UserMailer.onboarding_survey(user).deliver_now
        User.where(id: user.id).update_all(sent_onboarding_survey_at: Time.now)
      end
    end


    def self.send_take_lesson_poke
      User.came_through_amazon.where('remind_take_lesson_times <= 2').where('first_lesson_booked_at is NULL')
          .where('(remind_take_lesson_at is NULL AND users.created_at < ?) OR remind_take_lesson_at < ? ', 1.hours.ago, 2.days.ago).each do |user|
        user.send_lesson_poke
      end
    end

    def send_lesson_poke(first = false)
      if first && self.remind_take_lesson_times > 0
        return
      end


      UserMailer.amazon_prompt_take_lesson(self, Teacher.match_teacher(self).user, self.remind_take_lesson_times).deliver_now
      User.where(id: self.id).update_all(remind_take_lesson_at: Time.now, remind_take_lesson_times: self.remind_take_lesson_times + 1 )
    end

    def update_teacher_pct
      if teacher
        teacher.update_profile_pct
      end
    end

    def is_waiting_onboarding
      ONBOARDING_STATUS_UNASSIGNED == onboarding_status
    end

    def is_onboarding
      ONBOARDING_STATUS_ASSIGNED == onboarding_status || ONBOARDING_STATUS_ESCALATED == onboarding_status || ONBOARDING_STATUS_EMAILED == onboarding_status
    end

    def user_progression_fields
      @user_progression_fields ||= Set.new ["first_downloaded_client_at", "first_ran_client_at", "first_music_session_at", "first_real_music_session_at", "first_good_music_session_at", "first_certified_gear_at", "first_invited_at", "first_friended_at", "first_recording_at", "first_social_promoted_at", "first_played_jamtrack_at"]
    end

    def update_progression_field(field_name, time = DateTime.now)
      @updating_progression_field = true
      if self[field_name].nil?
        self[field_name] = time
        self.save
      end
    end

    def update_timezone(timezone)
      if timezone.nil?
        return
      end

      begin
        TZInfo::Timezone.get(timezone)
        User.where(id: self.id).update_all(timezone: timezone)
      rescue Exception => e
        @@log.error("unable to find timezone=#{timezone}, e=#{e}")
      end
    end

    def tz_safe
      tz_identifier = 'America/Chicago'
      if self.timezone
        tz_identifier = self.timezone
      end
      TZInfo::Timezone.get(tz_identifier)
    end

    # formats at 6:30 am. input should be UTC
    def local_hour_stmt(datetime)
      tz = tz_safe
      tz.utc_to_local(datetime).strftime("%l:%M %P").strip
    end
    def has_any_free_jamtracks
      has_redeemable_jamtrack || gifted_jamtracks > 0
    end

    def free_jamtracks
      (has_redeemable_jamtrack ? 1 : 0) + gifted_jamtracks
    end

    def show_free_jamtrack?
      ShoppingCart.user_has_redeemable_jam_track?(self)
    end

    def failed_qualification(reason)
      self.last_failed_certified_gear_at = DateTime.now
      self.last_failed_certified_gear_reason = reason
      self.save
    end

    def validate_musician_instruments
      errors.add(:musician_instruments, ValidationMessages::INSTRUMENT_MINIMUM_NOT_MET) if !administratively_created && musician && musician_instruments.length == 0
      errors.add(:musician_instruments, ValidationMessages::INSTRUMENT_LIMIT_EXCEEDED) if !administratively_created && musician && musician_instruments.length > 5
    end

    # let's work to stop junk from getting into the mods array; this is essentially the schema
    def validate_mods
      mods_json.each do |key, value|
        if key == MOD_NO_SHOW || key == MOD_GEAR
          errors.add(:mods, ValidationMessages::MODS_MUST_BE_HASH) unless value.is_a?(Hash)
        else
          errors.add(:mods, ValidationMessages::MODS_UNKNOWN_KEY)
        end
      end
    end

    def presence_gift_card
      if self.gift_cards.length == 0
        errors.add(:gift_card, ValidationMessages::NOT_FOUND)
      end
    end

    def validate_current_password
      # checks if the user put in their current password (used when changing your email, for instance)
      errors.add(:current_password, ValidationMessages::NOT_YOUR_PASSWORD) if should_confirm_existing_password? && !valid_password?(self.current_password)
    end

    def validate_update_email
      if updating_email && self.update_email == self.email
        errors.add(:update_email, ValidationMessages::EMAIL_MATCHES_CURRENT)
      elsif updating_email && User.where("email ILIKE ?", self.update_email).first != nil
        errors.add(:update_email, ValidationMessages::EMAIL_ALREADY_TAKEN)
      end
    end

    def validate_avatar_info
      if updating_avatar
        # we want to mak sure that original_fpfile and cropped_fpfile seems like real fpfile info objects (i.e, json objects from filepicker.io)
        errors.add(:original_fpfile, ValidationMessages::INVALID_FPFILE) if self.original_fpfile.nil? || self.original_fpfile["key"].nil? || self.original_fpfile["url"].nil?
        errors.add(:cropped_fpfile, ValidationMessages::INVALID_FPFILE) if self.cropped_fpfile.nil? || self.cropped_fpfile["key"].nil? || self.cropped_fpfile["url"].nil?
        errors.add(:cropped_large_fpfile, ValidationMessages::INVALID_FPFILE) if self.cropped_large_fpfile.nil? || self.cropped_large_fpfile["key"].nil? || self.cropped_large_fpfile["url"].nil?
      end
    end

    def email_case_insensitive_uniqueness
      # using the case insensitive unique check of active record will downcase the field, which is not what we want--we want to preserve original casing
      search = User.where("email ILIKE ?", self.email).first
      if search != nil && search != self
        errors.add(:email, ValidationMessages::EMAIL_ALREADY_TAKEN)
      end
    end

    def update_email_case_insensitive_uniqueness
      # using the case insensitive unique check of active record will downcase the field, which is not what we want--we want to preserve original casing
      search = User.where("update_email ILIKE ?", self.update_email).first
      if search != nil && search != self
        errors.add(:update_email, ValidationMessages::EMAIL_ALREADY_TAKEN)
      end
    end

    def online
      online?
    end

    def anonymous?
      first_name == 'Anonymous' && last_name == 'Anonymous'
    end

    def name
      if anonymous?
        'Anonymous'
      else
        "#{first_name} #{last_name}"
      end
    end

    def greetings
      if anonymous?
        "Hello -"
      else
        "Hello #{first_name} -"
      end

    end

    def location(country = false)
      loc = self.city.blank? ? '' : self.city
      loc = loc.blank? ? self.state : "#{loc}, #{self.state}" unless self.state.blank?
      if country
        loc = loc.blank? ? self.country : "#{loc}, #{self.country}" unless self.country.blank?
      end
      loc
    end

    def location= location_hash
      unless location_hash.nil?
        self.city = location_hash[:city]
        self.state = location_hash[:state]
        self.country = location_hash[:country]
      end
    end

    def musician?
      return musician
    end

    def should_validate_password?
      (updating_password || new_record?)
    end

    def should_confirm_existing_password?
      confirm_current_password
    end

    def end_user_created?
      return !administratively_created
    end

    def pending_friend_request?(user)
      FriendRequest.where("((user_id='#{self.id}' AND friend_id='#{user.id}') OR (user_id='#{user.id}' AND friend_id='#{self.id}')) AND status is null").size > 0
    end

    def friends?(user)
      self.friends.exists?(user.id)
    end

    def friend_count
      self.friends.size
    end

    # check if "this user" likes entity
    def likes?(entity)
      self.likings.where(:likable_id => entity.id).size > 0
    end

    def liking_count
      self.likings.size
    end

    def liker_count
      self.likers.size
    end

    # check if "this user" follows entity
    def following?(entity)
      self.followings.where(:followable_id => entity.id).size > 0
    end

    def following_count
      self.followings.size
    end

    def follower_count
      self.followers.size
    end

    def recording_count
      self.recordings.size
    end

    def age
      now = Time.now.utc.to_date
      self.birth_date.nil? ? nil : now.year - self.birth_date.year - (self.birth_date.to_date.change(:year => now.year) > now ? 1 : 0)
    end

    def session_count
      MusicSession.where("user_id = ? AND started_at IS NOT NULL", self.id).size
    end

    # count up any session you are RSVP'ed to
    def upcoming_session_count
      MusicSession.scheduled_rsvp(self, true).count
    end

    def purchased_jamtracks_count
      self.purchased_jam_tracks.count
    end

    def sales_count
      self.sales.count
    end

    def joined_score
      return nil unless has_attribute?(:score)
      a = read_attribute(:score)
      a.nil? ? nil : a.to_i
    end

    def music_session_id
      return nil unless has_attribute?(:music_session_id)
      read_attribute(:music_session_id)
    end

    # ===== ARTIFICIAL ATTRIBUTES CREATED BY ActiveMusicSession.ams_users, MusicSession.sms_users
    def full_score
      return nil unless has_attribute?(:full_score)
      a = read_attribute(:full_score)
      a.nil? ? nil : a.to_i
    end

    def internet_score
      return nil unless has_attribute?(:internet_score)
      a = read_attribute(:internet_score)
      a.nil? ? nil : a.to_i
    end

    def audio_latency
      return nil unless has_attribute?(:audio_latency)
      a = read_attribute(:audio_latency)
      a.nil? ? nil : a.to_i
    end

    # ====== END ARTIFICAL ATTRIBUTES

    def score_info(destination_user)
      if self.last_jam_locidispid && destination_user.last_jam_locidispid
        ActiveRecord::Base.connection.execute("select score from current_network_scores where alocidispid = #{self.last_jam_locidispid} and blocidispid = #{destination_user.last_jam_locidispid}").check
      else
        nil
      end
    end

    # mods comes back as text; so give ourselves a parsed version
    def mods_json
      @mods_json ||= mods ? mods : {}
    end

    # new_modes should be a regular hash with non-symbolized keys (vs symbolized keys)
    def mod_merge(new_mods)
      self.mods = (mods_json.merge(new_mods) do |key, old_val, new_val|
        if key == MOD_NO_SHOW || key == MOD_GEAR
          # we take the values from previous hash, and merge it with the new hash
          old_val.merge(new_val)
        else
          raise "unknown in mode_merge key: #{key}"
        end
      end)
      @mods_json = nil # invalidate this since we've updated self.mods

    end

    # any mod with the value 'null' will be deleted
    def delete_mod(root_key, sub_key)
      mod = mods_json
      root = mod[root_key]
      if root
        root.delete(sub_key)
        # check if root key is completely empty
        mod.delete(root_key) if root.length == 0
        # check if mod key is empty
        mod = nil if mod.length == 0
      end

      self.mods = mod.nil? ? nil : mod
      @mods_json = nil # invalidate this since we've updated self.mods
    end

    def get_mod(root_key, sub_key)
      mod = mods_json
      root = mod[root_key]
      root[sub_key] if root
    end

    def get_gear_mod(sub_key)
      get_mod(MOD_GEAR, sub_key)
    end

    def get_no_show_mod(sub_key)
      get_mod(MOD_NO_SHOW, sub_key)
    end

    def heartbeat_interval_client
      mods_json[:heartbeat_interval_client]
    end

    def connection_expire_time_client
      mods_json[:connection_expire_time_client]
    end

    def recent_history(session_id, claimed_recording_id)
      # used to exclude currently viewed recording
      recording_exclusion = "claimed_recordings.id != '#{claimed_recording_id}'" if claimed_recording_id
      recordings = Recording
                       .joins(:claimed_recordings)
                       .where(:owner_id => self.id)
                       .where("claimed_recordings.user_id = '#{self.id}'")
                       .where('claimed_recordings.is_public=true')
                       .where(recording_exclusion)
                       .order('created_at DESC')
                       .limit(10)

      # used to exclude currently viewed session
      session_exclusion = "music_sessions.id != '#{session_id}'" if session_id
      msh = MusicSession
                .where(:user_id => self.id)
                .where(:fan_access => true)
                .where(session_exclusion)
                .order('created_at DESC')
                .limit(10)


      results = recordings.concat(msh)
      results = results.sort! { |a, b| b.created_at <=> a.created_at }.first(5)
    end

    # returns the # of new notifications
    def new_notifications
      search = Notification.select('id').where(target_user_id: self.id)
      search = search.where('created_at > ?', self.notification_seen_at) if self.notification_seen_at
      search.count
    end

    # the user can pass in a timestamp string, or the keyword 'LATEST'
    # if LATEST is specified, we'll use the latest_notification as the timestamp
    # if not, just use seen as-is
    def update_notification_seen_at seen
      new_latest_seen = nil
      if seen == 'LATEST'
        latest = self.latest_notification
        new_latest_seen = latest.created_at if latest
      else
        new_latest_seen = seen
      end

      self.notification_seen_at = new_latest_seen
    end

    def latest_notification
      Notification.select('created_at').where(target_user_id: id).limit(1).order('created_at DESC').first
    end

    def confirm_email!
      self.email_confirmed = true
      self.email_needs_verification = false
    end

    def my_session_settings
      unless self.session_settings.nil?
        return self.session_settings
      else
        return ""
      end
    end

    def session_history(user_id, band_id = nil, genre = nil)
      return MusicSession.index(self, user_id, band_id, genre)
    end

    def session_user_history(user_id, session_id)
      return MusicSessionUserHistory.where("music_session_id='#{session_id}'")
    end

    # always returns a non-null value for photo-url,
    # using the generic avatar if no user photo available
    def resolved_photo_url
      if self.photo_url == nil || self.photo_url == ''
        "#{APP_CONFIG.external_root_url}/assets/shared/avatar_generic.png"
      else
        return self.photo_url
      end
    end

    def to_s
      return email unless email.nil?

      return name unless name.nil?

      id
    end



    def set_password(old_password, new_password, new_password_confirmation)

      # so that UserObserver knows to send a confirmation email on success
      self.setting_password = true
      # so that should_validate_password? fires
      self.updating_password = true

      attributes = {:password => new_password, :password_confirmation => new_password_confirmation}

      # taken liberally from Devise::DatabaseAuthenticatable.update_with_password

      if valid_password?(old_password)
        update_attributes(attributes)
      else
        self.assign_attributes(attributes)
        self.valid?
        self.errors.add(:current_password, old_password.blank? ? :blank : :invalid)
      end

      #clean_up_passwords

    end

    def self.set_password_from_token(email, token, new_password, new_password_confirmation)
      user = User.where("email ILIKE ?", email).first
      if user.nil? || user.reset_password_token != token || Time.now - user.reset_password_token_created > 3.days || new_password.length < 6 || new_password != new_password_confirmation
        raise JamRuby::JamArgumentError
      end
      user.reset_password_token = nil
      user.reset_password_token_created = nil
      user.change_password(new_password, new_password_confirmation)
      user.save
    end

    def change_password(new_password, new_password_confirmation)
      # FIXME: Should verify that the new password meets certain quality criteria. Really, maybe that should be a
      # verification step.
      self.updating_password = true
      self.password = new_password
      self.password_confirmation = new_password_confirmation
      UserMailer.password_changed(self).deliver_now
    end

    def self.reset_password(email, base_uri)
      user = User.where("email ILIKE ?", email).first
      raise JamRuby::JamArgumentError.new('unknown email', :email) if user.nil?

      user.reset_password_token = SecureRandom.urlsafe_base64
      user.reset_password_token_created = Time.now
      user.save

      reset_url = "#{base_uri}/reset_password_token?token=#{user.reset_password_token}&email=#{CGI.escape(email)}"
      UserMailer.password_reset(user, reset_url).deliver_now
      user
    end

    def self.band_index(user_id)
      bands = Band.joins(:band_musicians)
                  .where(:bands_musicians => {:user_id => "#{user_id}"})

      return bands
    end

    def self.recording_index(current_user, user_id)
      hide_private = false

      # hide private recordings from anyone but the current user
      if current_user.id != user_id
        hide_private = true
      end

      if hide_private
        recordings = Recording.joins(:musician_recordings)
                         .where(:musicians_recordings => {:user_id => "#{user_id}"}, :public => true)

      else
        recordings = Recording.joins(:musician_recordings)
                         .where(:musicians_recordings => {:user_id => "#{user_id}"})
      end

      return recordings
    end

    def update_genres(gids, genre_type)
      unless self.new_record?
        GenrePlayer.delete_all(["player_id = ? AND player_type = ? AND genre_type = ?",
                                self.id, self.class.name, genre_type])
      end

      gids.each do |gid|
        genre_player = GenrePlayer.new
        genre_player.player_id = self.id
        genre_player.player_type = self.class.name
        genre_player.genre_id = gid
        genre_player.genre_type = genre_type
        self.genre_players << genre_player
      end
    end

    def update_online_presences(online_presences)
      unless self.new_record?
        OnlinePresence.delete_all(["player_id = ?", self.id])
      end

      unless online_presences.nil?
        online_presences.each do |op|
          new_presence = OnlinePresence.create(self, op, false)
          self.online_presences << new_presence
        end
      end
    end

    def update_performance_samples(performance_samples)
      unless self.new_record?
        PerformanceSample.delete_all(["player_id = ?", self.id])
      end

      unless performance_samples.nil?
        performance_samples.each do |ps|
          new_sample = PerformanceSample.create(self, ps, false)
          self.performance_samples << new_sample
        end
      end
    end

    # Build calendars using given parameter.
    # @param calendars (array of hash)
    def update_calendars(calendars)
      unless self.new_record?
        Calendar.where("user_id = ?", self.id).delete_all
      end

      unless calendars.nil?
        calendars.each do |cal|
          self.calendars << self.calendars.create(cal)
        end
      end
    end

    # given an array of instruments, update a user's instruments
    def update_instruments(instruments)
      # delete all instruments for this user first
      unless self.new_record?
        MusicianInstrument.delete_all(["player_id = ?", self.id])
      end

      # loop through each instrument in the array and save to the db
      instruments.each do |musician_instrument_param|
        instrument = Instrument.find(musician_instrument_param[:instrument_id])
        musician_instrument = MusicianInstrument.new
        musician_instrument.player = self
        musician_instrument.instrument = instrument
        musician_instrument.proficiency_level = musician_instrument_param[:proficiency_level]
        musician_instrument.priority = musician_instrument_param[:priority]
        musician_instrument.save
        self.musician_instruments << musician_instrument
      end
    end

    # this easy_save routine guards against nil sets, but many of these fields can be set to null.
    # I've started to use it less as I go forward
    def easy_save(first_name, last_name, email, password, password_confirmation, musician, gender,
                  birth_date, internet_service_provider, city, state, country, instruments, photo_url, biography = nil)

      # first name
      unless first_name.nil?
        self.first_name = first_name
      end

      # last name
      unless last_name.nil?
        self.last_name = last_name
      end

      # email
      # !! Email is changed in a dedicated method, 'update_email'
      #unless email.nil?
      #  self.email = email
      #end

      # password
      unless password.nil?
        self.password = password
      end

      # password confirmation
      unless password_confirmation.nil?
        self.password_confirmation = password_confirmation
      end

      # musician flag
      unless musician.nil?
        self.musician = musician
      end

      # gender
      unless gender.nil?
        self.gender = gender
      end

      # birthdate
      unless birth_date.nil?
        self.birth_date = birth_date
      end

      # ISP
      unless internet_service_provider.nil?
        self.internet_service_provider = internet_service_provider
      end

      # city
      unless city.nil?
        self.city = city
      end

      # state
      unless state.nil?
        self.state = state
      end

      # country
      unless country.nil?
        self.country = country
      end

      # instruments
      unless instruments.nil?
        update_instruments(instruments)
      end

      # photo url
      unless photo_url.nil?
        self.photo_url = photo_url
      end

      unless biography.nil?
        self.biography = biography
      end

      self.updated_at = Time.now
      self.save
    end

    # helper method for creating / updating a User
    def self.save(id, updater_id, first_name, last_name, email, password, password_confirmation, musician, gender,
        birth_date, internet_service_provider, city, state, country, instruments, photo_url, biography)
      if id.nil?
        user = User.new()
      else
        user = User.find(id)
      end

      if user.id != updater_id
        raise JamPermissionError, ValidationMessages::PERMISSION_VALIDATION_ERROR
      end

      user.easy_save(first_name, last_name, email, password, password_confirmation, musician, gender,
                     birth_date, internet_service_provider, city, state, country, instruments, photo_url, biography)
      return user
    end

    def begin_update_email(email, current_password, confirmation_url)
      # sets the user model in a state such that it's expecting to have it's email updated
      # two columns matter for this; 'update_email_token' and 'update_email'
      # confirmation_link is odd in the sense that it can likely only come from www.jamkazam.com (jam-web)

      # an observer should be set up to send an email based on this activity
      self.updating_email = self.confirm_current_password = true
      self.current_password = current_password
      self.update_email = email
      self.update_email_token = SecureRandom.urlsafe_base64
      self.update_email_confirmation_url = "#{confirmation_url}#{self.update_email_token}"

      self.save
    end

    def create_user_following(targetUserId)
      targetUser = User.find(targetUserId)

      follow = Follow.new
      follow.followable = targetUser
      follow.user = self
      follow.save

      # TODO: make this async
      Notification.send_new_user_follower(self, targetUser)
    end

    def create_band_following(targetBandId)

      targetBand= Band.find(targetBandId)

      follow = Follow.new
      follow.followable = targetBand
      follow.user = self
      follow.save

      # TODO: make this async
      Notification.send_new_band_follower(self, targetBand)
    end

    def self.delete_following(followerId, targetEntityId)
      Follow.delete_all "(user_id = '#{followerId}' AND followable_id = '#{targetEntityId}')"
    end

    def create_user_liking(targetUserId)
      targetUser = User.find(targetUserId)

      like = Like.new
      like.likable = targetUser
      like.user = self
      like.save
    end

    def create_band_liking(targetBandId)
      targetBand = Band.find(targetBandId)

      like = Like.new
      like.likable = targetBand
      like.user = self
      like.save
    end

    def self.delete_liking(likerId, targetEntityId)
      Like.delete_all "(user_id = '#{likerId}' AND likable_id = '#{targetEntityId}')"
    end

    # def create_session_like(targetSessionId)
    #   targetSession = MusicSession.find(targetSessionId)

    #   like = Like.new
    #   like.likable = targetSession
    #   like.user = self
    #   like.save
    # end

    # def create_recording_like(targetRecordingId)
    #   targetRecording = Recording.find(targetRecordingId)

    #   like = Like.new
    #   like.likable = targetRecording
    #   like.user = self
    #   like.save
    # end

    def self.finalize_update_email(update_email_token)
      # updates the user model to have a new email address
      user = User.find_by_update_email_token!(update_email_token)

      user.updated_email = true
      user.email = user.update_email
      user.update_email_token = nil
      user.save
      begin
        RecurlyClient.new.update_account(user)
      rescue Recurly::Error
        @@log.debug("No recurly account found; continuing")
      end

      return user
    end

    def self.create_favorite(user_id, recording_id)
      favorite = UserFavorite.new
      favorite.user_id = user_id
      favorite.recording_id = recording_id
      favorite.save
    end

    def favorite_count
      0 # FIXME:  update this with recording likes count when implemented
    end

    def self.delete_favorite(user_id, recording_id)
      JamRuby::UserFavorite.delete_all "(user_id = '#{user_id}' AND recording_id = '#{recording_id}')"
    end

    def self.save_session_settings(user, music_session)
      unless user.nil?

        # only save genre id and description
        genres = [{id: music_session.genre.id, description: music_session.genre.description}]

        # only save invitation receiver id and name
        invitees = []
        unless music_session.invitations.nil?
          music_session.invitations.each do |invitation|
            i = Hash.new
            i["id"] = invitation.receiver.id
            i["name"] = invitation.receiver.name
            invitees << i
          end
        end

        session_settings = { :band_id => music_session.band_id,
                             :musician_access => music_session.musician_access,
                             :approval_required => music_session.approval_required,
                             :fan_chat => music_session.fan_chat,
                             :fan_access => music_session.fan_access,
                             :description => music_session.description,
                             :genres => genres,
                             :invitees => invitees
                           }


        user.session_settings = session_settings
        user.save
      end
    end

    def handle_test_drive_package(package, details)
      self.test_drive_packaging = true
      choice = TestDrivePackageChoice.new
      choice.user = self
      choice.test_drive_package = package
      details[:teachers].each do |teacher|
        teacher_choice = TestDrivePackageChoiceTeacher.new
        teacher_choice.teacher = User.find(teacher[:id])
        choice.test_drive_package_choice_teachers << teacher_choice
      end

      choice.save!

      choice.test_drive_package_choice_teachers.each do |teacher_choice|
        booking = LessonBooking.book_packaged_test_drive(self, teacher_choice.teacher, "Please suggest a time that works for you.", choice)
        if booking.errors.any?
          raise "unable to create booking in package user:#{self.email}"
        end
      end
    end

    def is_guitar_center?
      is_guitar_center_student? || is_guitar_center_teacher?
    end

    def is_guitar_center_student?
      !school.nil? && school.is_guitar_center?
    end

    def is_guitar_center_teacher?
      !teacher.nil? && teacher.is_guitar_center?
    end

    # throws ActiveRecord::RecordNotFound if instrument is invalid
    # throws an email delivery error if unable to connect out to SMTP
    def self.signup(options)

      first_name = options[:first_name]
      last_name = options[:last_name]
      email = options[:email]
      password = options[:password]
      password_confirmation = options[:password_confirmation]
      terms_of_service = options[:terms_of_service]
      location = options[:location]
      instruments = options[:instruments]
      birth_date = options[:birth_date]
      musician = options[:musician]
      photo_url = options[:photo_url]
      invited_user = options[:invited_user]
      fb_signup = options[:fb_signup]
      signup_confirm_url = options[:signup_confirm_url]
      affiliate_referral_id = options[:affiliate_referral_id]
      recaptcha_failed = options[:recaptcha_failed]
      any_user = options[:any_user]
      reuse_card = options[:reuse_card]
      signup_hint = options[:signup_hint]
      affiliate_partner = options[:affiliate_partner]
      gift_card = options[:gift_card]
      student = options[:student]
      teacher = options[:teacher]
      school_invitation_code = options[:school_invitation_code]
      school_id = options[:school_id]
      retailer_invitation_code = options[:retailer_invitation_code]
      retailer_id = options[:retailer_id]
      retailer_interest = options[:retailer_interest]
      school_interest = options[:school_interest]
      education_interest = options[:education_interest]
      origin = options[:origin]
      test_drive_package_details = options[:test_drive_package]
      under_13 = options[:under_13]
      timezone = options[:timezone]

      test_drive_package = TestDrivePackage.find_by_name(test_drive_package_details[:name]) if test_drive_package_details

      school = School.find(school_id) if school_id
      retailer = School.find(retailer_id) if retailer_id
      user = User.new
      user.validate_instruments = true
      UserManager.active_record_transaction do |user_manager|

        if school_invitation_code
          school_invitation = SchoolInvitation.find_by_invitation_code(school_invitation_code)
          if school_invitation
            first_name ||= school_invitation.first_name
            last_name ||= school_invitation.last_name
            school_invitation.accepted = true
            school_invitation.save
          end
        end

        if retailer_invitation_code
          retailer_invitation = RetailerInvitation.find_by_invitation_code(retailer_invitation_code)
          if retailer_invitation
            first_name ||= retailer_invitation.first_name
            last_name ||= retailer_invitation.last_name
            retailer_invitation.accepted = true
            retailer_invitation.save
          end
        end

        user.first_name = first_name if first_name.present?
        user.last_name = last_name if last_name.present?
        user.email = email
        user.subscribe_email = true
        user.terms_of_service = terms_of_service
        user.reuse_card unless reuse_card.nil?
        user.gifted_jamtracks = 0
        user.jamclass_credits = 0
        user.has_redeemable_jamtrack = true
        user.under_13 = under_13
        user.is_a_student = !!student
        user.is_a_teacher = !!teacher
        user.retailer_interest = !!retailer_interest
        user.school_interest = !!school_interest
        user.education_interest = !!education_interest
        if user.is_a_student || user.is_a_teacher
          musician = true
        end
        user.musician = !!musician

        if origin
          user.origin_utm_source = origin["utm_source"]
          user.origin_utm_medium = origin["utm_medium"]
          user.origin_utm_campaign = origin["utm_campaign"]
          user.origin_referrer = origin["referrer"]
        else
          user.origin_utm_source = 'organic'
          user.origin_utm_medium = 'organic'
          user.origin_utm_campaign = nil
          user.origin_referrer = nil
        end


        if school_id.present?
          if user.is_a_student
            user.school_id = school_id
            user.affiliate_referral = school.affiliate_partner
          elsif user.is_a_teacher
            school = School.find_by_id(school_id)
            user.teacher = Teacher.build_teacher(user, validate_introduction: true, biography: "Empty biography", school_id: school_id)
            user.affiliate_referral = school.affiliate_partner
          end
        elsif retailer_id.present?
          if user.is_a_student
            user.retailer_id = school_id
            user.affiliate_referral = retailer.affiliate_partner
          elsif user.is_a_teacher
            retailer = Retailer.find_by_id(retailer_id)
            user.teacher = Teacher.build_teacher(user, validate_introduction: true, biography: "Empty biography", retailer_id: retailer_id)
            user.affiliate_referral = retailer.affiliate_partner
          end
        else
          if user.is_a_teacher
            user.teacher = Teacher.build_teacher(user, validate_introduction: true, biography: "Empty biography")
          end

        end


        # FIXME: Setting random password for social network logins. This
        # is because we have validations all over the place on this.
        # The right thing would be to have this null

        # Seth: I think we need a flag in the signature of signup to say 'social_signup=true'. If that flag is set,
        # then you can do use.updating_password = false and instead set a null password
        if password.nil?
          user.password = user.password_confirmation = SecureRandom.urlsafe_base64
        else
          user.password = password
          user.password_confirmation = password_confirmation
        end

        user.admin = false
        user.location = location
        # user.city = location[:city]
        # user.state = location[:state]
        # user.country = location[:country]
        user.birth_date = birth_date

        if musician
          user.last_jam_addr = location[:addr]
          user.last_jam_locidispid = location[:locidispid]
          user.last_jam_updated_reason = JAM_REASON_REGISTRATION
          user.last_jam_updated_at = Time.now
        end

        if musician # only update instruments if the user is a musician
          unless instruments.nil?
            instruments.each do |musician_instrument_param|
              instrument = Instrument.find(musician_instrument_param[:instrument_id])
              musician_instrument = MusicianInstrument.new
              musician_instrument.player = user
              musician_instrument.instrument = instrument
              musician_instrument.proficiency_level = musician_instrument_param[:proficiency_level]
              musician_instrument.priority = musician_instrument_param[:priority]
              user.musician_instruments << musician_instrument
            end
          end
        end

        user.photo_url = photo_url

        # copy over the shopping cart to the new user, if a shopping cart is provided
        if any_user
          user.shopping_carts = any_user.shopping_carts
          if user.shopping_carts
            user.shopping_carts.each do |shopping_cart|
              shopping_cart.anonymous_user_id = nil # nil out the anonymous user ID; required for uniqeness constraint on ShoppingCart
            end
          end
        end

        unless fb_signup.nil?
          user.update_fb_authorization(fb_signup)

          if fb_signup.email.casecmp(user.email).zero?
            user.email_confirmed = true
            user.signup_token = nil
          else
            user.email_confirmed = false
            user.signup_token = SecureRandom.urlsafe_base64
          end
        end

        if invited_user.nil?
          user.can_invite = Limits::USERS_CAN_INVITE

          unless user.email_confirmed # important that the only time this goes true is if some other mechanism, like fb_signup, set this high
            user.email_confirmed = false
            user.signup_token = SecureRandom.urlsafe_base64
          end
        else
          # if you are invited by an admin, we'll say you can invite too.
          # but if not, then you can not invite
          user.can_invite = Limits::USERS_CAN_INVITE #invited_user.invited_by_administrator?

          # if you came in from an invite and used the same email to signup,
          # then we know you are a real human and that your email is valid.
          # lucky! we'll log you in immediately
          if invited_user.email && invited_user.email.casecmp(user.email).zero?
            user.email_confirmed = true
            user.signup_token = nil
          else
            user.email_confirmed = false
            user.signup_token = SecureRandom.urlsafe_base64
          end


          # now that the user is saved, let's
          if invited_user.autofriend && !invited_user.sender.nil?
            # hookup this user with the sender
            Friendship.save_using_models(user, invited_user.sender)
          end

          invited_user.accept!
          invited_user.save

          if invited_user.errors.any?
            raise ActiveRecord::Rollback
          end
        end

        found_gift_card = nil

        # if a gift card  value was passed in, then try to find that gift card and apply it to user
        if gift_card
          # first try posa card
          posa_card = PosaCard.where(code: gift_card).first

          if posa_card
            posa_card.claim(user)
            user.via_amazon = posa_card.is_amazon_posa_card?
            user.posa_cards << posa_card
            user.purchase_required = posa_card.requires_purchase # temporary; just so the signup page knows to send them to payment place
          else

            user.expecting_gift_card = true
            found_gift_card = GiftCard.where(code: gift_card).where(user_id: nil).first
            if found_gift_card
              user.gift_cards << found_gift_card
            end

          end
        end

        user.save

        if found_gift_card
          user.reload
          ShoppingCart.apply_gifted_jamtracks(user)
        end

        # if the user has just one, free jamtrack in their shopping cart, and it matches the signup hint, then auto-buy it
        # only_freebie_in_cart =
        #     signup_hint &&
        #         signup_hint.jam_track &&
        #         user.shopping_carts.length == 1 &&
        #         user.shopping_carts[0].cart_product == signup_hint.jam_track &&
        #         user.shopping_carts[0].product_info[:free]
        #
        # if only_freebie_in_cart
        #   Sale.place_order(user, user.shopping_carts)
        # end

        user.errors.add("recaptcha", "verification failed") if recaptcha_failed

        unless user.errors.any?
          if Rails.application.config.verify_email_enabled
            client = Kickbox::Client.new(Rails.application.config.kickbox_api_key)
            kickbox = client.kickbox()
            response = kickbox.verify(email)
            result = response.body["result"]

            user.kickbox_response = response.body.to_json
            if result == "deliverable"
              user.email_needs_verification = false
            elsif result == "undeliverable"

              did_you_mean = response.body["did_you_mean"]
              if did_you_mean
                user.errors.add(:email, "Did you mean #{did_you_mean}?")
              else
                user.errors.add(:email, "is not real")
              end
            elsif result == "risky" || result == "unknown"
              if response.body["disposable"]
                user.errors.add(:email, "is disposable address")
              else
                user.email_needs_verification = true
              end
            end
          else
            user.email_needs_verification = false
          end
        end


        user.save unless user.errors.any?

        if user.errors.any?
          raise ActiveRecord::Rollback
        else
          # if the partner ID was present and the partner doesn't already have a user associated, associate this new user with the affiliate partner
          if affiliate_partner && affiliate_partner.partner_user.nil?
            affiliate_partner.partner_user = user
            unless affiliate_partner.save
              @@log.error("unable to associate #{user.to_s} with affiliate_partner #{affiliate_partner.id} / #{affiliate_partner.partner_name}")
            end
          end

          if user.affiliate_referral = AffiliatePartner.find_by_id(affiliate_referral_id)
            user.save
          end if affiliate_referral_id.present?


          user.handle_test_drive_package(test_drive_package, test_drive_package_details) if test_drive_package

          if user.is_a_student
            #if school && school.education
            #  UserMailer.student_education_welcome_message(user).deliver_now
            #else
              body = "Name: #{user.name}\n"
              body << "Email: #{user.email}\n"
              body << "Student List: #{user.admin_student_url}\n"
              body << "User Page: #{user.admin_url}\n"
              if posa_card
                body << "Package Details: \n"
                body << "        Package: #{posa_card.lesson_package_type.id}\n"
                body << "        Credits: #{posa_card.credits}\n"
                body << "        Code: #{posa_card.code}\n"
              end

              AdminMailer.jamclass_alerts({subject: "#{user.email} just signed up as a student", body: body}).deliver_now
              if user.via_amazon
                UserMailer.amazon_welcome_message(user).deliver_now
                user.send_lesson_poke(true)
              else
                UserMailer.student_welcome_message(user).deliver_now
              end


            #end
          elsif user.is_a_teacher
            UserMailer.teacher_welcome_message(user).deliver_now
          elsif user.education_interest
            UserMailer.education_owner_welcome_message(user).deliver_now
          elsif user.school_interest
            UserMailer.school_owner_welcome_message(user).deliver_now
          elsif user.retailer_interest
            UserMailer.retailer_owner_welcome_message(user).deliver_now
          else
            UserMailer.welcome_message(user).deliver_now
          end

          if !user.email_confirmed
            # any errors here should also rollback the transaction; that's OK. If emails aren't going to be delivered,
            # it's already a really bad situation; make user signup again
            UserMailer.confirm_email(user, signup_confirm_url.nil? ? nil : (signup_confirm_url + "/" + user.signup_token) ).deliver_now
          end
        end
      end

      user.update_timezone(timezone)
      user.reload if user.id # gift card adding gifted_jamtracks doesn't reflect here until reload
      user
    end

    # def signup

    def self.create_user(first_name, last_name, email ,password, city, state, country, instruments, photo_url)

      user = User.find_or_create_by({email:email})
      User.transaction do
        user.first_name = first_name
        user.last_name = last_name
        user.email = email
        user.password = password
        user.password_confirmation = password
        user.admin = true
        user.email_confirmed = true
        user.musician = true
        user.city = city
        user.state = state
        user.country = country
        user.terms_of_service = true

        if instruments.nil?
          instruments = [{:instrument_id => "acoustic guitar", :proficiency_level => 3, :priority => 1}]
        end

        unless user.new_record?
          MusicianInstrument.delete_all(["player_id = ?", user.id])
        end

        instruments.each do |musician_instrument_param|
          instrument = Instrument.find(musician_instrument_param[:instrument_id])
          musician_instrument = MusicianInstrument.new
          musician_instrument.player = user
          musician_instrument.instrument = instrument
          musician_instrument.proficiency_level = musician_instrument_param[:proficiency_level]
          musician_instrument.priority = musician_instrument_param[:priority]
          user.musician_instruments << musician_instrument
        end

        if photo_url.nil?
          user.photo_url = photo_url
        end

        user.signup_token = nil
        user.save

        if user.errors.any?
          raise ActiveRecord::Rollback
        end
      end

      return user
    end

    # We guard against this code running in production mode,
    # because otherwise it's a bit of uncomfortable code
    # to have sitting around
    def self.create_dev_user(first_name, last_name, email, password,
        city, state, country, instruments, photo_url)

      if Environment.mode == "production"
        # short-circuit out
        return
      end

      return create_user(first_name, last_name, email, password, city, state, country, instruments, photo_url)
    end

    def signup_confirm
      self.signup_token = nil
      self.confirm_email!
      self.save
    end

    # gets the GeoIpLocation for the user's last_jam_locidispid (where are they REALLY, vs profile info)
    def geoiplocation
      GeoIpLocations.find_by_locid(last_jam_locidispid / 1000000) if last_jam_locidispid
    end

    def update_last_jam(remote_ip, reason)
      location = GeoIpLocations.lookup(remote_ip)
      self.last_jam_addr = location[:addr]
      self.last_jam_locidispid = location[:locidispid]
      self.last_jam_updated_reason = reason
      self.last_jam_updated_at = Time.now
      save!
    end

    def update_addr_loc(connection, reason)
      unless connection
        @@log.warn("no connection specified in update_addr_loc with reason #{reason}")
        return
      end

      if connection.locidispid.nil?
        @@log.warn("no locidispid for connection's ip_address: #{connection.ip_address}")
        return
      end

      # we don't use a websocket login to update the user's record unless there is no addr
      if reason == JAM_REASON_LOGIN && last_jam_addr
        return
      end

      self.last_jam_addr = connection.addr
      self.last_jam_locidispid = connection.locidispid
      self.last_jam_updated_reason = reason
      self.last_jam_updated_at = Time.now
      unless self.save
        @@log.warn("unable to update user #{self} with last_jam_reason #{reason}. errors: #{self.errors.inspect}")
      end
    end

    def escape_filename(path)
      dir = File.dirname(path)
      file = File.basename(path)
      "#{dir}/#{ERB::Util.url_encode(file)}"
    end

    def permanently_delete
      original_email  = self.email

      AdminMailer.ugly({to: original_email, cc: 'support@jamkazam.com', subject:'Your account has been deleted!', body: "This will be the last email you receive from JamKazam.\n\nRegards,\nTeam JamKazam"}).deliver_now

      User.where(id: self.id).update_all(encrypted_password: SecureRandom.uuid, email: "deleted+#{SecureRandom.uuid}@jamkazam.com", subscribe_email: false, remember_token: SecureRandom.uuid, deleted: true)
    end

    def update_avatar(original_fpfile, cropped_fpfile, cropped_large_fpfile, crop_selection, aws_bucket)
      self.updating_avatar = true

      cropped_s3_path = cropped_fpfile["key"]
      cropped_large_s3_path = cropped_large_fpfile["key"]

      self.update_attributes(
          :original_fpfile => original_fpfile,
          :cropped_fpfile => cropped_fpfile,
          :cropped_large_fpfile => cropped_large_fpfile,
          :cropped_s3_path => cropped_s3_path,
          :cropped_large_s3_path => cropped_large_s3_path,
          :crop_selection => crop_selection,
          :photo_url => S3Util.url(aws_bucket, escape_filename(cropped_s3_path), :secure => true),
          :large_photo_url => S3Util.url(aws_bucket, escape_filename(cropped_large_s3_path), :secure => true)
      )
    end

    def delete_avatar(aws_bucket)

      User.transaction do

        unless self.cropped_s3_path.nil?
          S3Util.delete(aws_bucket, File.dirname(self.cropped_s3_path) + '/cropped.jpg')
          S3Util.delete(aws_bucket, self.cropped_s3_path)
          S3Util.delete(aws_bucket, self.cropped_large_s3_path)
        end

        return self.update_attributes(
            :original_fpfile => nil,
            :cropped_fpfile => nil,
            :cropped_large_fpfile => nil,
            :cropped_s3_path => nil,
            :cropped_large_s3_path => nil,
            :photo_url => nil,
            :crop_selection => nil,
            :large_photo_url => nil
        )
      end

    end

    # throws RecordNotFound if signup token is invalid; i.e., if it's nil, empty string, or not belonging to a user
    def self.signup_confirm(signup_token)
      if signup_token.nil? || signup_token.empty?
        # there are plenty of confirmed users with nil signup_tokens, so we can't look on it
        raise ActiveRecord::RecordNotFound
      else
        User.transaction do
          # throws ActiveRecord::RecordNotFound if invalid
          user = User.find_by_signup_token!(signup_token)
          user.signup_confirm
          return user
        end
      end
    end

    # if valid credentials are supplied for an 'active' user, returns the user
    # if not authenticated, returns nil
    def self.authenticate(email, password)
      # remove email_confirmed restriction due to VRFS-378

      # we only allow users that have confirmed email to authenticate
      # user = User.where('email_confirmed=true').find_by_email(email)

      # do a case insensitive search for email, because we store it case sensitive
      user = User.where("email ILIKE ?", email).first

      if user && user.valid_password?(password)
        return user
      else
        return nil
      end
    end

    def invalidate_user_authorization(provider)
      auth = user_authorization(provider)
      auth.destroy if auth
    end

    def user_authorization(provider)
      user_authorizations.where(provider: provider).first
    end

    def auth_twitter
      !user_authorization('twitter').nil?
    end

    def build_twitter_authorization(auth_hash)

      twitter_uid = auth_hash[:uid]
      credentials = auth_hash[:credentials]
      secret = credentials[:secret] if credentials
      token = credentials[:token] if credentials

      if twitter_uid && secret && token
        user_authorization = nil

        unless self.new_record?
          # see if this user has an existing user_authorization for this provider
          user_authorization = UserAuthorization.find_by_user_id_and_provider(self.id, 'twitter')
        end
      end

      if user_authorization.nil?
        user_authorization = UserAuthorization.new(provider: 'twitter',
                                                   uid: twitter_uid,
                                                   token: token,
                                                   secret: secret,
                                                   user: self)
      else
        user_authorization.uid = twitter_uid
        user_authorization.token = token
        user_authorization.secret = secret
      end

      user_authorization
    end

    # updates an existing user_authorization for facebook, or creates a new one if none exist
    def update_fb_authorization(fb_signup)
      if fb_signup.uid && fb_signup.token && fb_signup.token_expires_at

        user_authorization = nil

        unless self.new_record?
          # see if this user has an existing user_authorization for this provider
          user_authorization = UserAuthorization.find_by_user_id_and_provider(self.id, 'facebook')
        end

        if user_authorization.nil?
          self.user_authorizations.build provider: 'facebook',
                                         uid: fb_signup.uid,
                                         token: fb_signup.token,
                                         token_expiration: fb_signup.token_expires_at,
                                         user: self
        else
          user_authorization.uid = fb_signup.uid
          user_authorization.token = fb_signup.token
          user_authorization.token_expiration = fb_signup.token_expires_at
          user_authorization.save
        end
      end
    end

    def provides_location?
      !self.city.blank? && (!self.state.blank? || !self.country.blank?)
    end

    def self.update_locidispids(use_copied=true)
      # using last_jam_addr, we can rebuild
      # * last_jam_locidispid
      # * last_jam_updated_reason
      # * last_jam_updated_at

      # this will set a user's last_jam_locidispid = NULL if there are no geoiplocations/blocks that match their IP address, or if there are no JamIsps that match the IP address
      # otherwise, last_jam_locidispid will be updated to the correct new value.
      # updates all user's locidispids

      table_suffix = use_copied ? '_copied' : ''

      User.connection.execute("UPDATE users SET last_jam_locidispid = (SELECT geolocs.locid as geolocid FROM geoipblocks#{table_suffix} as geoblocks INNER JOIN geoiplocations#{table_suffix} AS geolocs ON geoblocks.locid = geolocs.locid WHERE geoblocks.geom && ST_MakePoint(users.last_jam_addr, 0) AND users.last_jam_addr BETWEEN geoblocks.beginip AND geoblocks.endip LIMIT 1) * 1000000::bigint +(SELECT coid FROM jamisp#{table_suffix} as jisp WHERE geom && ST_MakePoint(users.last_jam_addr, 0) AND users.last_jam_addr BETWEEN beginip AND endip LIMIT 1), last_jam_updated_at = NOW(), last_jam_updated_reason='i' ").check
    end

    def self.after_maxmind_import
      update_locidispids
    end

    # def check_lat_lng
    #   if (city_changed? || state_changed? || country_changed?) && !lat_changed? && !lng_changed?
    #     update_lat_lng
    #   end
    # end

    # def update_lat_lng(ip_addy=nil)
    #   if provides_location?  # ip_addy argument ignored in this case
    #     return false unless ip_addy.nil?  # do nothing if attempting to set latlng from an ip address
    #     query = { :city => self.city }
    #     query[:region] = self.state unless self.state.blank?
    #     query[:country] = self.country unless self.country.blank?
    #     if geo = MaxMindGeo.where(query).limit(1).first
    #       geo.lat = nil if geo.lat = 0
    #       geo.lng = nil if geo.lng = 0
    #       if geo.lat && geo.lng && (self.lat != geo.lat || self.lng != geo.lng)
    #         self.update_attributes({ :lat => geo.lat, :lng => geo.lng })
    #         return true
    #       end
    #     end
    #   elsif ip_addy
    #     if geo = MaxMindGeo.ip_lookup(ip_addy)
    #       geo.lat = nil if geo.lat = 0
    #       geo.lng = nil if geo.lng = 0
    #       if self.lat != geo.lat || self.lng != geo.lng
    #         self.update_attributes({ :lat => geo.lat, :lng => geo.lng })
    #         return true
    #       end
    #     end
    #   else
    #     if self.lat || self.lng
    #       self.update_attributes({ :lat => nil, :lng => nil })
    #       return true
    #     end
    #   end
    #   false
    # end

    def current_city(ip_addy=nil)
      # unless self.city
      #   if self.lat && self.lng
      #     # todo this is really dumb, you can't compare lat lng for equality
      #     return MaxMindGeo.where(['lat = ? AND lng = ?',self.lat,self.lng]).limit(1).first.try(:city)
      #   elsif ip_addy
      #     return MaxMindGeo.ip_lookup(ip_addy).try(:city)
      #   end
      # else
      #   return self.city
      # end
      self.city
    end

    def update_audio_latency(connection, audio_latency)
      # the backend sometimes gives tiny numbers, and sometimes very large numbers
      if audio_latency > MINIMUM_AUDIO_LATENCY && audio_latency < MAXIMUM_AUDIO_LATENCY
        # updating the connection is best effort; if it's not there that's OK
        if connection
          Connection.where(:id => connection.id).update_all(:last_jam_audio_latency => audio_latency)
        end

        self.last_jam_audio_latency = audio_latency
        self.save
      end
    end

    def top_followings
      @topf ||= User.joins("INNER JOIN follows ON follows.followable_id = users.id AND follows.followable_type = '#{self.class.to_s}'")
                    .where(['follows.user_id = ?', self.id])
                    .order('follows.created_at DESC')
                    .limit(3)
    end

    def nearest_musicians
      # FIXME:  replace with Scotts scoring query
      Search.new_musicians(self, Time.now - 1.week)
    end

    def self.deliver_new_musician_notifications(since_date=nil)
      since_date ||= Time.now-1.week
      # return musicians with locidispid not null
      self.musicians_geocoded.find_each do |usr|
        Search.new_musicians(usr, since_date) do |new_nearby|
          UserMailer.new_musicians(usr, new_nearby).deliver_now
        end
      end
    end

    def facebook_invite!
      unless iu = InvitedUser.facebook_invite(self)
        iu = InvitedUser.new
        iu.sender = self
        iu.autofriend = true
        iu.invite_medium = InvitedUser::FB_MEDIUM
        iu.save
      end
      iu
    end

    # both email and name helps someone understand/recall/verify who they are looking at
    def autocomplete_display_name
      "#{email} (#{name})"
    end

    # used by formtastic for display
    def to_label
      autocomplete_display_name
    end

    # devise compatibility

    #def encrypted_password
    #  logger.debug("password digest returned #{self.password_digest}")
    #  self.password_digest
    #end

    #def encrypted_password=(encrypted_password)
    #  self.password_digest = encrypted_password
    #end

    def self.id_for_email(email)
      User.where(:email => email).limit(1).pluck(:id).first
    end

    # checks if user has submitted RSVP to a session
    def has_rsvp(session)
      slots = RsvpSlot.find_by_sql(%Q{select rs.*
                              from rsvp_slots rs
                              inner join rsvp_requests_rsvp_slots rrrs on rrrs.rsvp_slot_id = rs.id
                              inner join rsvp_requests rr on rr.id = rrrs.rsvp_request_id
                              where rs.music_session_id = '#{session.id}'
                              and rr.user_id = '#{self.id}'
                            })

      !slots.blank?
    end

    def has_approved_rsvp(session)
      approved_slots = RsvpSlot.find_by_sql(%Q{select rs.*
                              from rsvp_slots rs
                              inner join rsvp_requests_rsvp_slots rrrs on rrrs.rsvp_slot_id = rs.id
                              inner join rsvp_requests rr on rr.id = rrrs.rsvp_request_id
                              where rs.music_session_id = '#{session.id}'
                              and rr.user_id = '#{self.id}'
                              and rrrs.chosen = true
                            })

      !approved_slots.blank?
    end

    # end devise compatibility

    def self.stats
      stats = {}
      result = User.select('count(CASE WHEN musician THEN 1 ELSE null END) as musician_count, count(CASE WHEN musician = FALSE THEN 1 ELSE null END) as fan_count, count(first_downloaded_client_at) first_downloaded_client_at_count, count(first_ran_client_at) first_ran_client_at_count, count(first_certified_gear_at) first_certified_gear_at_count, count(first_music_session_at) as first_music_session_at_count, count(first_invited_at) first_invited_at_count, count(first_friended_at) as first_friended_at_count, count(first_social_promoted_at) first_social_promoted_at_count, avg(last_jam_audio_latency) last_jam_audio_latency_avg')[0]
      stats['musicians'] = result['musician_count'].to_i
      stats['fans'] = result['fan_count'].to_i
      stats['downloaded_client'] = result['first_downloaded_client_at_count'].to_i
      stats['ran_client'] = result['first_ran_client_at_count'].to_i
      stats['certified_gear'] = result['first_certified_gear_at_count'].to_i
      stats['jammed'] = result['first_music_session_at_count'].to_i
      stats['invited'] = result['first_invited_at_count'].to_i
      stats['friended'] = result['first_friended_at_count'].to_i
      stats['social_promoted'] = result['first_social_promoted_at_count'].to_i
      stats['audio_latency_avg'] = result['last_jam_audio_latency_avg'].to_f
      stats
    end

    def shopping_cart_total
      total = 0
      shopping_carts.each do |shopping_cart|
        total += shopping_cart.product_info[:total_price]
      end
      total
    end
    def destroy_all_shopping_carts
      ShoppingCart.where("user_id=?", self).destroy_all
    end

    def mixed_cart
      Sale.is_mixed(shopping_carts)
    end

    def destroy_jam_track_shopping_carts
      ShoppingCart.destroy_all(anonymous_user_id: @id, cart_type: JamTrack::PRODUCT_TYPE)
    end


    def unsubscribe_token
      self.class.create_access_token(self)
    end

    # Verifier based on our application secret
    def self.verifier
      ActiveSupport::MessageVerifier.new(APP_CONFIG.secret_token)
    end

    # Get a user from a token
    def self.read_access_token(signature)
      uid = self.verifier.verify(signature)
      User.find_by_id uid
    rescue ActiveSupport::MessageVerifier::InvalidSignature
      nil
    end

    # Class method for token generation
    def self.create_access_token(user)
      verifier.generate(user.id)
    end

    def admin_name
      "#{name} (#{(email)})"
    end
    # URL to jam-admin
    def admin_url
      APP_CONFIG.admin_root_url + "/admin/users/" + id
    end

    def admin_student_url
      APP_CONFIG.admin_root_url + "/admin/students" # should add id; not yet supported
    end

    def admin_onboarding_url
      APP_CONFIG.admin_root_url + "/admin/onboarder_managements"
    end

    def jam_track_rights_admin_url
      APP_CONFIG.admin_root_url + "/admin/jam_track_rights?q[user_id_equals]=#{id}&commit=Filter&order=created_at DESC"
    end

    # these are signup attributes that we default to when not presenting the typical form @ /signup
    def self.musician_defaults(remote_ip, confirmation_url, any_user, options)
      options = options || {}
      options[:remote_ip] = remote_ip
      options[:birth_date] = nil
      options[:instruments] = [{:instrument_id => 'other', :proficiency_level => 1, :priority => 1}]
      options[:musician] = true
      options[:skip_recaptcha] = true
      options[:invited_user] = nil
      options[:fb_signup] = nil
      options[:signup_confirm_url] = confirmation_url
      options[:any_user] = any_user
      options
    end

    def should_attribute_sale?(shopping_cart, instance = nil)

      if shopping_cart.is_lesson? && shopping_cart.cart_product.is_test_drive?
        # never attribute test drives
        return false
      end


      if affiliate_referral
        referral_info = affiliate_referral.should_attribute_sale?(shopping_cart, self, instance)
      else
        false
      end
    end

    def redeem_free_credit
      using_free_credit = false
      if self.has_redeemable_jamtrack
        User.where(id: self.id).update_all(has_redeemable_jamtrack: false)
        self.has_redeemable_jamtrack = false
        using_free_credit = true

      elsif 0 < self.gifted_jamtracks
        User.where(id: self.id).update_all(gifted_jamtracks: self.gifted_jamtracks - 1)
        self.gifted_jamtracks = self.gifted_jamtracks - 1
        using_free_credit = true
      end
      using_free_credit
    end

    def has_stored_credit_card?
      stored_credit_card
    end

    def has_free_lessons?
      remaining_free_lessons > 0
    end

    def can_book_free_lesson?
      has_free_lessons? && has_stored_credit_card?
    end

    def can_buy_test_drive?
      lesson_purchases.where('lesson_package_type_id in (?)', LessonPackageType.test_drive_package_ids).where('created_at > ?', APP_CONFIG.test_drive_wait_period_year.years.ago).count == 0
    end

    # validate if within waiting period
    def can_claim_posa_card
      posa_cards.where('is_lesson = ?', true).where('claimed_at > ?', APP_CONFIG.jam_class_card_wait_period_year.years.ago).count == 0
    end

    def lessons_with_teacher(teacher)
      taken_lessons.where(teacher_id: teacher.id)
    end

    def lessons_with_student(student)
      taught_lessons.where(user_id: student.id)
    end

    def has_test_drives?
      remaining_test_drives > 0
    end

    def has_posa_credits?
      jamclass_credits > 0
    end

    def has_unprocessed_test_drives?
      !unprocessed_test_drive.nil?
    end

    def has_requested_test_drive?(teacher = nil)
      !requested_test_drive(teacher).nil?
    end

    def stripe_auth
      user_authorizations.where(provider: "stripe_connect").first
    end

    def paypal_auth
      user_authorizations.where(provider: 'paypal').first
    end

    def has_paypal_auth?
      auth = paypal_auth
      auth && (!auth.token_expiration || auth.token_expiration > Time.now)
    end

    def has_stripe_connect?
      auth = stripe_auth
      auth && (!auth.token_expiration || auth.token_expiration > Time.now)
    end

    def fetch_stripe_customer
      Stripe::Customer.retrieve(stripe_customer_id)
    end

    # if the user already has a stripe customer, then keep it synced.  otherwise create it
    def sync_stripe_customer
      if self.stripe_customer_id
        # we already have a customer for this user; re-use it
        customer = fetch_stripe_customer

        if customer.email.nil? || customer.email.downcase != email.downcase
          customer.email = email
          customer.save
        end
      else
        customer = Stripe::Customer.create(
            :description => admin_url,
            :source => stripe_token,
            :email => email)
      end
      self.stripe_customer_id = customer.id
      User.where(id: id).update_all(stripe_customer_id: customer.id)

      customer
    end

    ## !!!! this is only valid for tests
    def stripe_account_id=(new_acct_id)
      existing = stripe_auth
      existing.destroy if existing

      user_auth_hash = {
          :provider => 'stripe_connect',
          :uid => new_acct_id,
          :token => 'bogus',
          :refresh_token => 'refresh_bogus',
          :token_expiration => Date.new(2050, 1, 1),
          :secret => "secret"
      }

      authorization = user_authorizations.build(user_auth_hash)
      authorization.save!
    end

    def card_approved(token, zip, booking_id, test_drive_package_choice_id = nil)

      approved_booking = nil
      choice = nil
      found_uncollectables = nil
      User.transaction do
        self.stripe_token = token if token
        self.stripe_zip_code = zip if zip
        customer = sync_stripe_customer
        self.stripe_customer_id = customer.id
        self.stored_credit_card = true
        if self.save
          if booking_id
            approved_booking = LessonBooking.find_by_id(booking_id)
            if approved_booking
              approved_booking.card_approved
            end
          end

          if test_drive_package_choice_id
            choice = TestDrivePackageChoice.find(test_drive_package_choice_id)
            choice.lesson_bookings.each do|booking|
              booking.card_approved
            end
          end

          if uncollectables.count > 0
            found_uncollectables = uncollectables
            uncollectables.update_all(billing_should_retry: true)
          else
            found_uncollectables = nil
          end
        end
      end
      [approved_booking, found_uncollectables, choice]
    end

    def update_name(name)
      if name.blank?
        self.first_name = ''
        self.last_name = ''
      else
        bits = name.split
        if bits.length == 1
          self.first_name = ''
          self.last_name = bits[0].strip
        elsif bits.length == 2
          self.first_name = bits[0].strip
          self.last_name = bits[1].strip
        else
          self.first_name = bits[0].strip
          self.last_name = bits[1..-1].join(' ')
        end
      end
      self.save
    end

    def payment_update(params)
      booking = nil
      test_drive = nil
      normal = nil
      intent = nil
      purchase = nil
      lesson_package_type = nil
      uncollectables = nil
      choice = nil
      posa_card = nil
      User.transaction do

        if params[:name].present?
          if !self.update_name(params[:name])
            return nil
          end
        end

        booking, uncollectables, choice = card_approved(params[:token], params[:zip], params[:booking_id], params[:test_drive_package_choice_id])
        if params[:test_drive]
          self.reload
          if booking
            # bookin will indicate test package
            lesson_package_type = booking.resolved_test_drive_package
            posa_card = booking.posa_card
          elsif choice
            # packages also indicate lesson package
            lesson_package_type = choice.lesson_package_type
          elsif self.lesson_package_needs_purchase
            # user has a POSA card requiring purchase, so this takes preference over the 'desired_package' (a user could have both set, but we force user to pay for POSA_CARD requiring purchase before picking up a random TD purchase)
            lesson_package_type = self.lesson_package_needs_purchase
            # also update POSA cards indicating they have been bought. This below code is a little bit
            posa_card = self.posa_cards.where(requires_purchase: true).where(purchased:false).order(:created_at).first
          else
            # the user has at some point b4 indicated interest in a package; so in absence of above indicators, this is what they are buying
            lesson_package_type = self.desired_package
          end

          result = Sale.purchase_test_drive(self, lesson_package_type, booking, posa_card)
          test_drive = result[:sale]
          purchase = result[:purchase]

          if posa_card && !purchase.errors.any?
            posa_card.has_been_purchased(false)
          end
          if booking && !purchase.errors.any?
            # the booking would not have a lesson_package_purchase associated yet, so let's associate it
            booking.lesson_sessions.update_all(lesson_package_purchase_id: purchase.id)
          end
        elsif params[:normal]
          self.reload
        end

      end


      {lesson: booking, test_drive: test_drive, purchase: purchase, lesson_package_type: lesson_package_type, uncollectables: uncollectables, package: choice}
    end

    def requested_test_drive(teacher = nil)
      query = LessonBooking.requested(self).where(lesson_type: LessonBooking::LESSON_TYPE_TEST_DRIVE)
      if teacher
        query = query.where(teacher_id: teacher.id)
      end
      query.first
    end

    def unprocessed_test_drive
      LessonBooking.unprocessed(self).where(lesson_type: LessonBooking::LESSON_TYPE_TEST_DRIVE).first
    end

    def unprocessed_normal_lesson
      LessonBooking.unprocessed(self).where(lesson_type: LessonBooking::LESSON_TYPE_PAID).first
    end

    def most_recent_posa_purchase
      lesson_purchases.where('lesson_package_type_id in (?)', LessonPackageType.test_drive_package_ids).where('posa_card_id is not null').order('created_at desc').first
    end

    def most_recent_posa_card
      posa_cards.where('lesson_package_type_id in (?)', LessonPackageType.test_drive_package_ids).order('created_at desc').first
    end

    def most_recent_test_drive_purchase
      lesson_purchases.where('lesson_package_type_id in (?)', LessonPackageType.test_drive_package_ids).order('created_at desc').first
    end

    def total_test_drives
      purchase = most_recent_test_drive_purchase
      if purchase
        purchase.test_drive_count
      else
        0
      end
    end


    def total_posa_credits
      purchase = most_recent_posa_purchase
      if purchase
        purchase.posa_card.credits
      else
        0
      end
    end

    def test_drive_succeeded(lesson_session)
      if (lesson_session.posa_card && self.jamclass_credits <= 0) || (!lesson_session.posa_card && self.remaining_test_drives <= 0)
        UserMailer.student_test_drive_lesson_done(lesson_session).deliver_now
        UserMailer.teacher_lesson_completed(lesson_session).deliver_now
      else
        UserMailer.student_test_drive_lesson_completed(lesson_session).deliver_now
        UserMailer.teacher_lesson_completed(lesson_session).deliver_now
      end
    end

    def test_drive_declined(lesson_session)
      # because we decrement test_drive credits as soon as you book, we need to bring it back now
      if lesson_session.lesson_booking.user_decremented
        if lesson_session.posa_card
          self.jamclass_credits = self.jamclass_credits + 1
        else
          self.remaining_test_drives = self.remaining_test_drives + 1

        end

      self.save(validate: false)
      end

    end

    def test_drive_failed(lesson_session)

      if lesson_session.lesson_booking.user_decremented
        # because we decrement test_drive credits as soon as you book, we need to bring it back now
        if lesson_session.posa_card
          self.jamclass_credits = self.jamclass_credits + 1
        else
          self.remaining_test_drives = self.remaining_test_drives + 1
        end

        self.save(validate: false)
      end
      UserMailer.teacher_test_drive_no_bill(lesson_session).deliver_now
      UserMailer.student_test_drive_no_bill(lesson_session).deliver_now
    end

    def used_test_drives
      total_test_drives - remaining_test_drives
    end

    def used_posa_credits
      total_posa_credits - jamclass_credits
    end

    def uncollectables(limit = 10)
      LessonPaymentCharge.where(user_id:self.id).order(:created_at).where('billing_attempts > 0').where(billed: false).limit(limit)
    end

    def has_rated_teacher(teacher)
      teacher_rating(teacher).count > 0
    end

    def teacher_rating(teacher)
      if teacher.is_a?(JamRuby::User)
        teacher = teacher.teacher
      end
      Review.where(target_id: teacher.id).where(target_type: teacher.class.to_s)
    end

    def has_rated_student(student)
      student_rating(student).count > 0
    end

    def student_rating(student)
      Review.where(target_id: student.id).where(target_type: "JamRuby::User")
    end

    def teacher_profile_url
      "#{APP_CONFIG.external_root_url}/client#/profile/teacher/#{id}"
    end

    def profile_url
      "#{APP_CONFIG.external_root_url}/client#/profile/#{id}"
    end

    def ratings_url
      "#{APP_CONFIG.external_root_url}/client?tile=ratings#/profile/teacher/#{id}"
    end

    def student_ratings_url
      "#{APP_CONFIG.external_root_url}/client?selected=ratings#/profile/#{id}"
    end

    def self.search_url
      "#{APP_CONFIG.external_root_url}/client#/jamclass/searchOptions"
    end

    def recent_test_drive_teachers
      User.select('distinct on (users.id) users.*').joins(taught_lessons: :music_session).where('lesson_sessions.lesson_type = ?', LessonSession::LESSON_TYPE_TEST_DRIVE).where('music_sessions.user_id = ?', id).where('lesson_sessions.created_at > ?', APP_CONFIG.test_drive_wait_period_year.years.ago)
    end

    def mark_session_ready
      self.ready_for_session_at = Time.now
      self.save!
    end

    def mark_session_not_ready
      self.ready_for_session_at = nil
      self.save!
    end

    def mark_sent_paid_lesson
      self.stuck_take_plesson = false
      self.sent_admin_take_plesson_email_at = Time.now
      self.save!
    end

    def mark_sent_2nd_free_lesson
      self.stuck_take_2nd_flesson = false
      self.sent_admin_take_2nd_flesson_email_at = Time.now
      self.save!
    end

    def mark_sent_1st_free_lesson
      self.stuck_take_flesson = false
      self.sent_admin_take_flesson_email_at = Time.now
      self.save!
    end

    def mark_onboarded
      self.onboarding_onboarded_at = Time.now
      self.save!
    end

    def mark_lost(lost_reason = LOST_REASON_OTHER)
      self.onboarding_lost_at = Time.now
      self.onboarding_lost_reason = lost_reason
      self.save!
    end

    def has_booked_with_student?(student, since_at = nil)
      LessonBooking.engaged_bookings(student, self, since_at).count > 0
    end

    def has_booked_test_drive_with_student?(student, since_at = nil)
      LessonBooking.engaged_bookings(student, self, since_at).test_drive.count > 0
    end

    def same_school_with_student?(student)
      student.school && self.teacher && self.teacher.school && student.school.id == self.teacher.school.id
    end

    def computed_onboarding_status
      if first_onboarding_paid_lesson_at
        ONBOARDING_STATUS_PAID_LESSON
      elsif second_onboarding_free_lesson_at || first_onboarding_free_lesson_at
        ONBOARDING_STATUS_FREE_LESSON
      elsif onboarding_onboarded_at
        ONBOARDING_STATUS_ONBOARDED
      elsif onboarding_lost_reason
        ONBOARDING_STATUS_LOST
      elsif onboarding_escalation_reason
        ONBOARDING_STATUS_ESCALATED
      elsif onboarding_email_5_sent_at
        ONBOARDING_STATUS_EMAILED
      elsif onboarder_id
        ONBOARDING_STATUS_ASSIGNED
      else
        ONBOARDING_STATUS_UNASSIGNED
      end
    end

    private
    def create_remember_token
      self.remember_token = SecureRandom.urlsafe_base64
    end

    def default_anonymous_names
      self.first_name = 'Anonymous' if self.first_name.nil?
      self.last_name = 'Anonymous' if self.last_name.nil?
    end

    def stringify_avatar_info
      # fpfile comes in as a hash, which is a easy-to-use and validate form.  However, we store it as a VARCHAR,
      # so we need t oconvert it to JSON before storing it (otherwise it gets serialized as a ruby object)
      # later, when serving this data out to the REST API, we currently just leave it as a string and make a JSON capable
      # client parse  it, because it's very rare when it's needed at all
      self.original_fpfile = original_fpfile.to_json if !original_fpfile.nil?
      self.cropped_fpfile = cropped_fpfile.to_json if !cropped_fpfile.nil?
      self.crop_selection = crop_selection.to_json if !crop_selection.nil?
    end
  end
end