vk_music 3.1.5 → 4.0.2

data/lib/vk_music/request/wall_section.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module VkMusic
+  module Request
+    # Wall in JSON sections request
+    class WallSection < Base
+      # Initialize new request
+      # @param owner_id [Integer]
+      # @param post_id [Integer]
+      # @param offset [Integer]
+      # @param client_id [Integer]
+      def initialize(owner_id, post_id, client_id)
+        @client_id = client_id
+        super(
+          "#{VK_ROOT}/audio",
+          {
+            act: 'load_section', type: 'wall', utf8: true,
+            owner_id: owner_id, post_id: post_id, wall_type: 'own'
+          },
+          'GET',
+          {}
+        )
+      end
+
+      def_delegators :@parser, :audios, :title, :subtitle, :real_size, :more?
+
+      private
+
+      def after_call
+        @parser = WebParser::WallSection.new(@response, client_id: @client_id)
+      end
+    end
+  end
+end

data/lib/vk_music/utility.rb

@@ -1,78 +1,8 @@
-require_relative "utility/log"
-
-module VkMusic
-  ##
-  # Utility methods.
-  module Utility
-    ##
-    # Turn amount of seconds into string.
-    # @param s [Integer] amount of seconds.
-    # @return [String] formatted string.
-    def self.format_seconds(s)
-      s = s.to_i # Require integer
-      "#{(s / 60).to_s.rjust(2, "0")}:#{(s % 60).to_s.rjust(2, "0")}";
-    end
-
-    ##
-    # Guess type of request by from string.
-    #
-    # Possible results:
-    # * +:playlist+ - if string match playlist URL.
-    # * +:post+ - if string match post URL.
-    # * +:audios+ - if string match user or group URL.
-    # * +:find+ - in rest of cases.
-    # @param str [String] request from user for some audios.
-    # @return [Symbol]
-    def self.guess_request_type(str)
-      case str
-        when Constants::Regex::VK_PLAYLIST_URL_POSTFIX
-          :playlist
-        when Constants::Regex::VK_WALL_URL_POSTFIX, Constants::Regex::VK_POST_URL_POSTFIX
-          :post
-        when Constants::Regex::VK_BLOCK_URL
-          :block
-        when Constants::Regex::VK_URL
-          :audios
-        else
-          :find
-      end
-    end
-
-    ##
-    # Turn hash into URL query string.
-    # @param hash [Hash]
-    # @return [String]
-    def self.hash_to_params(hash = {})
-      qs = ""
-      hash.each_key do |key|
-        qs << "&" unless qs.empty?
-        case hash[key]
-          when Array
-            qs << CGI.escape(key.to_s) << "=" << hash[key].map { |value| CGI.escape(value.to_s) }.join(",")
-          else
-            qs << CGI.escape(key.to_s) << "=" << CGI.escape(hash[key].to_s)
-        end
-      end
-      qs
-    end
-
-    ##
-    # Get content of text children of provided Node.
-    # @param node [Nokogiri::Xml::Node]
-    # @return [String]
-    def self.plain_text(node)
-      node.children.select(&:text?).map(&:text).join ""
-    end
-
-    ##
-    # Turn human readable track length to its size in seconds.
-    # @param str [String] string in format "HH:MM:SS" or something alike (+/d++ Regex selector is used).
-    # @return [Integer] amount of seconds.
-    def self.parse_duration(str)
-      str.scan(/\d+/)
-         .map(&:to_i)
-         .reverse
-         .each_with_index.reduce(0) { |m, arr| m + arr[0] * 60**arr[1] }
-    end
-  end
-end
+# frozen_string_literal: true
+
+module VkMusic
+  # Helpers
+  module Utility; end
+end
+
+Dir[File.join(__dir__, 'utility', '*.rb')].each { |file| require_relative file }

