asca 0.1.2 → 1.0.0

data/asca.gemspec

@@ -31,6 +31,7 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "rake", "~> 10.0"
   spec.add_development_dependency "minitest", "~> 5.0"
   spec.add_dependency "json"
+  #https://github.com/httprb/http/wiki
   spec.add_dependency "http"
   spec.add_dependency 'jwt'
 end

data/exe/asca

@@ -10,31 +10,71 @@ require 'optparse'
 
 options = {}
 option_parser = OptionParser.new do |opts|
-  opts.banner = 'This is an apple connect api wrapper cli.'
+  opts.banner = 'This is an apple connect api wrapper cli. It wraps most of the apple store connect REST api and also supplement some useful tools based on these apis. For how to use it, refer to https://github.com/xueminghao/appstoreconnectapi plase.'
 
-  opts.on('-a action-name', '--action action-name', 'version, profile-install, profile-download') do |value|
-    options[:action] = value
+  opts.on('--tools tool-name', 'Call a specific tool by name. such as register-device') do |value|
+    options[:tool_name] = value
   end
-  opts.on('-n name', '--name name', 'Profile name') do |value|
-    options[:profile_name] = value
+  
+  opts.on('-a api-name', '--api api-name', 'api name') do |value|
+    options[:api_name] = value
   end
-  opts.on('-v', '--version', 'Get current version') do |value|
-    options[:action] = 'version'
+
+  opts.on('-m method', '--method method', 'api request method') do |value|
+    options[:method] = value
+  end
+
+  opts.on('-n name', '--name name', 'tool or api parameter: name') do |value|
+    options[:name] = value
+  end
+  opts.on('--udid udid', 'tool or api parameter: device udid') do |value|
+    options[:udid] = value
+  end
+  opts.on('--profile-names profile-name-array', 'tool or api parameter: profile name list') do |value|
+    options[:profile_names] = value.split(',')
+  end
+  opts.on('--auto-install', 'tool or api parameter: auto install the downloaded profiles') do
+    options[:auto_install] = true
+  end
+  opts.on('-v', '--version', 'current version') do |value|
+    options[:version] = 'version'
   end
 end.parse!
 
-case options[:action]
-when 'version'
-  Asca::Log.info(Asca::VERSION)
-when 'profile-download'
-  Asca::Profiles.download_profile options[:profile_name]
-when 'profile-install'
-  Asca::Profiles.install_profile options[:profile_name]
-else
-  if options[:action]
-    puts "Unsupported action: " + options[:action]
+tool_name = options[:tool_name]
+api_name = options[:api_name]
+
+if tool_name
+  case tool_name
+  when 'register-device'
+    Asca::Tools.register_device :device_info => { :udid => options[:udid], :name => options[:name] }, :profile_names => options[:profile_names]
+  when 'download-profile'
+    if options[:auto_install]
+      Asca::REST::Provisioning::Profiles.install_profile :name => options[:name]
+    else
+      Asca::REST::Provisioning::Profiles.download_profile :name => options[:name]
+    end
   else
-    puts Asca::Log.error('Wrong parameters')
+    Asca::Tools::Log.error("Unsupported tool name: #{tool_name}")
   end
-
-end
+elsif api_name
+  method = options[:method]
+  method = method ? method : 'get'
+  case api_name  
+  when 'device'
+    case method
+    when 'get'
+      Asca::REST::Provisioning::Devices.list_devices
+    when 'post'
+      Asca::REST::Provisioning::Devices.register_new_device options[:udid], options[:name]
+    else
+      Asca::Tools::Log.error("Unsupported request method #{method} for api #{api_name}, coming soon!!")
+    end
+  else
+    Asca::Tools::Log.error("Unsupported api request #{api_name}, coming soon!!")
+  end
+elsif options[:version]
+  Asca::Tools::Log.info(Asca::VERSION)
+else
+  puts Asca::Tools::Log.error('Wrong parameters')
+end

data/lib/asca.rb

@@ -1,9 +1,15 @@
 require "asca/version"
-require "asca/log.rb"
 require "asca/consts.rb"
