app/models/user.rb - develop - tofflin/music_project

app/models/user.rb
134 строки4 KB
tofflin
Merge branch 'add_strategy' into develop
19 июн 2025, 22:35
19 июн 2025, 22:35df1f8b8
class User < ApplicationRecord
  include Devise::JWT::RevocationStrategies::JTIMatcher
  include Strategic

  # Include default devise modules. Others available are:
  # :confirmable, :lockable, :timeoutable, :trackable and :omniauthable
  devise :database_authenticatable, :registerable, :recoverable, :rememberable,
         :validatable,  :jwt_authenticatable, jwt_revocation_strategy: self
  acts_as_voter


  has_one :artist, dependent: :destroy
  has_many :albums, through: :artist

  has_one_attached :avatar
  has_one_attached :banner
  validates :email, presence: true, uniqueness: true, format: {  with: Devise.email_regexp }
  validates :first_name, presence: true, length: { maximum: 50 }
  validates :last_name, presence: true, length: { maximum: 50 }
  validates :bio, length: { maximum: 500 }, allow_blank: true
  validates :country, length: { maximum: 100 }, allow_blank: true
  validates :city, length: { maximum: 100 }, allow_blank: true
  validates :nickname, presence: true, uniqueness: true, length: { maximum: 50 },
            format: { with: /\A[a-zA-Z0-9_]+\z/,
            message: "can only contain letters, numbers, and underscores" }

  validates :avatar, content_type: ['image/png', 'image/jpeg'], 
            size: { less_than: 5.megabytes, message: 'should be less than 5MB' }
  
  has_many :library_tracks, -> { where('votes.vote_flag = ?', true) }, 
         through: :votes, source: :votable, source_type: 'Track'

  has_many :library_playlists, -> { where('votes.vote_flag = ?', true) }, 
            through: :votes, source: :votable, source_type: 'Playlist'
  has_many :tracks, dependent: :destroy 
  has_many :playlists, dependent: :destroy 

  has_many :subscriptions, foreign_key: :subscriber_id,
            dependent: :destroy, inverse_of: :subscriber
  has_many :subscribed_to_users, through: :subscriptions, source: :subscribed_to

  has_many :reverse_subscriptions, class_name: "Subscription",
           foreign_key: :subscribed_to_id, dependent: :destroy,  inverse_of: :subscribed_to
  has_many :subscribers, through: :reverse_subscriptions, source: :subscriber

  after_update :update_nickname_in_tracs, if: :saved_change_to_nickname?

  enum :user_type, { base: 'base', artist_pro: 'artist_pro' }, default: :base
  delegate :can_create_artist?, :can_create_group?, :can_create_album?, to: :strategy
  after_initialize :initialize_strategy

  def update_nickname_in_tracs
    tracks.update_all(artist: nickname)
  end

  def initialize_strategy
    self.strategy = user_type if strategy.blank? && user_type.present?
  end

  def add_to_library(track)
    track.liked_by(self) unless voted_for?(track)
  end

  def remove_from_library(track)
    track.unliked_by(self) if voted_for?(track)
  end

  def has_in_library?(track)
    voted_up_on?(track)
  end

  def collected_playlists
    find_up_voted_items.select { |item| item.is_a?(Playlist) }
  end

  def collect_playlist(playlist)
    playlist.liked_by(self) unless voted_for?(playlist)
  end

  def uncollect_playlist(playlist)
    playlist.unliked_by(self) if voted_for?(playlist)
  end

  def collected_playlist?(playlist)
    voted_up_on?(playlist)
  end

  def visible_playlists
    Playlist.left_joins(:user_playlists)
            .where("playlists.visibility = ? OR playlists.user_id = ? OR user_playlists.user_id = ?",
                   Playlist.visibilities[:public_visibility], id, id).distinct
  end


  def subscribe(user)
    return false if self == user || subscribed_to_users.include?(user)
     subscribed_to_users << user
  end

  def unsubscribe(user)
    return false unless subscribed_to_users.include?(user)
    subscribed_to_users.destroy(user)
  end

  def subscribed?(user)
    subscribed_to_users.exists?(user.id)
  end

  def subscribers_count
    subscribers.count
  end

  def subscriptions_count
    subscribed_to_users.count
  end

  def liked_tracks
    liked_items = self.find_up_voted_items
    liked_items.select { |item| item.is_a?(Track) }
  end

  # Переопределение стандартного метода из device-jwt для добавления nickname при регистрации
  def jwt_payload
    super.merge({ nickname: nickname })
  end

  #strategy

  def build_artist(attributes = {})
    return artist if artist.present?
    Artist.new({ user: self }.merge(attributes))
  end
  
end