apprepo 0.0.2 → 0.0.4

data/lib/apprepo/manifest.rb

@@ -1,39 +1,35 @@
 module AppRepo
+  class Manifest
+    #
+    # Translated internal key names from Fastlane to AppRepo
+    #
 
-class Manifest
+    attr_accessor :appcode             # AppRepo Internal Code
+    attr_accessor :filename            # IPA file name
+    attr_accessor :bundle_identifier   # app_identifier
+    attr_accessor :bundle_version      # app_version
+    attr_accessor :title               # app_name
+    attr_accessor :subtitle            # app_description
+    attr_accessor :notify              # will send push notification / slack
 
-#
-# Translated internal key names from Fastlane to AppRepo
-#
+    def initialize(appcode)
+      self.appcode = appcode
+      UI.message('Initializing "AppRepo:Manifest requies at least APPCODE :"' + self.appcode)
+    end
 
-  attr_accessor :appcode             # AppRepo Internal Code
-  attr_accessor :filename            # IPA file name
-  attr_accessor :bundle_identifier   # app_identifier
-  attr_accessor :bundle_version      # app_version
-  attr_accessor :title               # app_name
-  attr_accessor :subtitle            # app_description
-  attr_accessor :notify              # will send push notification / slack
-  
-  def initialize (appcode)
-    self.appcode = appcode
-    puts 'Initializing "AppRepo:Manifest requies at least APPCODE :"'+self.appcode
-  end
-  
-  # Provide JSON serialized data 
-  def getJSON
+    # Provide JSON serialized data
+    def getJSON
       structure = {
-          appcode: self.appcode,
-          filename: self.filename,
-          bundle_identifier: self.bundle_identifier,
-          bundle_version: self.bundle_version,
-          title: self.title,
-          subtitle: self.subtitle,
-          notify: self.notify
+        appcode: appcode,
+        filename: filename,
+        bundle_identifier: bundle_identifier,
+        bundle_version: bundle_version,
+        title: title,
+        subtitle: subtitle,
+        notify: notify
       }
-      
+
       fputs structure
+    end
   end
-  
-end
 end
-    

data/lib/apprepo/options.rb