-require "asca/configuration.rb"
-require "asca/token"
-require "asca/profiles.rb"
+
+require "asca/rest/provisioning/bundleids.rb"
+require "asca/rest/provisioning/devices.rb"
+require "asca/rest/provisioning/certificates.rb"
+require "asca/rest/provisioning/profiles.rb"
+
+require "asca/tools/log.rb"
+require "asca/tools/configuration.rb"
+require "asca/tools/token"
+require "asca/tools/tools.rb"
 
 module Asca
   class Error < StandardError; end

data/lib/asca/consts.rb

@@ -7,4 +7,7 @@ module Asca
     end
 
     URI_PROFILES = url_for_path('v1/profiles')
+    URI_DEVICES = url_for_path('v1/devices')
+    URI_CERTIFICATES = url_for_path('v1/certificates')
+    URI_BUNDLEIDS = url_for_path('v1/bundleIds')
 end

data/lib/asca/rest/provisioning/bundleids.rb

@@ -0,0 +1,22 @@
+require 'http'
+require 'json'
+
+module Asca
+    module REST
+        module Provisioning
+            class BundleIDs
+                class << self
+                    def list_bundle_ids
+                        response = HTTP.auth('Bearer ' + Asca::Tools::Token.new_token).get(URI_BUNDLEIDS)
+                        if response.status.success?
+                            bundleids = JSON.parse(response.body)
+                            return bundleids
+                        else
+                            puts response.body
+                        end
+                    end
+                end
+            end
+        end
+    end
+end

data/lib/asca/rest/provisioning/certificates.rb

@@ -0,0 +1,32 @@
+require 'http'
+
+module Asca
+    module REST
+        module Provisioning
+            class Certificates
+                class << self
+                    def list_certificates(options = {})
+                        # type enum : [ "DEVELOPMENT", "DISTRIBUTION" ]
+                        type = options[:type]
+                        types = !type ? "DEVELOPMENT, DISTRIBUTION" : type
+                        response = HTTP.auth('Bearer ' + Asca::Tools::Token.new_token).get(URI_CERTIFICATES, :params => { 
+                            "filter[certificateType]" => types
+                        })
+                        if response.status.success?
+                            certificates = JSON.parse(response.body)["data"]
+                            for certificate in certificates do
+                                id = certificate["id"]
+                                name = certificate["attributes"]["name"]
+                                type = certificate["attributes"]["certificateType"]
+                                puts "Certificate id: #{id} name: #{name} type: #{type}"
+                            end
+                        else 
+                            puts response.body
+                        end
+                        return response.status.success?
+                    end
+                end
+            end
+        end
+    end
+end

data/lib/asca/rest/provisioning/devices.rb

@@ -0,0 +1,40 @@
+require 'http'
+require "json"
+
+module Asca
+    module REST
+        module Provisioning
+            class Devices
+                class << self
+                    def list_devices
+                        response = HTTP.auth('Bearer ' + Asca::Tools::Token.new_token).get(URI_DEVICES, :params => { "limit": 200 })
+                        if response.status.success?
+                            devices = JSON.parse(response.body)
+                            puts "device count #{devices["data"].length()}"
+                            return devices["data"]
+                        end
+                        return nil
+                    end
+        
+                    def register_new_device(options = {})
+                        udid = options[:udid] 
+                        name = options[:name]
+                        response = HTTP.auth('Bearer ' + Asca::Tools::Token.new_token).post(URI_DEVICES, :json => { "data" => {
+                            "type" => "devices",
+                            "attributes" => {
+                                "name" => name,
+                                "platform" => "IOS",
+                                "udid" => udid
+                            }
+                        }})
+                        if response.status.success?
+                            return true
+                        else
+                            return false
+                        end
+                    end
+                end
+            end
+        end
+    end
+end

data/lib/asca/rest/provisioning/profiles.rb

