voluntary_music_metadata_enrichment 0.0.1

data/app/controllers/music_metadata_enrichment/tracks_controller.rb

@@ -0,0 +1,82 @@
+# -*- encoding : utf-8 -*-
+class MusicMetadataEnrichment::TracksController < ::MusicMetadataEnrichment::ApplicationController
+  include ::MusicMetadataEnrichment::BaseController
+  include Applicat::Mvc::Controller::Resource
+  include ::MusicMetadataEnrichment::ArtistConfirmation
+  
+  authorize_resource class: 'MusicTrack', except: [:by_name]
+  
+  def index
+  end
+  
+  def autocomplete
+    artist = MusicArtist.find(params[:artist_id])
+    render json: (
+      artist.tracks.select('id, name').where("name LIKE ?", "#{params[:term]}%").order(:name).limit(10).map{|r| { id: r.id, value: r.name } }
+    ), root: false
+  end
+  
+  def new
+    build_artist
+  end
+  
+  def artist_confirmation
+    confirm_artist('new_track')
+  end
+  
+  def select_artist
+    artist_selection('new_track')
+  end
+  
+  def name
+    build_track
+  end
+  
+  def name_confirmation
+    build_track
+    
+    @tracks = MusicTrack.search_on_musicbrainz(@track.artist.mbid, @track.name)
+  end
+  
+  def create
+    build_track
+    track_creation('new_track')
+  end
+  
+  def show
+    @track = MusicTrack.find(params[:id])
+    get_variables_for_show
+  end
+  
+  def by_name
+    if params[:artist_name].blank? || params[:name].blank?
+      flash[:alert] = I18n.t('music_tracks.by_name.artist_name_or_name_blank')
+      redirect_to music_tracks_path(artist_name: params[:artist_name], name: params[:name]) and return
+    end
+    
+    @tracks = MusicTrack.by_artist_and_name(params[:artist_name], params[:name])
+    @track = @tracks.first if params[:page].blank? && @tracks.count == 1
+ 
+    if @track
+      get_variables_for_show
+      render :show
+    else
+      @tracks = MusicTrack.without_slaves.artist_and_name_like(params[:artist_name], params[:name]) if @tracks.nil? || @tracks.count == 0
+      @tracks = @tracks.paginate(per_page: 10, page: params[:page] || 1)
+    end
+  end
+  
+  def resource
+    @track
+  end
+  
+  private
+  
+  def get_variables_for_show
+    @videos = @track.videos.order_by_status
+    
+    unless @videos.none?
+      @video_likes = current_user.likes_or_dislikes.for_targets('MusicVideo', @videos.map(&:id)).index_by(&:target_id)
+    end
+  end
+end

data/app/controllers/music_metadata_enrichment/videos_controller.rb