@@ -0,0 +1,98 @@
+require 'fastlane_core'
+
+module AppRepo
+  class Options
+    def self.available_options
+      [
+        FastlaneCore::ConfigItem.new(key: :ipa,
+                                     short_option: '-i',
+                                     optional: true,
+                                     env_name: 'APPREPO_IPA_PATH',
+                                     description: 'Path to your ipa file',
+                                     default_value: Dir['*.ipa'].first,
+                                     verify_block: proc do |value|
+                                       UI.user_error!("Could not find ipa file at path '#{value}'") unless File.exist?(value)
+                                       UI.user_error!("'#{value}' doesn't seem to be an ipa file") unless value.end_with?('.ipa')
+                                     end,
+                                     conflicting_options: [:pkg],
+                                     conflict_block: proc do |value|
+                                       UI.user_error!("You can't use 'ipa' and '#{value.key}' options in one run.")
+                                     end),
+        FastlaneCore::ConfigItem.new(key: :app_identifier,
+                                     short_option: '-b',
+                                     optional: false,
+                                     env_name: 'APPREPO_APP_ID',
+                                     description: 'Your bundle identifier',
+                                     default_value: ""),
+        FastlaneCore::ConfigItem.new(key: :app_code,
+                                     short_option: '-c',
+                                     optional: true,
+                                     env_name: 'APPREPO_APPCODE',
+                                     description: 'APPCODE value for apprepo'),
+        FastlaneCore::ConfigItem.new(key: :repo_url,
+                                     short_option: '-r',
+                                     optional: false,
+                                     env_name: 'APPREPO_URL',
+                                     description: 'URL of your Apprepo server'),
+        FastlaneCore::ConfigItem.new(key: :repo_user,
+                                     short_option: '-u',
+                                     optional: false,
+                                     env_name: 'APPREPO_USER',
+                                     description: 'USER of your Apprepo server'),
+        FastlaneCore::ConfigItem.new(key: :repo_key,
+                                     short_option: '-k',
+                                     optional: false,
+                                     env_name: 'APPREPO_KEY',
+                                     description: 'RSA key for your Apprepo server'),
+        FastlaneCore::ConfigItem.new(key: :repo_description,
+                                     short_option: '-d',
+                                     optional: true,
+                                     env_name: 'APPREPO_DESCRIPTION',
+                                     description: 'Long description for your Apprepo server'),
+        FastlaneCore::ConfigItem.new(key: :metadata_path,
+                                     short_option: '-m',
+                                     description: 'Path to the folder containing the metadata files',
+                                     optional: true),
+        FastlaneCore::ConfigItem.new(key: :meta_title,
+                                     short_option: '-a',
+                                     description: 'Name of the app',
+                                     optional: true),
+        FastlaneCore::ConfigItem.new(key: :skip_binary_upload,
+                                     description: 'Skip uploading an ipa or pkg to iTunes Connect',
+                                     is_string: false,
+                                     default_value: false),
+        FastlaneCore::ConfigItem.new(key: :app_version,
+                                     short_option: '-z',
+                                     description: 'The version that should be edited or created',
+                                     optional: true),
+        FastlaneCore::ConfigItem.new(key: :skip_metadata,
+                                     description: "Don't upload the metadata (e.g. title, description), this will still upload screenshots",
+                                     is_string: false,
+                                     default_value: false),
+        FastlaneCore::ConfigItem.new(key: :notify,
+                                     description: "Notify AppRepo users on update",
+                                     is_string: false,
+                                     default_value: false),
+        FastlaneCore::ConfigItem.new(key: :build_number,
+                                     short_option: '-n',
+                                     description: 'If set the given build number (already uploaded to iTC) will be used instead of the current built one',
+                                     optional: true,
+                                     conflicting_options: [:ipa, :pkg],
+                                     conflict_block: proc do |value|
+                                       UI.user_error!("You can't use 'build_number' and '#{value.key}' options in one run.")
+                                     end),
+
+        # App Metadata
+        # Non Localised
+        FastlaneCore::ConfigItem.new(key: :app_icon,
+                                     description: 'Metadata: The path to the app icon',
+                                     optional: true,
+                                     short_option: '-l',
+                                     verify_block: proc do |value|
+                                       UI.user_error!("Could not find png file at path '#{value}'") unless File.exist?(value)
+                                       UI.user_error!("'#{value}' doesn't seem to be a png file") unless value.end_with?('.png')
+                                     end)
+      ]
+    end
+  end
+end

data/lib/apprepo/runner.rb