@@ -0,0 +1,160 @@
+require 'http'
+require 'json'
+require "base64"
+
+module Asca
+  module REST
+    module Provisioning
+      class Profiles
+        class << self
+          def download_profile(options = {})
+            profile_name = options[:name] 
+            out_put_dir = options[:out_put_dir]
+            if !out_put_dir
+              out_put_dir = Asca::Tools::Configuration.get_config('out_put_dir')
+              if !out_put_dir
+                  puts "Please enter your out put dir:"
+                  out_put_dir = File.expand_path(gets.chomp)
+                  Asca::Tools::Configuration.update_config('out_put_dir', out_put_dir)
+              end
+            end
+            response = HTTP.auth('Bearer ' + Asca::Tools::Token.new_token).get(URI_PROFILES, :params => { 'filter[name]' => profile_name })
+            if response.status.success?
+              profile_obj = JSON.parse(response.body)
+              profile_content = profile_obj["data"][0]["attributes"]['profileContent']
+              File.open(File.expand_path(profile_name + ".mobileprovision", out_put_dir), 'w') do |file|
+                file.write(Base64.decode64(profile_content))
+              end
+            else
+              Asca::Tools::Log.error(response.body)
+            end
+          end
+    
+          def install_profile(options = {})
+            profile_name = options[:name]
+            download_profile :name => profile_name, :out_put_dir => Asca::Tools::Configuration::CACHE_DIR
+            profile_file_path = File.expand_path(profile_name + ".mobileprovision", Asca::Tools::Configuration::CACHE_DIR)
+    
+            # install profile
+            `open #{profile_file_path}`
+          end
+    
+          # notion: bundle_id is not bundle identifier and device id is udid。They are the corresponding api id.
+          def create_new_profile(options = {})
+            if !options[:name]
+              Asca::Tools::Asca::Tools::Log.error('No profile name specified')
+              return false
+            end
+            if !options[:type]
+              Asca::Tools::Asca::Tools::Log.error('No type specified')
+              return false
+            end
+            if !options[:bundle_id]
+              Asca::Tools::Asca::Tools::Log.error('No bundle id specfied')
+              return false
+            end
+            if !options[:certificate_ids] || options[:certificate_ids].length == 0
+              Asca::Tools::Asca::Tools::Log.error('No certificate id specified')
+              return false
+            end
+    
+            response = HTTP.auth('Bearer ' + Asca::Tools::Token.new_token).post(URI_PROFILES, :json => { "data" => {
+              "type" => "profiles",
+              "attributes" => {
+                  "name" => options[:name],
+                  "profileType" => options[:type],
+              },
+              "relationships" => {
+                "bundleId" => {
+                  "data" => {
+                    "type" => "bundleIds",
+                    "id" => options[:bundle_id],
+                  }
+                },
+                "certificates" => {
+                  "data" => options[:certificate_ids].map { |certificate_id| { "type" => "certificates", "id" => certificate_id }}
+                },
+                "devices" => {
+                  "data" => options[:device_ids] ? options[:device_ids].map { |device_id| { "type" => "devices", "id" => device_id } } : nil
+                },
+              }
+            }})
+            if response.status.success?
+                return true
+            else
+                puts response.body
+                return false
+            end      
+          end
+    
+          def delete_profile(options = {})
+            # query profile id
+            response = HTTP.auth('Bearer ' + Asca::Tools::Token.new_token).get(URI_PROFILES, :params => { 'filter[name]' => options[:name] })
+            if response.status.success?
+              responseObj = JSON.parse(response.body)
+              queried_profile_list = responseObj["data"]
+              if queried_profile_list.length() > 0
+                profile_id = queried_profile_list[0]["id"]
+              end
+            else
+              Asca::Tools::Log.error(response.body)
+              return
+            end
+            if !profile_id
+              puts "No profile named #{options[:name]} found!"
+              return
+            end
+    
+            # delete profile
+            response = HTTP.auth('Bearer ' + Asca::Tools::Token.new_token).delete(URI_PROFILES + "/#{profile_id}")
+            if response.status.success?
+              Asca::Tools::Log.info("Profile named #{options[:name]} deleted successfully!")
+            else
+              puts response.body
+            end
+            return response.status.success?
+          end
+    
+          # update profile. The new profile is almost the same as the old one, such as the same name, bundle id, certificate ids, with only exception that the new one always try to include all the currently reigstered devices.
+          def update_profile(options = {}) 
+            # query profile info
+            response = HTTP.auth('Bearer ' + Asca::Tools::Token.new_token).get(URI_PROFILES, :params => { 'filter[name]' => options[:name] })
+            if response.status.success?
+              responseObj = JSON.parse(response.body)
+              queried_profile_list = responseObj["data"]
+              if queried_profile_list.length() > 0
+                profile = queried_profile_list[0]
+              end
+            else
+              Asca::Tools::Log.error(response.body)
+              return
+            end
+            
+            if !profile
+              Asca::Tools::Log.error("No profile named #{options[:name]} found")
+              return
+            end
+            # create new profile
+            profile_type = profile["attributes"]["profileType"]
+    
+            # get bundle id
+            response = HTTP.auth('Bearer ' + Asca::Tools::Token.new_token).get(profile["relationships"]["bundleId"]["links"]["self"])
+            bundle_id = JSON.parse(response.body)["data"]["id"]
+            response = HTTP.auth('Bearer ' + Asca::Tools::Token.new_token).get(profile["relationships"]["certificates"]["links"]["self"])
+            certificate_ids = JSON.parse(response.body)["data"].map { |cer| cer["id"] }
+    
+            device_ids = Asca::REST::Provisioning::Devices.list_devices.map { |device|
+              device["id"]
+            }
+    
+            # delete old prifile
+            delete_profile :name => options[:name]
+            
+            create_new_profile :name => options[:name], :type => profile_type, :bundle_id => bundle_id, :device_ids => device_ids, :certificate_ids => certificate_ids
+            return true
+          end
+        end
+      end
+    end
+  end
+end

