apple-tv-converter 0.6.2 → 0.7.0

data/lib/apple_tv_converter/metadata/imdb.rb

@@ -0,0 +1,77 @@
+module AppleTvConverter
+  module Metadata
+    class Imdb
+      def self.get_metadata(media, interactive = true, language = 'en')
+        printf "* Getting info from IMDB" if interactive
+
+        metadata_id = media.get_metadata_id(:imdb, :show)
+
+        if !metadata_id
+          search = ::Imdb::Search.new(media.show)
+
+          search.movies.delete_if do |item|
+            item.title.strip =~ /(?:(?:\(TV\s*(?:Movie|(?:Mini.?)?Series|Episode))|(?:Video(?:\s*Game)?))/i
+          end
+
+          metadata_id = if search.movies.length > 1 && interactive
+            choice = 0
+            puts "\n  *"
+            while true
+              puts %Q[  | Several movies found, choose the intended one#{" (showing only the first 20 of #{search.movies.length} results)" if search.movies.length > 20}:]
+
+              search.movies[0...20].each_with_index do |item, index|
+                puts "  | #{(index + 1).to_s.rjust(search.movies.length.to_s.length)} - #{item.title.strip} (id: #{item.id})"
+                if item.also_known_as.any?
+                  akas = item.also_known_as[0...5].each do |aka|
+                    puts "  | #{' '.rjust(search.movies.length.to_s.length)}   AKA: #{(aka.is_a?(Hash) ? aka[:title] : aka).strip}"
+                  end
+                end
+              end
+
+              printf "  |\n  *- What's your choice (1..#{[search.movies.length, 20].min})? "
+              choice = STDIN.gets.chomp.to_i
+
+              break if choice.between?(1, [search.movies.length, 20].min)
+
+              puts "  | Invalid choice!"
+              puts "  |"
+            end
+
+            printf "  * Getting info from IMDB"
+            search.movies[choice - 1].id
+          else
+            search.movies.first.id rescue nil
+          end
+        end
+
+        # begin
+          if metadata_id
+            imdb_movie = ::Imdb::Movie.new(metadata_id)
+
+            media.metadata.name = imdb_movie.title.gsub(/"/, '"')
+            media.metadata.genre = imdb_movie.genres.first.gsub(/"/, '"') if imdb_movie.genres.any?
+            media.metadata.description = imdb_movie.plot.gsub(/"/, '"') if imdb_movie.plot
+            media.release_date = imdb_movie.year if imdb_movie.year
+            media.metadata.director = (imdb_movie.director.first || '').gsub(/"/, '"') if imdb_movie.director.any?
+            media.metadata.codirector = imdb_movie.director[1].gsub(/"/, '"') if imdb_movie.director.length > 1
+            media.metadata.artwork = imdb_movie.poster if imdb_movie.poster
+
+            media.set_metadata_id :imdb, :show, metadata_id
+
+            puts " [DONE]" if interactive
+          end
+        # rescue OpenURI::HTTPError => e
+        #   media.set_metadata_id :imdb, :show, nil
+        #   media.imdb_movie = nil
+        #   puts (e.message =~ /404/ ? " [NOT FOUND]" : " [ERROR]") if interactive
+        # rescue
+        #   if media.get_metadata_id(:imdb, :show).nil?
+        #     puts " [NOT FOUND]" if interactive
+        #   else
+        #     raise e
+        #   end
+        # end
+      end
+    end
+  end
+end

data/lib/apple_tv_converter/metadata/info.rb

@@ -0,0 +1,23 @@
+module AppleTvConverter
+  module Metadata
+    class Info
+      attr_accessor :name, :genre, :description, :release_date
+      attr_accessor :tv_show, :tv_show_season, :tv_show_episode, :tv_network
+      attr_accessor :screenwriters, :director, :codirector
+      attr_accessor :artwork_filename
+
+      def initialize(media)
+        @media = media
+      end
+
+      def artwork ; @media.artwork_filename ; end
+      def artwork=(value) ; AppleTvConverter.copy value, @media.artwork_filename ; end
+
+      def sort_name ; return @media.is_tv_show_episode? ? "#{tv_show} S#{tv_show_season.to_s.rjust(2, '0')}E#{tv_show_episode.to_s.rjust(2, '0')}" : name ; end
+      def sort_album ; return tv_show ; end
+      def sort_album_artist ; return tv_show ; end
+      def sort_composer ; return tv_show ; end
+      def sort_show ; return "#{tv_show} Season #{tv_show_season.to_s.rjust(2, '0')}" ; end
+    end
+  end
+end

data/lib/apple_tv_converter/metadata/movie_db.rb

@@ -0,0 +1,104 @@
+module AppleTvConverter
+  module Metadata
+    class MovieDb
+      def self.get_metadata(media, interactive = true, language = 'en')
+        show_id = nil
+
+        if media.get_metadata_id(:tmdb, :show)
+          # We have an id, assume it for the search
+          show_id = media.get_metadata_id(:tmdb, :show)
+        else
+          printf  "* Searching TheMovieDb.org "
+
+          # Query the data
+          results = search(media)
+          if results
+            puts "[DONE]"
+
+            if results[:total_results] > 0
+              if results[:total_results] == 1 || !interactive
+                # Only 1 result, or non-interactive, use the first result
+                show_id = results[:results].first[:id]
+              else
+                # More than one result, ask the user
+                choice = 0
+                puts "\n  *"
+
+                while true
+                  puts %Q[  | Several shows found, choose the intended one:]
+
+                  results[:results].each_with_index do |item, index|
+                    puts "  | #{(index + 1).to_s.rjust(results[:total_results].to_s.length)} - #{item[:title]} (#{Date.parse(item[:release_date]).year}) (id: #{item[:id]})"
+                  end
+
+                  printf "  |\n  *- What's your choice (1..#{results[:results].length})? "
+                  choice = STDIN.gets.chomp.to_i
+
+                  break if choice.between?(1, results[:results].length)
+
+                  puts "  | Invalid choice!"
+                  puts "  |"
+                end
+
+                show_id = results[:results][choice - 1][:id]
+              end
+            else
+              # It's not found, return false to continue with other services
+              return false
+            end
+          else
+            puts "[ERROR]"
+          end
+        end
+
+        if show_id.to_i > 0
+          printf  "* Fetching metadata from TheMovieDb.org "
+
+          # Fetch the detailed data
+          data = get(show_id)
+
+          if data
+            puts "[DONE]"
+            media.metadata.name = data[:title]
+            media.metadata.genre = data[:genres].first[:name]
+            media.metadata.description = data[:overview]
+            media.metadata.release_date = data[:release_date]
+            # media.metadata.screenwriters = data[:release_date]
+            # media.metadata.director = data[:release_date]
+            # media.metadata.codirector = data[:release_date]
+            media.metadata.artwork = poster_url(data[:poster_path])
+
+            media.release_date = Date.parse(media.metadata.release_date).year
+            media.set_metadata_id :tmdb, :show, show_id
+
+            return true
+          else
+            puts "[ERROR]"
+          end
+        end
+      end
+
+      private
+
+        def self.api_key; return '5ebb3f1009ddd14d244cbe1645b616a0' ; end
+        def self.base_url; return 'http://api.themoviedb.org/3/'; end
+        def self.build_url(path, params = {}) ; return "#{base_url}#{path}" ; end
+        def self.build_params(params = {}) ; return params.merge(:api_key => api_key) ; end
+        def self.poster_url(extra) ; return "#{configuration[:images][:base_url]}original#{extra}" ; end
+
+        def self.search(media) ; request 'search/movie', :query => media.show ; end
+        def self.get(id) ; request("movie/#{id}", :append_to_response => 'credits') ; end
+        def self.configuration ; @configuration ||= request('configuration') ; end
+
+        def self.request(url, params = {})
+          data = { :params => build_params(params), :accept => 'application/json', :block_response => true }
+          begin
+            return JSON.parse(RestClient.get(build_url(url), data), :symbolize_names => true, :symbolize_keys => true)
+          rescue => e
+            return nil
+          end
+        end
+    end
+  end
+end
+

data/lib/apple_tv_converter/metadata/tv_db.rb

@@ -0,0 +1,303 @@
+module AppleTvConverter
+  module Metadata
+    class TvDb
+      require 'httparty'
+      require 'yaml'
+      require 'net/http'
+      require 'zip/zip'
+      require 'xml'
+
+      include HTTParty
+
+      base_uri 'thetvdb.com/api'
+
+      def self.search(media, interactive = true, language = 'en')
+        get_updates_from_server
+
+        if media.get_metadata_id(:tvdb, :show)
+          show_id = media.get_metadata_id(:tvdb, :show)
+        else
+          data = load_config_file('show_ids') || {}
+
+          # http://thetvdb.com/api/GetSeries.php?seriesname=
+          unless data.has_key?(media.show)
+            printf "* Searching TheTVDB "
+
+            show_ids = get_and_parse_data_from_server('show_ids', '/GetSeries.php', { :query => { :seriesname => media.show } }, ['Data', 'Series']) do |loaded_data|
+              puts "[DONE]"
+              loaded_data = [loaded_data].flatten
+
+              data[media.show] = if loaded_data.length > 1 && interactive
+                choice = 0
+                puts "\n  *"
+
+                while true
+                  puts %Q[  | Several shows found, choose the intended one:]
+
+                  loaded_data.each_with_index do |item, index|
+                    puts "  | #{(index + 1).to_s.rjust(loaded_data.length.to_s.length)} - #{item['SeriesName']} (id: #{item['seriesid']})"
+                    puts "  | #{' '.rjust(loaded_data.length.to_s.length)}   AKA: #{item['AliasNames']}" if item['AliasNames']
+                  end
+
+                  printf "  |\n  *- What's your choice (1..#{loaded_data.length})? "
+                  choice = STDIN.gets.chomp.to_i
+
+                  break if choice.between?(1, loaded_data.length)
+
+                  puts "  | Invalid choice!"
+                  puts "  |"
+                end
+
+                loaded_data[choice - 1]['seriesid']
+              else
+                loaded_data.first['seriesid']
+              end
+
+              # Return the new list sorted by show name
+              Hash[data.sort]
+            end
+
+            puts "[NOT FOUND]" if show_ids.empty?
+          end
+
+          show_id = data[media.show]
+        end
+
+        if show_id.to_i > 0
+          printf "* Getting info from TheTVDB "
+
+          # <mirrorpath_zip>/api/<apikey>/series/<seriesid>/all/<language>.zip
+          show_data = get_data(show_id, "/#{api_key}/series/#{show_id}/all/#{language}.zip", { :zip => true }) do |data|
+            show_data = xml_document_to_hash(XML::Document.string(data[language.to_s].gsub(/>\s*</im, '><')))
+            banners = xml_document_to_hash(XML::Document.string(data['banners'].gsub(/>\s*</im, '><'))) rescue { 'Banner' => [] }
+            actors = xml_document_to_hash(XML::Document.string(data['actors'].gsub(/>\s*</im, '><'))) rescue { 'Actor' => [] }
+
+            {
+              :series => show_data['Series'],
+              :episodes => [show_data['Episode']].flatten,
+              :banners => [banners['Banner']].flatten,
+              :actors => [actors['Actor']].flatten
+            }
+          end
+
+          data = {
+            :episode => show_data[:episodes].detect do |ep|
+              # For season 1, check the absolute number first (for cartoons, etc.), and then check the usual season/episode combo
+              (media.season.to_i == 1 && ep['absolute_number'].to_i == media.number.to_i) || (ep['SeasonNumber'].to_i == media.season.to_i && ep['EpisodeNumber'].to_i == media.number.to_i)
+            end,
+            :show => show_data
+          }
+
+          if data[:episode]
+            media.metadata.tv_show = data[:show][:series]['SeriesName'] || media.show
+            media.metadata.tv_show_season = media.use_absolute_episode_numbering ? 1 : data[:episode]['SeasonNumber']
+            media.metadata.tv_show_episode = data[:episode][media.use_absolute_episode_numbering ? 'absolute_number' : 'EpisodeNumber']
+            media.metadata.tv_network = data[:show][:series]['Network']
+            media.metadata.name = data[:episode]['EpisodeName'] || "#{media.metadata.tv_show} S#{media.metadata.tv_show_season.to_s.rjust(2, '0')}E#{media.number.to_s.rjust(2, '0')}"
+            media.metadata.genre = data[:show][:series]['Genre'].gsub(/(?:^\|)|(?:\|$)/, '').split('|').first rescue nil
+            media.metadata.description = data[:episode]['Overview']
+            media.metadata.release_date = data[:episode]['FirstAired']
+            media.metadata.screenwriters = data[:episode]['Writer'].gsub(/(?:^\|)|(?:\|$)/, '').split('|').join(', ') rescue nil
+            media.metadata.director = data[:episode]['Director']
+            media.metadata.artwork = get_poster(media, data)
+
+            # Update some data in the media
+            set_metadata_id_if_not_set(:imdb, :show, data[:show][:series]['IMDB_ID']) rescue nil
+            media.release_date = media.metadata.release_date
+
+            # Update the episode name, if available
+            media.episode_title = data[:episode]['EpisodeName']
+            media.set_metadata_id :tvdb, :show, data[:episode]['seriesid']
+            media.set_metadata_id :tvdb, :season, data[:episode]['seasonid']
+            media.set_metadata_id :tvdb, :episode, data[:episode]['id']
+            media.set_metadata_id :imdb, :episode, data[:episode]['IMDB_ID']
+
+            puts "[DONE]"
+
+            return true
+          else
+            puts "[NOT FOUND]"
+          end
+        end
+
+        return false
+      end
+
+      def self.get_poster(media, data = nil)
+        local_file = File.join(AppleTvConverter.data_path, 'cache', 'tvdb', "#{media.tvdb_id}.jpg")
+
+        unless File.exists?(local_file)
+          artwork_filename = data[:show][:series]['poster'] || ''
+          artwork_filename = data[:episode]['filename'] || '' if artwork_filename.blank?
+          artwork_filename = "http://thetvdb.com/banners/#{artwork_filename}" if !artwork_filename.blank?
+
+          AppleTvConverter.copy artwork_filename, local_file unless artwork_filename.blank?
+        end
+
+        local_file
+      end
+
+      private
+
+        def self.api_key ; return '67FBF9F0670DBDF2' ; end
+        def self.local_cache_base_path
+          return File.expand_path(File.join(AppleTvConverter.data_path, 'cache', 'tvdb'))
+        end
+        def self.server_update_timestamp
+          @server_update_timestamp ||= load_config_file('update')
+
+          unless @server_update_timestamp
+            # http://thetvdb.com/api//Updates.php?type=none
+            @server_update_timestamp = get_data_from_server('/Updates.php', { :query => { :type => 'none' }})["Items"]["Time"] rescue nil
+            @server_update_timestamp = @server_update_timestamp.to_i unless @server_update_timestamp.nil?
+            save_config_file 'update', @server_update_timestamp
+          end
+
+          @server_update_timestamp
+        end
+
+        def self.load_config_file(filename)
+          full_filename = File.join(local_cache_base_path, filename =~ /\.yml$/ ? filename : "#{filename}.yml")
+          File.exists?(full_filename) ? YAML.load_file(full_filename) : nil
+        end
+
+        def self.save_config_file(filename, data)
+          full_filename = File.join(local_cache_base_path, filename =~ /\.yml$/ ? filename : "#{filename}.yml")
+          File.open(full_filename, 'w') { |f| f.write data.to_yaml }
+        end
+
+        def self.delete_config_file(filename)
+          full_filename = File.join(local_cache_base_path, filename =~ /\.yml$/ ? filename : "#{filename}.yml")
+          File.delete(full_filename) if File.exists?(full_filename)
+        end
+
+
+        def self.get_data_from_server(url, options = {})
+          AppleTvConverter.logger.debug "  -> Getting from server: #{url}"
+          cache = options.delete(:cache) || true
+          zip = options.delete(:zip) || false
+          response = self.get(url, options).parsed_response
+
+          if zip
+            filename = File.join(local_cache_base_path, 'zip_file.zip')
+
+            begin
+              File.open(filename, 'wb') { |f| f.write response }
+              response = {}
+
+              Zip::ZipFile.open(filename) do |zipfile|
+                zipfile.each do |entry|
+                  unless entry.name.downcase["__macosx"]
+                    zip_data = zipfile.read(entry)
+                    response[entry.name.to_s.gsub(/\.xml$/i, '')] = zip_data
+                  end
+                end
+              end
+            rescue => e
+              ap [e, e.backtrace]
+
+            ensure
+              FileUtils.rm_f filename if File.exists?(filename)
+            end
+          end
+
+          return response
+        end
+
+        def self.get_data(filename, url, url_options, response_indexes = [])
+          AppleTvConverter.logger.debug "-> Getting data: #{filename}"
+          data = load_config_file(filename)
+
+          unless data
+            data = get_data_from_server(url, url_options)
+
+            if data
+              begin
+                response_indexes.each { |idx| data = data[idx] }
+
+                data = yield(data) if block_given?
+
+                save_config_file filename, data
+              rescue
+                data = nil
+              end
+            end
+          else
+            # ap ['found on cache', filename, data]
+          end
+
+          return data
+        end
+
+        def self.get_and_parse_data_from_server(filename, url, url_options, response_indexes = [])
+          cache = url_options.delete(:cache) || true
+          data = get_data_from_server(url, url_options)
+
+          if data
+            begin
+              response_indexes.each { |idx| data = data[idx] }
+
+              data = yield(data) if block_given?
+
+              save_config_file filename, data if cache
+            rescue
+              data = nil
+            end
+          end
+        end
+
+        def self.get_updates_from_server(options = {})
+          get_and_parse_data_from_server('updates', '/Updates.php', { :query => { :type => 'all', :time => load_config_file('update')}, :cache => false }, ['Items']) do |data|
+            if data
+              # Delete each show's cached data
+              data['Series'].each do |show_id|
+                delete_config_file show_id
+                delete_config_file "#{show_id}.jpg"
+              end
+
+              # Save the new timestamp
+              save_config_file 'update', data['Time']
+              @server_update_timestamp = data['Time']
+            end
+          end
+        end
+
+        def self.xml_document_to_hash(document)
+          def self.xml_node_to_hash(xml)
+            return nil if xml.children.empty?
+            return xml.children.first.to_s if xml.children.count == 1 && xml.children.first.text?
+
+            # Append a sequential number to the name to prevent replacing items that should be in an array
+            child_number = 0
+            Hash[*(xml.children.map { |child| child_number += 1 ; ["#{child.name}::#{child_number}", xml_node_to_hash(child)] }.compact.flatten(1))]
+          end
+
+          intermediate_hash = xml_node_to_hash(document.root)
+
+          return Hash[*(intermediate_hash.group_by do |obj|
+            obj.first.gsub(/::\d+$/, '')
+          end.map do |key, value|
+            # Remove the 'key' entries
+            value = value.flatten(1).delete_if { |v| v.to_s =~ /#{key}::\d+/ }
+
+            # Remove the sequential number from the keys
+            value.map! do |element|
+              Hash[*(element.map do |ikey, ivalue|
+                [ikey.gsub(/::\d+$/, ''), ivalue]
+              end.flatten(1))]
+            end
+
+            # If there's only one entry, remove the array
+            value = value.first if value.count == 1
+
+            [key, value]
+          end.flatten(1))]
+        end
+
+        FileUtils.mkdir_p local_cache_base_path
+
+        # Load the server timestamp on startup
+        server_update_timestamp
+    end
+  end
+end