@@ -0,0 +1,133 @@
+# -*- encoding : utf-8 -*-
+class MusicMetadataEnrichment::VideosController < ::MusicMetadataEnrichment::ApplicationController
+  include ::MusicMetadataEnrichment::BaseController
+  include Applicat::Mvc::Controller::Resource
+  include ::MusicMetadataEnrichment::ArtistConfirmation
+  include ::MusicMetadataEnrichment::TrackConfirmation
+    
+  authorize_resource class: 'MusicVideo', except: [:by_name]
+    
+  def index
+    if request.xhr? 
+
+      if params[:artist_id].present?
+        @videos = MusicVideo.where(artist_id: params[:artist_id])
+      elsif params[:group_id].present?
+        @videos = MusicMetadataEnrichment::Group.find(params[:group_id]).videos
+      elsif params[:uploaded_by_the_user] == 'true'
+        @videos = MusicVideo.where(user_id: params[:user_id])
+      elsif params[:user_id].present?
+        @videos = User.find(params[:user_id]).music_videos
+      end
+      
+      @videos = @videos.order('created_at DESC').paginate(per_page: 5, page: params[:page] || 1)
+      
+      unless @videos.none? || !user_signed_in?
+        @video_likes = current_user.likes_or_dislikes.for_targets('MusicVideo', @videos.map(&:id)).index_by(&:target_id)
+      end
+      
+      render partial: 'music_metadata_enrichment/videos/collection', locals: { paginate: true }
+    end
+  end
+  
+  def new
+    if params[:artist_id].present?
+      redirect_to track_name_music_videos_path(music_track: { artist_id: params[:artist_id]})
+    elsif params[:track_id].present?
+      redirect_to metadata_music_videos_path(music_video: { track_id: params[:track_id]})  
+    else
+      build_artist
+    end
+  end
+  
+  def artist_confirmation
+    confirm_artist('new_video')
+  end
+  
+  def select_artist
+    artist_selection('new_video')
+  end
+  
+  def track_name
+    build_track
+  end
+  
+  def track_confirmation
+    build_track
+    
+    @tracks = MusicTrack.search_on_musicbrainz(@track.artist.mbid, @track.name)
+  end
+  
+  def create_track
+    build_track
+    track_creation('new_video')
+  end
+  
+  def metadata
+    build_video
+  end
+  
+  def create
+    build_video
+    
+    if @video.save
+      flash[:notice] = I18n.t('music_videos.create.successful')
+      
+      if params[:group_id].present?
+        redirect_to music_group_path(params[:group_id])
+      else
+        redirect_to music_video_path(@video)
+      end
+    else
+      render :metadata
+    end
+  end
+  
+  def show
+    @video = MusicVideo.find(params[:id])
+  end
+  
+  def by_name
+    if params[:artist_name].blank? || params[:name].blank?
+      flash[:alert] = I18n.t('music_videos.by_name.artist_name_or_name_blank')
+      redirect_to music_videos_path(artist_name: params[:artist_name], name: params[:name]) and return
+    end
+     
+    status = if match = params[:name].match(/\(Live\)|\(Official\)|\(Unofficial\)/i)
+      match[0].gsub(/\(|\)/, '').titleize
+    else
+      nil
+    end
+    
+    name = params[:name].gsub(/\(Live\)|\(Official\)|\(Unofficial\)/i, '')
+    
+    unless params[:page].present?
+      @videos = MusicVideo.by_artist_and_name(params[:artist_name], name)
+      @videos = @videos.where(status: status) if status.present?
+      
+      @video = @videos.first if @videos.count == 1
+    end
+    
+    if @video
+      render :show
+    else
+      if @videos.count == 0
+        @videos = MusicVideo.artist_and_name_like(params[:artist_name], name)
+        @videos = @videos.where(status: status) if status.present?
+      end
+      
+      @videos = @videos.paginate(per_page: 10, page: params[:page] || 1)
+    end
+  end
+  
+  def resource
+    @video
+  end
+  
+  private
+  
+  def build_video
+    @video = MusicVideo.new(params[:music_video])
+    @video.user_id = current_user.id
+  end
+end

data/app/controllers/product/music_metadata_enrichment_controller.rb

@@ -0,0 +1,6 @@
+class Product::MusicMetadataEnrichmentController < ApplicationController
+  include ::MusicMetadataEnrichment::BaseController
+  
+  def index
+  end
+end

data/app/models/concerns/year_in_review_music_entry.rb

@@ -0,0 +1,12 @@
+module YearInReviewMusicEntry
+  extend ActiveSupport::Concern
+          
+  included do
+    belongs_to :year_in_review_music
+    belongs_to :user
+    
+    validates :year_in_review_music_id, presence: true
+    
+    acts_as_list scope: :year_in_review_music_id
+  end
+end

data/app/models/music_artist.rb