data/lib/vk_music/utility/audio_data_parser.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module VkMusic
+  module Utility
+    # Parse {Audio} from +Array+ of audio data
+    module AudioDataParser
+      class << self
+        # @param data [Array]
+        # @param client_id [Integer]
+        # @return [Audio]
+        def call(data, client_id)
+          url_encoded = get_url_encoded(data)
+          _add_hash, _edit_hash, action_hash, _delete_hash, _teplace_hash, url_hash = get_secrets(data)
+
+          Audio.new(id: data[0], owner_id: data[1],
+                    secret1: action_hash, secret2: url_hash,
+                    artist: CGI.unescapeHTML(data[4]), title: CGI.unescapeHTML(data[3]),
+                    duration: data[5],
+                    url_encoded: url_encoded, url: nil, client_id: client_id)
+        end
+
+        private
+
+        def get_url_encoded(data)
+          url_encoded = data[2].to_s
+          url_encoded = nil if url_encoded.empty?
+
+          url_encoded
+        end
+
+        def get_secrets(data)
+          data[13].to_s.split('/')
+        end
+      end
+    end
+  end
+end

data/lib/vk_music/utility/audio_items_parser.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module VkMusic
+  module Utility
+    # Parse {Audio} from +Nokogiri::XML::Node+
+    module AudioItemsParser
+      # @param node [Nokogiri::XML::Node]
+      # @param client_id [Integer]
+      # @return [Array<Audio>]
+      def self.call(node, client_id)
+        node.css('.audio_item.ai_has_btn,.audio_item.audio_item_disabled').map do |elem|
+          data = JSON.parse(elem.attribute('data-audio').value)
+          Utility::AudioDataParser.call(data, client_id)
+        end
+      end
+    end
+  end
+end

data/lib/vk_music/utility/audio_node_parser.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module VkMusic
+  module Utility
+    # Parse {Audio} from +Nokogiri::XML::Node+
+    module AudioNodeParser
+      class << self
+        # @param node [Nokogiri::XML::Node]
+        # @param client_id [Integer]
+        # @return [Audio]
+        def call(node, client_id)
+          input = node.at_css('input')
+          if input
+            parse_input(input, node, client_id)
+          else
+            parse_post(node, client_id)
+          end
+        end
+
+        private
+
+        def parse_input(input, node, client_id)
+          id_array = get_id_array(node)
+          artist, title, duration = get_main_data(node)
+
+          Audio.new(id: Integer(id_array[1], 10), owner_id: Integer(id_array[0], 10),
+                    artist: artist, title: title, duration: duration,
+                    url_encoded: get_encoded_url(input), url: nil, client_id: client_id)
+        end
+
+        def get_encoded_url(input)
+          url_encoded = input.attribute('value').to_s
+          url_encoded = nil if url_encoded.empty? || url_encoded == Constants::URL::VK[:audio_unavailable]
+
+          url_encoded
+        end
+
+        def get_id_array(node)
+          node.attribute('data-id').to_s.split('_')
+        end
+
+        def get_main_data(node)
+          [
+            node.at_css('.ai_artist').text.strip,
+            node.at_css('.ai_title').text.strip,
+            Integer(node.at_css('.ai_dur').attribute('data-dur').to_s, 10)
+          ]
+        end
+
+        def parse_post(node, client_id)
+          artist = node.at_css('.medias_music_author').text.strip
+          title = NodeTextChildrenReader.call(node.at_css('.medias_audio_title'))
+          duration = DurationParser.call(node.at_css('.medias_audio_dur').text)
+          Audio.new(artist: artist, title: title, duration: duration, client_id: client_id)
+        end
+      end
+    end
+  end
+end

data/lib/vk_music/utility/audios_from_ids_loader.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module VkMusic
+  module Utility
+    # Load audios from ids
+    module AudiosFromIdsLoader
+      # @param agent [Mechanize]
+      # @param ids [Array<String>]
+      # @return [Array<Audio>]
+      def self.call(agent, ids, client_id)
+        audios = []
+        ids.each_slice(10) do |subarray|
+          page = Request::AudiosReload.new(subarray, client_id)
+          page.call(agent)
+          audios.concat(page.audios)
+        end
+        audios
+      end
+    end
+  end
+end

data/lib/vk_music/utility/audios_ids_getter.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module VkMusic
+  module Utility
+    # Load ids from array of data
+    module AudiosIdsGetter
+      # @param args [Array<Audio, (owner_id, audio_id, secret_1, secret_2),
+      #   "#{owner_id}_#{id}_#{secret_1}_#{secret_2}">]
+      # @return [Array<String>] array of uniq full ids
+      def self.call(args)
+        ids = args.map do |item|
+          case item
+          when Audio then item.full_id
+          when Array then item.join('_')
+          when String then item
+          end
+        end
+        ids.compact!
+        ids.uniq!
+
+        ids
+      end
+    end
+  end
+end