data/lib/asca/tools/configuration.rb

@@ -0,0 +1,57 @@
+require 'json'
+require 'fileutils'
+
+module Asca
+    module Tools
+        class Configuration
+            ROOTDIR = File.expand_path '~/.com.hurryup.asca'
+            JSONFILE = File.expand_path 'config.json', ROOTDIR
+            CACHE_DIR = File.expand_path 'cache', ROOTDIR
+            class << self
+                # reset config file
+                def reset_config
+                    # remove all
+                    FileUtils.rm_rf(ROOTDIR)
+    
+                    # create root dir
+                    Dir.mkdir ROOTDIR
+    
+                    # create cache dir
+                    Dir.mkdir CACHE_DIR
+                    
+                    # init config file
+                    File.open(JSONFILE, 'w') { |file|
+                        file.write("{}")
+                    }
+                end
+    
+                # update config
+                def update_config(key, value)
+                    if !File.exist?(JSONFILE)
+                        reset_config
+                    end
+                    file_content = File.read(JSONFILE)
+                    configuration = JSON.parse(file_content)
+                    if value
+                        configuration[key] = value
+                    else
+                        configuration.delete(key)
+                    end
+                    File.open(JSONFILE, 'w') { |file| 
+                        file.write(JSON.pretty_generate(configuration))
+                    }
+                    return 0
+                end
+                
+                def get_config(key)
+                    if !File.exist?(JSONFILE)
+                        reset_config
+                    end
+                    file_content = File.read(JSONFILE)
+                    configuration = JSON.parse(file_content)
+                    return configuration[key]
+                end
+            end
+        end
+    end
+end

data/lib/asca/tools/log.rb

@@ -0,0 +1,55 @@
+module Asca
+    module Tools
+        class Log
+            class Color
+                class << self
+                def time
+                    "\e[37m"
+                end
+    
+                def warn
+                    "\e[33;1m"
+                end
+    
+                def info
+                    "\e[32m"
+                end
+    
+                def error
+                    "\e[31;1m"
+                end
+    
+                def reset
+                    "\e[0m"
+                end
+    
+                def command
+                    "\e[34m"
+                end
+                end
+            end
+    
+            class << self
+                def warn message
+                puts "#{Color.warn}WARN: #{message}#{Color.reset}"
+                end
+    
+                def info message
+                puts "#{Color.info}INFO: #{message}#{Color.reset}"
+                end
+    
+                def error message
+                puts "#{Color.error}ERROR: #{message}#{Color.reset}", STDERR
+                end
+    
+                def command message
+                puts "#{Color.command}RUN: \e[4m#{message}#{Color.reset}"
+                end
+    
+                def puts message, io = STDOUT
+                io.puts "#{Color.time}[#{Time.new}]#{Color.reset} #{message}"
+                end
+            end
+        end
+    end
+end