@@ -0,0 +1,77 @@
+module AppRepo
+  class Runner
+    attr_accessor :options
+
+    def initialize(options)
+      UI.message('[AppRepo:Runner] Initializing...')
+      self.options = options
+      #login
+      AppRepo::DetectValues.new.run!(self.options)
+      #FastlaneCore::PrintTable.print_values(config: options, hide_keys: [:app], mask_keys: ['app_review_information.demo_password'], title: "deliver #{AppRepo::VERSION} Summary")
+    end
+
+    def login
+      #UI.message("Login to AppRepo (#{options[:username]})")
+      #AppRepo::Server.login(options[:username])
+      #AppRepo::Server.select_app
+      #UI.message('Login successful')
+    end
+
+    def run
+      verify_version if options[:app_version].to_s.length > 0
+      upload_metadata
+
+      has_binary = (options[:ipa] || options[:pkg])
+      if !options[:skip_binary_upload] && !options[:build_number] && has_binary
+        upload_binary
+      end
+
+      UI.success('Finished the upload to AppRepo')
+
+      notify if options[:notify]
+    end
+
+    # Make sure the version on AppRepo matches the one in the ipa
+    # If not, the new version will automatically be created
+    def verify_version
+      app_version = options[:app_version]
+      UI.message("TODO: Make sure the latest version on AppRepo matches '#{app_version}' from the ipa file...")
+
+      #changed = options[:app].ensure_version!(app_version)
+      #if changed
+      #  UI.success("Successfully set the version to '#{app_version}'")
+      #else
+      #  UI.success("'#{app_version}' is the latest version on iTunes Connect")
+      #end
+    end
+
+    # Upload all metadata, screenshots, pricing information, etc. to iTunes Connect
+    def upload_metadata
+      #
+    end
+
+    # Upload the binary to iTunes Connect
+    def upload_binary
+      UI.message('Uploading binary to iTunes Connect')
+      if options[:ipa]
+        #package_path = FastlaneCore::IpaUploadPackageBuilder.new.generate(
+        #  app_id: options[:app].apple_id,
+        #  ipa_path: options[:ipa],
+        #  package_path: '/tmp'
+        puts "TODO: Build package path without IpaUploadPackageBuilder"
+        
+      end
+
+      #transporter = FastlaneCore::ItunesTransporter.new(options[:username])
+      #result = transporter.upload(options[:app].apple_id, package_path)
+      #UI.user_error!('Could not upload binary to iTunes Connect. Check out the error above') unless result
+    end
+
+    def notify
+      # should be in metadata
+    end
+
+    private
+
+  end
+end

data/lib/apprepo/setup.rb

@@ -0,0 +1,49 @@
+module AppRepo
+  class Setup
+
+    def setup_apprepo(file_path, data, _apprepo_path, _options)
+      UI.message('[AppRepo:Setup] Setting up...')
+      File.write(file_path, data)
+
+      # TODO: implement later
+      # download_metadata(apprepo_path, options)
+
+      UI.success("NOT! created new Repofile at path '#{file_path}'")
+    end
+
+    # This method takes care of creating a new 'apprepo' folder, containg the app metadata
+    # and screenshots folders
+    def generate_apprepo_file(apprepo_path, options)
+      #
+      #v = options[:app].latest_version
+      #generate_metadata_files(v, File.join(apprepo_path, 'metadata'))
+
+      # Generate the final Repofile here
+      gem_path = Helper.gem_path('apprepo')
+      apprepo = File.read("#{gem_path}/../assets/RepofileDefault")
+      apprepo.gsub!("[[APP_IDENTIFIER]]", options[:app].bundle_id)
+      apprepo.gsub!("[[APPREPO_IPA_PATH]]", options[:app].file_path)
+      apprepo.gsub!("[[APP_VERSION]]", options[:app].version)
+      apprepo.gsub!("[[APP_NAME]]", options[:app].name)
+      UI.user_error("TODO: ADJUST Repofile'")
+      # deliver => apprepo??
+    end
+
+    def download_metadata(apprepo_path, _options)
+      path = File.join(apprepo_path, 'metadata')
+      FileUtils.mkdir_p(path)
+      UI.success("TODO: DOWNLOAD METADATA'")
+      # AppRepo::DownloadManifest.run(options, path)
+    end
+
+    def run(options)
+      UI.message('[AppRepo:Setup] Running...')
+      containing = (File.directory?('fastlane') ? 'fastlane' : '.')
+      file_path = File.join(containing, 'Repofile')
+      data = generate_apprepo_file(containing, options)
+      setup_apprepo(file_path, data, containing, options)
+    end
+  end
+end
+
+# @setup = new AppRepo::Setup

data/lib/apprepo/upload_assets.rb

@@ -0,0 +1,22 @@
+module AppRepo
+  class UploadAssets
+    def upload(options)
+      app = options[:app]
+
+      v = app.edit_version
+      UI.user_error!("Could not find a version to edit for app '#{app.name}'") unless v
+
+      if options[:app_icon]
+         UI.message('Uploading app icon...')
+        v.upload_large_icon!(options[:app_icon])
+      end
+
+      if options[:apple_watch_app_icon]
+        UI.message('Uploading apple watchapp icon...')
+        v.upload_watch_icon!(options[:apple_watch_app_icon])
+      end
+
+      v.save!
+    end
+  end
+end