@@ -0,0 +1,155 @@
+# -*- encoding : utf-8 -*-
+class MusicArtist < ActiveRecord::Base
+  has_many :releases, class_name: 'MusicRelease', foreign_key: 'artist_id', dependent: :destroy
+  has_many :tracks, class_name: 'MusicTrack', foreign_key: 'artist_id'
+  has_many :videos, class_name: 'MusicVideo', foreign_key: 'artist_id'
+  
+  scope :name_like, ->(name) do
+    where(MusicArtist.arel_table[:name].matches("%#{name}%"))
+  end
+  
+  validates :name, presence: true
+  validates :mbid, presence: true, uniqueness: true, length: { is: 36 }
+  
+  after_update :synchronize_artist_name
+  after_create :create_bonustracks_release
+  
+  attr_accessible :name, :mbid, :disambiguation, :founded_at, :dissolved_at, :listeners, :plays
+  
+  state_machine :state, initial: :without_metadata do
+    event :import_metadata do transition :without_metadata => :active; end
+    
+    before_transition :without_metadata => :active do |artist, transition|
+      musicbrainz_artist = MusicBrainz::Artist.find(artist.mbid)
+  
+      artist.update_attributes(
+        disambiguation: musicbrainz_artist.disambiguation,
+        founded_at: artist.musicbrainz_date_to_iso_date(musicbrainz_artist.begin), 
+        dissolved_at: artist.musicbrainz_date_to_iso_date(musicbrainz_artist.end)
+      )
+      
+      lastfm = Lastfm.new(LastfmApiKey, LastfmApiSecret)
+      lastfm_artist = lastfm.artist.get_info(mbid: artist.mbid)
+      artist.update_attributes(listeners: lastfm_artist['stats']['listeners'], plays: lastfm_artist['stats']['playcount'])
+      
+      offset, count = 0, 100
+      
+      begin
+        release_groups = musicbrainz_artist.release_groups(offset: offset)
+        count = release_groups.total_count
+        
+        release_groups.select{|r| ['Album', 'EP'].include?(r.type) && r.secondary_types.select{|st| ['Audiobook', 'Compilation', 'Live', 'Remix'].include?(st)}.none? && r.artists.length == 1}.each do |musicbrainz_release_group|
+          releases = musicbrainz_release_group.releases
+          
+          next if releases.select{|r| r.status == 'Official' && (r.media.map(&:format).none? || r.media.map(&:format).select{|f| !['DVD-Video', 'DVD'].include?(f) }.any?) }.none?
+          
+          release = MusicRelease.create(artist_id: artist.id, artist_name: artist.name, name: musicbrainz_release_group.title)
+          
+          next unless release.persisted?
+            
+          release.releases = releases
+          release.import_metadata!
+        end
+        
+        offset += 100
+      end while offset < count  
+      
+      #artist.import_bonus_tracks
+      #artist.import_music_videos_from_tapetv
+    end
+  end
+  
+  def import_bonus_tracks
+    offset = 0
+    count = 100
+    bonus_track_names = []
+    
+    begin
+      recordings = MusicBrainz::Recording.search(mbid, nil, limit: 100, offset: offset, create_models: true)
+      count = recordings.total_count
+      recordings = recordings.select{|r| !MusicTrack.name_included_in_bonustrack_blacklist?(r.title) && r.disambiguation.blank? }
+      recording_titles = recordings.map{|r| MusicTrack.format_name(r.title).downcase }.uniq
+      voluntary_names = MusicTrack.where("artist_id = :artist_id AND LOWER(name) IN(:name)", artist_id: id, name: recording_titles).map{|t| t.name.downcase }
+      
+      recordings.select{|r| !voluntary_names.include?(MusicTrack.format_name(r.title).downcase) }.each do |recording|
+        next if bonus_track_names.include? MusicTrack.format_name(recording.title).downcase
+        
+        track = MusicTrack.new(artist: self, name: MusicTrack.format_name(recording.title))
+        track.artist_mbid = mbid
+        
+        if track.is_bonus_track?
+          track.create_bonus_track(recording.id)
+          bonus_track_names << track.name.downcase
+        end
+      end
+      
+      offset += 100
+    end while offset < count
+  end
+  
+  def import_music_videos_from_tapetv
+    tapetv_videos, page = [], 1
+    
+    begin
+      response = nil
+      
+      begin
+        response = JSON.parse(HTTParty.get("http://www.tape.tv/#{name.split(' ').join('-').downcase}/videos.json?page=#{page}&page_size=8").body)
+      rescue JSON::ParserError
+      end
+      
+      break if response.nil?
+      
+      tapetv_videos += response.select{|v| !v['title'].match(/\(/) && !v['title'].match(/live/i) }.map{|v| { name: v['title'].gsub(/\(Video\)/, '').strip, url: v['share_url'] } }
+      sleep 5
+      
+      break if response.length != 8
+      
+      page += 1
+    end while !response.nil? && response.length > 0
+    
+    return if tapetv_videos.empty?
+    
+    tracks.where('LOWER(name) IN(?)', tapetv_videos.map{|v| MusicTrack.format_name(v[:name]).downcase }).each do |track|
+      tapetv_video = tapetv_videos.select do |v| 
+        MusicTrack.format_name(v[:name]).downcase == track.name.downcase ||
+        MusicTrack.format_name(v[:name]).downcase.gsub('ß', 'ss') == track.name.downcase.gsub('ß', 'ss')
+      end.first
+      
+      MusicVideo.create(status: 'Official', track_id: track.id, url: tapetv_video[:url]) unless tapetv_video.nil?
+    end
+  end
+  
+  def bonus_tracks_release
+    releases.where(name: '[Bonus Tracks]').first
+  end
+  
+  def musicbrainz_date_to_iso_date(date)
+    return date if date.blank?
+    
+    splitted_date = date.split('-')
+    
+    if splitted_date.length == 1
+      "#{splitted_date.first}-01-01"
+    elsif splitted_date.length == 2
+      "#{splitted_date.first}-#{splitted_date.last}-01"
+    else
+      date
+    end
+  end
+  
+  private
+  
+  def create_bonustracks_release
+    release = releases.create(name: '[Bonus Tracks]')
+    release.update_attribute(:state, 'active')
+  end
+  
+  def synchronize_artist_name
+    return unless name_changed?
+    
+    [MusicRelease, MusicTrack, MusicVideo].each do |klass|
+      klass.where('artist_id = ?', id).update_all ['artist_name = ?', name]
+    end
+  end
+end

data/app/models/music_library_artist.rb

@@ -0,0 +1,10 @@
+# -*- encoding : utf-8 -*-
+class MusicLibraryArtist < ActiveRecord::Base
+  belongs_to :user
+  belongs_to :artist, class_name: 'MusicArtist'
+  
+  validates :user_id, presence: true
+  validates :artist_id, presence: true, uniqueness: { scope: :user_id }
+  
+  attr_accessible :user_id, :artist_id, :plays
+end

data/app/models/music_metadata_enrichment/group.rb

@@ -0,0 +1,136 @@
+module MusicMetadataEnrichment
+  class Group < ActiveRecord::Base
+    self.table_name = 'music_metadata_enrichment_groups'
+    
+    has_many :artist_connections, class_name: 'MusicMetadataEnrichment::GroupArtistConnection', foreign_key: 'group_id', dependent: :destroy
+    has_many :artists, class_name: 'MusicArtist', through: :artist_connections
+    has_many :releases, class_name: 'MusicRelease', through: :artists
+    has_many :videos, class_name: 'MusicVideo', through: :artists
+    
+    validates :name, presence: true, uniqueness: { case_sensitive: false }
+    validate :registered_on_lastfm
+    
+    attr_accessible :name, :artist_connections_text
+    
+    attr_accessor :artist_connections_text
+    
+    def import_artist_connections
+      artist_names_without_mbid = []
+      artist_names = artist_connections_text.split("\n").map(&:strip)
+      
+      artist_names.each do |artist_name|
+        lastfm = Lastfm.new(LastfmApiKey, LastfmApiSecret)
+        lastfm_artist = lastfm.artist.get_info(artist: artist_name)
+        
+        if lastfm_artist['mbid'].blank?
+          artist_names_without_mbid << lastfm_artist['name']
+          
+          next
+        end
+        
+        artist = MusicArtist.where(mbid: lastfm_artist['mbid']).first
+        
+        unless artist
+          musicbrainz_artist = MusicBrainz::Artist.find(lastfm_artist['mbid'])
+          
+          if musicbrainz_artist
+            artist = MusicArtist.where(mbid: musicbrainz_artist.id).first
+            artist = MusicArtist.create(name: lastfm_artist['name'], mbid: musicbrainz_artist.id) unless artist
+          end
+        end
+        
+        next unless artist
+        
+        if artist_connections.where(artist_id: artist.id).none?
+          MusicMetadataEnrichment::GroupArtistConnection.create(group_id: id, artist_id: artist.id)
+        end
+      end
+      
+      artist_names_without_mbid
+    end
+    
+    def import_artists_of_group_members(options = {})
+      last_page = options[:last_page]
+      last_user_name_from_last_run = options[:last_user_name_from_last_run]
+      library_start_page = options[:library_start_page]
+      
+      user_names, page, last_user_name, last_user_name_from_last_run_reached, i = [], nil, nil, false, 1
+      
+      lastfm = Lastfm.new(LastfmApiKey, LastfmApiSecret)
+      
+      1000.times do |page|
+        page +=1
+        
+        if last_page.present? && page == last_page
+          i = (page * 50) + 1
+        elsif last_page.present? && page < last_page
+          next
+        end
+      
+        puts "GROUP MEMBERS PAGE: #{page}"
+        
+        lastfm_users = nil
+        
+        3.times do
+          begin
+            lastfm_users = lastfm.group.get_members(group: 'Dark Electro', page: page)
+            
+            break
+          rescue Lastfm::ApiError
+            puts "GROUP MEMBERS PAGE: #{page} ... TRY AGAIN"
+            sleep 30
+          end
+        end
+        
+        if lastfm_users.select{|u| !user_names.include?(u['name'])}.none?
+          # over last page
+          break
+        end
+      
+        lastfm_users.each do |lastfm_user|
+          if user_names.include?(lastfm_user['name'])
+            next
+          else
+            user_names << lastfm_user['name']
+          end
+      
+          if lastfm_user['name'] == last_user_name_from_last_run
+            last_user_name_from_last_run_reached = true
+          elsif last_user_name_from_last_run.present? && !last_user_name_from_last_run_reached
+            i += 1
+            next
+          end
+          
+          last_user_name = lastfm_user['name']
+          puts "USER #{i}: #{last_user_name} (GROUP MEMBERS PAGE: #{page})"
+          user = User.new
+          user.lastfm_user_name = lastfm_user['name']
+      
+          if lastfm_user['name'] == last_user_name_from_last_run && !library_start_page.nil?
+            user.import_music_artists(lastfm, library_start_page)
+          else
+            user.import_music_artists(lastfm)
+          end
+          
+          i += 1
+        end
+        
+        [page, last_user_name]
+      end
+    end
+    
+    private
+    
+    def registered_on_lastfm
+      return if name.blank?
+      
+      lastfm = Lastfm.new(LastfmApiKey, LastfmApiSecret)
+      
+      begin
+        lastfm.group.get_members(group: name)
+      rescue Lastfm::ApiError
+        errors[:name] << I18n.t('activerecord.errors.models.music_metadata_enrichment_group.attributes.name.not_registered_on_lastfm')
+      end
+    end
+  end
+end

data/app/models/music_metadata_enrichment/group_artist_connection.rb

@@ -0,0 +1,15 @@
+module MusicMetadataEnrichment
+  class GroupArtistConnection < ActiveRecord::Base
+    include Likeable
+    
+    self.table_name = 'music_metadata_enrichment_group_artist_connections'
+    
+    belongs_to :group, class_name: 'MusicMetadataEnrichment::Group'
+    belongs_to :artist, class_name: 'MusicArtist'
+    
+    validates :group_id, presence: true
+    validates :artist_id, presence: true, uniqueness: { scope: :group_id }
+    
+    attr_accessible :group_id, :artist_id
+  end
+end