data/lib/vk_music/utility/audios_loader.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module VkMusic
+  module Utility
+    # Load user or group audios
+    module AudiosLoader
+      class << self
+        # @param agent [Mechanize]
+        # @param client_id [Integer]
+        # @param owner_id [Integer]
+        # @param up_to [Integer]
+        # @return [Playlist?]
+        def call(agent, client_id, owner_id, up_to)
+          page = Request::PlaylistSection.new(owner_id, -1, '', 0, client_id).call(agent)
+          audios = page.audios
+          return if audios.nil? || audios.empty?
+
+          up_to = page.real_size if up_to > page.real_size
+
+          load_till_up_to(audios, agent, client_id, owner_id, up_to)
+
+          Playlist.new(audios, id: -1, owner_id: owner_id, access_hash: '',
+                               title: page.title, subtitle: page.subtitle, real_size: page.real_size)
+        end
+
+        private
+
+        def load_till_up_to(audios, agent, client_id, owner_id, up_to)
+          return audios.slice!(up_to..) if up_to <= audios.size
+
+          rest = PlaylistSectionLoader.call(agent, client_id, owner_id, -1, '', audios.size, up_to - audios.size)
+          audios.concat(rest)
+        end
+      end
+    end
+  end
+end

data/lib/vk_music/utility/data_type_guesser.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require_relative 'playlist_url_parser'
+require_relative 'post_url_parser'
+
+module VkMusic
+  module Utility
+    # Guess type of method to use based on string data
+    module DataTypeGuesser
+      # End of playlist URL
+      PLAYLIST_POSTFIX = PlaylistUrlParser::VK_PLAYLIST_URL_POSTFIX
+      public_constant :PLAYLIST_POSTFIX
+
+      # End of post URL
+      POST_POSTFIX = PostUrlParser::POST_POSTFIX
+      public_constant :POST_POSTFIX
+
+      # End of wall URL
+      WALL_POSTFIX = /.*wall(-?\d+)/.freeze
+      public_constant :WALL_POSTFIX
+
+      # End of profile audios URL
+      AUDIOS_POSTFIX = /.*audios(-?\d+)/.freeze
+      public_constant :AUDIOS_POSTFIX
+
+      # Full profile URL regex
+      PROFILE_URL = %r{(?:https?://)?(?:vk\.com/)([^/?&]+)}.freeze
+      public_constant :PROFILE_URL
+
+      # @param data [String]
+      # @return [Symbol]
+      def self.call(data)
+        case data
+        when PLAYLIST_POSTFIX then :playlist
+        when POST_POSTFIX then :post
+        when WALL_POSTFIX then :wall
+        when AUDIOS_POSTFIX, PROFILE_URL then :audios
+        else :find
+        end
+      end
+    end
+  end
+end

data/lib/vk_music/utility/duration_parser.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module VkMusic
+  module Utility
+    # Turn human readable track length to its size in seconds
+    module DurationParser
+      # @param str [String] string in format "HH:MM:SS" or something alike (+/d++ Regex selector is used)
+      # @return [Integer] amount of seconds
+      def self.call(str)
+        str.scan(/\d+/)
+           .map(&:to_i)
+           .reverse
+           .each_with_index.reduce(0) { |acc, (count, position)| acc + count * 60**position }
+      end
+    end
+  end
+end

data/lib/vk_music/utility/last_profile_post_loader.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require_relative 'profile_id_resolver'
+
+module VkMusic
+  module Utility
+    # Get user or group id from url
+    module LastProfilePostLoader
+      # vk.com url regex
+      VK_PATH = ProfileIdResolver::VK_PATH
+      private_constant :VK_PATH
+
+      # @param agent [Mechanize]
+      # @param url [String] URL to profile page
+      # @return [Array(owner_id?, post_id?)]
+      def self.call(agent, url: nil, owner_id: nil)
+        path = url&.match(VK_PATH)&.captures&.first
+        request = VkMusic::Request::Profile.new(profile_id: owner_id, profile_custom_path: path)
+        request.call(agent)
+        [request.id, request.last_post_id]
+      rescue Mechanize::ResponseCodeError
+        [nil, nil]
+      end
+    end
+  end
+end

data/lib/vk_music/utility/link_decoder.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module VkMusic
+  module Utility
+    # Link decoding utilities
+    module LinkDecoder
+      # JS code which creates function to unmask audio URL.
+      JS_CODE = <<~HEREDOC
+        function vk_unmask_link(link, vk_id) {
+
+          // Utility functions to unmask
+
+          var audioUnmaskSource = function (encrypted) {
+            if (encrypted.indexOf('audio_api_unavailable') != -1) {
+              var parts = encrypted.split('?extra=')[1].split('#');
+
+              var handled_anchor = '' === parts[1] ? '' : handler(parts[1]);
+
+              var handled_part = handler(parts[0]);
+
+              if (typeof handled_anchor != 'string' || !handled_part) {
+                // if (typeof handled_anchor != 'string') console.warn('Handled_anchor type: ' + typeof handled_anchor);
+                // if (!handled_part) console.warn('Handled_part: ' + handled_part);
+                return encrypted;
+              }
+
+              handled_anchor = handled_anchor ? handled_anchor.split(String.fromCharCode(9)) : [];
+
+              for (var func_key, splited_anchor, l = handled_anchor.length; l--;) {
+                splited_anchor = handled_anchor[l].split(String.fromCharCode(11));
+                func_key = splited_anchor.splice(0, 1, handled_part)[0];
+                if (!utility_object[func_key]) {
+                  // console.warn('Was unable to find key: ' + func_key);
+                  return encrypted;
+                }
+                handled_part = utility_object[func_key].apply(null, splited_anchor)
+              }
+
+              if (handled_part && 'http' === handled_part.substr(0, 4)) return handled_part;
+              // else console.warn('Failed unmasking: ' + handled_part);
+            } else {
+              // console.warn('Bad link: ' + encrypted);
+            }
+            return encrypted;
+          }
+
+          var handler = function (part) {
+            if (!part || part.length % 4 == 1) return !1;
+            for (var t, i, o = 0, s = 0, a = ''; i = part.charAt(s++);) {
+              i = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMN0PQRSTUVWXYZO123456789+/='.indexOf(i)
+              ~i && (t = o % 4 ? 64 * t + i : i, o++ % 4) && (a += String.fromCharCode(255 & t >> (-2 * o & 6)));
+            }
+            return a;
+          }
+
+          var utility_object = {
+            i: function(e, t) {
+              return utility_object.s(e, t ^ vk_id);
+            },
+            s: function(e, t) {
+              var n = e.length;
+              if (n) {
+                var i = r_func(e, t),
+                  o = 0;
+                for (e = e.split(''); ++o < n;)
+                  e[o] = e.splice(i[n - 1 - o], 1, e[o])[0];
+                e = e.join('')
+              }
+              return e;
+            }
+          };
+
+          var r_func = function (e, t) {
+            var n = e.length,
+              i = [];
+            if (n) {
+              var o = n;
+              for (t = Math.abs(t); o--;)
+                t = (n * (o + 1) ^ t + o) % n,
+                i[o] = t;
+            }
+            return i;
+          }
+
+          return audioUnmaskSource(link);
+        }
+      HEREDOC
+      private_constant :JS_CODE
+
+      # JS context with unmasking link
+      @@js_context = ExecJS.compile(JS_CODE)
+
+      # Unmask audio download URL
+      # @param link [String] encoded link to audio. Usually looks like
+      #   "https://m.vk.com/mp3/audio_api_unavailable.mp3?extra=...".
+      # @param client_id [Integer] ID of user which got this link. ID is required for decoding.
+      # @return [String?] audio download URL, which can be used only from current IP.
+      def self.call(link, client_id)
+        VkMusic.log.debug('LinkDecoder') { "Unmasking link `#{link}` with client id #{client_id}" }
+        @@js_context.call('vk_unmask_link', link, client_id)
+      rescue StandardError => e
+        VkMusic.log.warn('LinkDecoder') { "Failed to decode link `#{link}`: #{e.full_message}" }
+        nil
+      end
+    end
+  end
+end