data/lib/apprepo/upload_descriptor.rb

@@ -1,14 +1,13 @@
 module AppRepo
+  class UploadDescriptor
 
-class UploadDescriptor
+    attr_accessor :appcode # required
+    attr_accessor :ipa # can be inferred anyway (glob or metadata)
+    attr_accessor :metadata # optional, allows re-uploading same binary without metadata change
 
-  attr_accessor :appcode
-
-  def initialize (appcode)
-    self.appcode = appcode
-    puts 'Initializing "AppRepo:UploadDescriptor with appcode "'+self.appcode
+    def initialize(appcode)
+      self.appcode = appcode
+      UI.message('Initializing "AppRepo:UploadDescriptor with appcode "' + self.appcode + '"')
+    end
   end
 end
-
-end
-    

data/lib/apprepo/upload_metadata.rb

@@ -0,0 +1,192 @@
+module AppRepo
+  # upload description, rating, etc.
+  class UploadMetadata
+    # All the localised values attached to the version
+    LOCALISED_VERSION_VALUES = [:description, :keywords, :release_notes, :support_url, :marketing_url].freeze
+
+    # Everything attached to the version but not being localised
+    NON_LOCALISED_VERSION_VALUES = [:copyright].freeze
+
+    # Localised app details values
+    LOCALISED_APP_VALUES = [:name, :privacy_url].freeze
+
+    # Non localized app details values
+    NON_LOCALISED_APP_VALUES = [:primary_category, :secondary_category,
+                                :primary_first_sub_category, :primary_second_sub_category,
+                                :secondary_first_sub_category, :secondary_second_sub_category
+                               ].freeze
+
+    # Make sure to call `load_from_filesystem` before calling upload
+    def upload(options)
+      return if options[:skip_metadata]
+      verify_available_languages!(options)
+
+      app = options[:app]
+
+      details = app.details
+      v = app.edit_version
+
+      (LOCALISED_VERSION_VALUES + LOCALISED_APP_VALUES).each do |key|
+        current = options[key]
+        next unless current
+
+        unless current.is_a?(Hash)
+          UI.error("Error with provided '#{key}'. Must be a hash, the key being the language.")
+          next
+        end
+
+        current.each do |language, value|
+          next unless value.to_s.length > 0
+          strip_value = value.to_s.strip
+          v.send(key)[language] = strip_value if LOCALISED_VERSION_VALUES.include?(key)
+          details.send(key)[language] = strip_value if LOCALISED_APP_VALUES.include?(key)
+        end
+      end
+
+      (NON_LOCALISED_VERSION_VALUES + NON_LOCALISED_APP_VALUES).each do |key|
+        current = options[key].to_s.strip
+        next unless current.to_s.length > 0
+        v.send("#{key}=", current) if NON_LOCALISED_VERSION_VALUES.include?(key)
+        details.send("#{key}=", current) if NON_LOCALISED_APP_VALUES.include?(key)
+      end
+
+      v.release_on_approval = options[:automatic_release]
+
+      set_review_information(v, options)
+      set_app_rating(v, options)
+
+      UI.message('Uploading metadata to iTunes Connect')
+      v.save!
+      details.save!
+      UI.success('Successfully uploaded initial set of metadata to iTunes Connect')
+    end
+
+    # If the user is using the 'default' language, then assign values where they are needed
+    def assign_defaults(options)
+      # Build a complete list of the required languages
+      enabled_languages = []
+
+      # Get all languages used in existing settings
+      (LOCALISED_VERSION_VALUES + LOCALISED_APP_VALUES).each do |key|
+        current = options[key]
+        next unless current && current.is_a?(Hash)
+        current.each do |language, _value|
+          enabled_languages << language unless enabled_languages.include?(language)
+        end
+      end
+
+      # Check folder list (an empty folder signifies a language is required)
+      Dir.glob(File.join(options[:metadata_path], '*')).each do |lng_folder|
+        next unless File.directory?(lng_folder) # We don't want to read txt as they are non localised
+
+        language = File.basename(lng_folder)
+        enabled_languages << language unless enabled_languages.include?(language)
+      end
+
+      return unless enabled_languages.include?('default')
+      UI.message('Detected languages: ' + enabled_languages.to_s)
+
+      (LOCALISED_VERSION_VALUES + LOCALISED_APP_VALUES).each do |key|
+        current = options[key]
+        next unless current && current.is_a?(Hash)
+
+        default = current['default']
+        next if default.nil?
+
+        enabled_languages.each do |language|
+          value = current[language]
+          next unless value.nil?
+
+          current[language] = default
+        end
+        current.delete('default')
+      end
+    end
+
+    # Makes sure all languages we need are actually created
+    def verify_available_languages!(options)
+      return if options[:skip_metadata]
+
+      # Collect all languages we need
+      # We only care about languages from user provided values
+      # as the other languages are on iTC already anyway
+      v = options[:app].edit_version
+      UI.user_error!("Could not find a version to edit for app '#{options[:app].name}', the app metadata is read-only currently") unless v
+
+      enabled_languages = []
+      LOCALISED_VERSION_VALUES.each do |key|
+        current = options[key]
+        next unless current && current.is_a?(Hash)
+        current.each do |language, _value|
+          enabled_languages << language unless enabled_languages.include?(language)
+        end
+      end
+
+      if enabled_languages.count > 0
+        v.create_languages(enabled_languages)
+        lng_text = 'language'
+        lng_text += 's' if enabled_languages.count != 1
+        UI.message("Activating #{lng_text} #{enabled_languages.join(', ')}...")
+        v.save!
+      end
+      true
+    end
+
+    # Loads the metadata files and stores them into the options object
+    def load_from_filesystem(options)
+      return if options[:skip_metadata]
+
+      # Load localised data
+      Loader.language_folders(options[:metadata_path]).each do |lng_folder|
+        language = File.basename(lng_folder)
+        (LOCALISED_VERSION_VALUES + LOCALISED_APP_VALUES).each do |key|
+          path = File.join(lng_folder, "#{key}.txt")
+          next unless File.exist?(path)
+
+          UI.message("Loading '#{path}'...")
+          options[key] ||= {}
+          options[key][language] ||= File.read(path)
+        end
+      end
+
+      # Load non localised data
+      (NON_LOCALISED_VERSION_VALUES + NON_LOCALISED_APP_VALUES).each do |key|
+        path = File.join(options[:metadata_path], "#{key}.txt")
+        next unless File.exist?(path)
+
+        UI.message("Loading '#{path}'...")
+        options[key] ||= File.read(path)
+      end
+    end
+
+    private
+
+    def set_review_information(v, options)
+      return unless options[:app_review_information]
+      info = options[:app_review_information]
+      UI.user_error!('`app_review_information` must be a hash') unless info.is_a?(Hash)
+
+      v.review_first_name = info[:first_name] if info[:first_name]
+      v.review_last_name = info[:last_name] if info[:last_name]
+      v.review_phone_number = info[:phone_number] if info[:phone_number]
+      v.review_email = info[:email_address] if info[:email_address]
+      v.review_demo_user = info[:demo_user] if info[:demo_user]
+      v.review_demo_password = info[:demo_password] if info[:demo_password]
+      v.review_user_needed = (v.review_demo_user.to_s + v.review_demo_password.to_s).length > 0
+      v.review_notes = info[:notes] if info[:notes]
+    end
+
+    def set_app_rating(v, options)
+      return unless options[:app_rating_config_path]
+
+      require 'json'
+      begin
+        json = JSON.parse(File.read(options[:app_rating_config_path]))
+      rescue => ex
+        UI.error(ex.to_s)
+        UI.user_error!("Error parsing JSON file at path '#{options[:app_rating_config_path]}'")
+      end
+      v.update_rating(json)
+    end
+  end
+end