fastlane_pricing_fix 2.212.1

data/produce/lib/produce/itunes_connect.rb

@@ -0,0 +1,139 @@
+require 'spaceship'
+require 'spaceship/tunes/tunes'
+require 'fastlane_core/languages'
+require_relative 'module'
+
+module Produce
+  class ItunesConnect
+    def run
+      @full_bundle_identifier = app_identifier
+      @full_bundle_identifier.gsub!('*', Produce.config[:bundle_identifier_suffix].to_s) if wildcard_bundle?
+
+      # Team selection passed though FASTLANE_ITC_TEAM_ID and FASTLANE_ITC_TEAM_NAME environment variables
+      # Prompts select team if multiple teams and none specified
+      Spaceship::ConnectAPI.login(Produce.config[:username], nil, use_portal: false, use_tunes: true)
+
+      create_new_app
+    end
+
+    def create_new_app
+      application = fetch_application
+      if application
+        UI.success("App '#{Produce.config[:app_identifier]}' already exists (#{application.id}), nothing to do on App Store Connect")
+        # Nothing to do here
+      else
+        emails = Produce.config[:itc_users] || []
+        user_ids = []
+        unless emails.empty?
+          UI.message("Verifying users exist before creating app...")
+          user_ids = find_user_ids(emails: emails)
+        end
+
+        UI.success("Creating new app '#{Produce.config[:app_name]}' on App Store Connect")
+
+        platforms = Produce.config[:platforms] || [Produce.config[:platform]]
+
+        platforms = platforms.map do |platform|
+          Spaceship::ConnectAPI::Platform.map(platform)
+        end
+
+        # Produce.config[:itc_users]
+        application = Spaceship::ConnectAPI::App.create(
+          name: Produce.config[:app_name],
+          version_string: Produce.config[:app_version] || "1.0",
+          sku: Produce.config[:sku].to_s,
+          primary_locale: language,
+          bundle_id: app_identifier,
+          platforms: platforms,
+          company_name: Produce.config[:company_name]
+        )
+
+        application = fetch_application
+        counter = 0
+        while application.nil?
+          counter += 1
+          UI.crash!("Couldn't find newly created app on App Store Connect - please check the website for more information") if counter == 200
+
+          # Since 2016-08-10 App Store Connect takes some time to actually list the newly created application
+          # We have no choice but to poll to see if the newly created app is already available
+          UI.message("Waiting for the newly created application to be available on App Store Connect...")
+          sleep(15)
+          application = fetch_application
+        end
+
+        UI.crash!("Something went wrong when creating the new app - it's not listed in the App's list") unless application
+
+        UI.message("Ensuring version number")
+        platforms.each do |platform|
+          application.ensure_version!(Produce.config[:app_version], platform: platform) if Produce.config[:app_version]
+        end
+
+        # Add users to app
+        unless user_ids.empty?
+          application.add_users(user_ids: user_ids)
+          UI.message("Successfuly added #{user_ids.size} #{user_ids.count == 1 ? 'user' : 'users'} to app")
+        end
+
+        UI.success("Successfully created new app '#{Produce.config[:app_name]}' on App Store Connect with ID #{application.id}")
+      end
+
+      return application.id
+    end
+
+    def find_user_ids(emails: nil)
+      emails ||= []
+      users = Spaceship::ConnectAPI::User.all.select do |user|
+        emails.include?(user.email)
+      end
+
+      diff_emails = emails - users.map(&:email)
+      unless diff_emails.empty?
+        raise "Could not find users with emails of: #{diff_emails.join(',')}"
+      end
+
+      return users.map(&:id)
+    end
+
+    private
+
+    def platform
+      (Produce.config[:platforms] || []).first || Produce.config[:platform]
+    end
+
+    def fetch_application
+      Spaceship::ConnectAPI::App.find(@full_bundle_identifier)
+    end
+
+    def wildcard_bundle?
+      return app_identifier.end_with?("*")
+    end
+
+    def app_identifier
+      Produce.config[:app_identifier].to_s
+    end
+
+    # Makes sure to get the value for the language
+    # Instead of using the user's value `UK English` spaceship should send `en-UK`
+    def language
+      @language = Produce.config[:language]
+
+      unless FastlaneCore::Languages::ALL_LANGUAGES.include?(@language)
+        mapped_language = Spaceship::Tunes::LanguageConverter.from_standard_to_itc_locale(@language)
+        if mapped_language.to_s.empty?
+          message = [
+            "Sending language name is deprecated. Could not map '#{@language}' to a locale.",
+            "Please enter one of available languages: #{FastlaneCore::Languages::ALL_LANGUAGES}"
+          ].join("\n")
+          UI.user_error!(message)
+        end
+
+        UI.deprecated("Sending language name is deprecated. '#{@language}' has been mapped to '#{mapped_language}'.")
+        UI.deprecated("Please enter one of available languages: #{FastlaneCore::Languages::ALL_LANGUAGES}")
+
+        @language = mapped_language
+      end
+
+      return @language
+    end
+  end
+end

data/produce/lib/produce/manager.rb

@@ -0,0 +1,15 @@
+require 'fastlane_core/print_table'
+require_relative 'developer_center'
+require_relative 'itunes_connect'
+
+module Produce
+  class Manager
+    # Produces app at DeveloperCenter and ItunesConnect
+    def self.start_producing
+      FastlaneCore::PrintTable.print_values(config: Produce.config, hide_keys: [], title: "Summary for produce #{Fastlane::VERSION}")
+
+      Produce::DeveloperCenter.new.run unless Produce.config[:skip_devcenter]
+      return Produce::ItunesConnect.new.run unless Produce.config[:skip_itc]
+    end
+  end
+end

data/produce/lib/produce/merchant.rb

@@ -0,0 +1,121 @@
+require 'spaceship'
+require_relative 'module'
+
+module Produce
+  class Merchant
+    def create(_options, _args)
+      login
+
+      merchant_identifier = detect_merchant_identifier
+      merchant = find_merchant(merchant_identifier)
+
+      if merchant
+        UI.success("[DevCenter] Merchant '#{merchant.bundle_id})' already exists, nothing to do on the Dev Center")
+      else
+        merchant_name = Produce.config[:merchant_name] || merchant_name_from_identifier(merchant_identifier)
+        UI.success("Creating new merchant '#{merchant_name}' with identifier '#{merchant_identifier}' on the Apple Dev Center")
+        merchant = Spaceship.merchant.create!(bundle_id: merchant_identifier, name: merchant_name, mac: self.class.mac?)
+
+        if merchant.name != merchant_name
+          UI.important("Your merchant name might include non-ASCII characters, which are not supported by the Apple Developer Portal.")
+          UI.important("To fix this a unique (internal) name '#{merchant.name}' has been created for you.")
+        end
+
+        UI.message("Created merchant #{merchant.merchant_id}")
+        UI.success("Finished creating new merchant '#{merchant_name}' on the Dev Center")
+      end
+    end
+
+    def associate(_options, args)
+      login
+
+      app = Spaceship.app.find(app_identifier)
+
+      if app
+        app.update_service(Spaceship.app_service.apple_pay.on)
+
+        UI.message("Validating merchants before association")
+
+        # associate requires identifiers to exist. This splits the provided identifiers into existing/non-existing. See: https://ruby-doc.org/core/Enumerable.html#method-i-partition
+        valid_identifiers, errored_identifiers = args.partition { |identifier| merchant_exists?(identifier) }
+        new_merchants = valid_identifiers.map { |identifier| find_merchant(identifier) }
+
+        errored_identifiers.each do |merchant_identifier|
+          UI.message("[DevCenter] Merchant '#{merchant_identifier}' does not exist, please create it first, skipping for now")
+        end
+
+        UI.message("Finalising association with #{new_merchants.count} #{pluralize('merchant', new_merchants)}")
+        app.associate_merchants(new_merchants)
+        UI.success("Done!")
+      else
+        UI.message("[DevCenter] App '#{Produce.config[:app_identifier]}' does not exist, nothing to associate with the merchants")
+      end
+    end
+
+    def login
+      UI.message("Starting login with user '#{Produce.config[:username]}'")
+      Spaceship.login(Produce.config[:username], nil)
+      Spaceship.select_team
+      UI.message("Successfully logged in")
+    end
+
+    def app_identifier
+      Produce.config[:app_identifier]
+    end
+
+    def pluralize(singular, arr)
+      return singular if arr.count == 1
+
+      "#{singular}s"
+    end
+
+    def merchant_exists?(identifier)
+      find_merchant(identifier)
+    end
+
+    def detect_merchant_identifier
+      self.class.detect_merchant_identifier
+    end
+
+    def self.detect_merchant_identifier(config = Produce.config)
+      identifier = config[:merchant_identifier] || input("Merchant identifier (reverse-domain name style string starting with 'merchant'): ", ":merchant_identifier option is required")
+      prepare_identifier(identifier)
+    end
+
+    def self.input(message, error_message)
+      if UI.interactive?
+        UI.input(message)
+      else
+        UI.user_error!(error_message)
+      end
+    end
+
+    def self.prepare_identifier(identifier)
+      return identifier if identifier.start_with?("merchant.")
+
+      "merchant.#{identifier}"
+    end
+
+    def find_merchant(identifier)
+      self.class.find_merchant(identifier)
+    end
+
+    def self.find_merchant(identifier, merchant: Spaceship.merchant)
+      @cache ||= {}
+      @cache[identifier] ||= merchant.find(identifier, mac: mac?)
+    end
+
+    def self.mac?(config = Produce.config)
+      config[:platform].to_s == "mac"
+    end
+
+    def merchant_name_from_identifier(identifier)
+      self.class.merchant_name_from_identifier(identifier)
+    end
+
+    def self.merchant_name_from_identifier(identifier)
+      capitalized_words = identifier.split(".").map(&:capitalize)
+      capitalized_words.reverse.join(' ')
+    end
+  end
+end

data/produce/lib/produce/module.rb

@@ -0,0 +1,14 @@
+require 'fastlane_core/helper'
+
+module Produce
+  class << self
+    attr_accessor :config
+  end
+
+  Helper = FastlaneCore::Helper # you gotta love Ruby: Helper.* should use the Helper class contained in FastlaneCore
+  UI = FastlaneCore::UI
+  ROOT = Pathname.new(File.expand_path('../../..', __FILE__))
+
+  ENV['FASTLANE_TEAM_ID'] ||= ENV["PRODUCE_TEAM_ID"]
+  ENV['DELIVER_USER'] ||= ENV["PRODUCE_USERNAME"]
+end

data/produce/lib/produce/options.rb

@@ -0,0 +1,184 @@
+require 'fastlane_core/configuration/config_item'
+require 'credentials_manager/appfile_config'
+require_relative 'module'
+require_relative 'developer_center'
+
+module Produce
+  class Options
+    def self.available_options
+      user = CredentialsManager::AppfileConfig.try_fetch_value(:apple_dev_portal_id)
+      user ||= CredentialsManager::AppfileConfig.try_fetch_value(:apple_id)
+
+      [
+        FastlaneCore::ConfigItem.new(key: :username,
+                                     short_option: "-u",
+                                     env_name: "PRODUCE_USERNAME",
+                                     description: "Your Apple ID Username",
+                                     code_gen_sensitive: true,
+                                     default_value: user,
+                                     default_value_dynamic: true),
+        FastlaneCore::ConfigItem.new(key: :app_identifier,
+                                     env_name: "PRODUCE_APP_IDENTIFIER",
+                                     short_option: "-a",
+                                     description: "App Identifier (Bundle ID, e.g. com.krausefx.app)",
+                                     code_gen_sensitive: true,
+                                     default_value: CredentialsManager::AppfileConfig.try_fetch_value(:app_identifier),
+                                     default_value_dynamic: true),
+        FastlaneCore::ConfigItem.new(key: :bundle_identifier_suffix,
+                                     short_option: "-e",
+                                     env_name: "PRODUCE_APP_IDENTIFIER_SUFFIX",
+                                     optional: true,
+                                     description: "App Identifier Suffix (Ignored if App Identifier does not end with .*)"),
+        FastlaneCore::ConfigItem.new(key: :app_name,
+                                     env_name: "PRODUCE_APP_NAME",
+                                     short_option: "-q",
+                                     description: "App Name"),
+        FastlaneCore::ConfigItem.new(key: :app_version,
+                                     short_option: "-z",
+                                     optional: true,
+                                     env_name: "PRODUCE_VERSION",
+                                     description: "Initial version number (e.g. '1.0')"),
+        FastlaneCore::ConfigItem.new(key: :sku,
+                                     env_name: "PRODUCE_SKU",
+                                     short_option: "-y",
+                                     description: "SKU Number (e.g. '1234')",
+                                     code_gen_sensitive: true,
+                                     default_value: Time.now.to_i.to_s,
+                                     default_value_dynamic: true,
+                                     is_string: true),
+        FastlaneCore::ConfigItem.new(key: :platform,
+                                     short_option: "-j",
+                                     env_name: "PRODUCE_PLATFORM",
+                                     description: "The platform to use (optional)",
+                                     conflicting_options: [:platforms],
+                                     optional: true,
+                                     default_value: "ios",
+                                     verify_block: proc do |value|
+                                                     UI.user_error!("The platform can only be ios or osx") unless %('ios', 'osx', 'tvos').include?(value)
+                                                   end),
+        FastlaneCore::ConfigItem.new(key: :platforms,
+                                     short_option: "-J",
+                                     env_name: "PRODUCE_PLATFORMS",
+                                     description: "The platforms to use (optional)",
+                                     conflicting_options: [:platform],
+                                     optional: true,
+                                     type: Array,
+                                     verify_block: proc do |values|
+                                                     types = %w(ios osx tvos)
+                                                     UI.user_error!("The platform can only be #{types}") unless (values - types).empty?
+                                                   end),
+        FastlaneCore::ConfigItem.new(key: :language,
+                                     short_option: "-m",
+                                     env_name: "PRODUCE_LANGUAGE",
+                                     description: "Primary Language (e.g. 'en-US', 'fr-FR')",
+                                     default_value: "English",
+                                     verify_block: proc do |language|
+                                     end),
+        FastlaneCore::ConfigItem.new(key: :company_name,
+                                     short_option: "-c",
+                                     env_name: "PRODUCE_COMPANY_NAME",
+                                     description: "The name of your company. It's used to set company name on App Store Connect team's app pages. Only required if it's the first app you create",
+                                     optional: true),
+        FastlaneCore::ConfigItem.new(key: :skip_itc,
+                                     short_option: "-i",
+                                     env_name: "PRODUCE_SKIP_ITC",
+                                     description: "Skip the creation of the app on App Store Connect",
+                                     is_string: false,
+                                     default_value: false),
+        FastlaneCore::ConfigItem.new(key: :itc_users,
+                                     short_option: "-s",
+                                     env_name: "ITC_USERS",
+                                     optional: true,
+                                     type: Array,
+                                     description: "Array of App Store Connect users. If provided, you can limit access to this newly created app for users with the App Manager, Developer, Marketer or Sales roles",
+                                     is_string: false),
+        # Deprecating this in favor of a rename from "enabled_features" to "enable_services"
+        FastlaneCore::ConfigItem.new(key: :enabled_features,
+                                     deprecated: "Please use `enable_services` instead",
+                                     display_in_shell: false,
+                                     env_name: "PRODUCE_ENABLED_FEATURES",
+                                     description: "Array with Spaceship App Services",
+                                     is_string: false,
+                                     default_value: {},
+                                     verify_block: proc do |value|
+                                                     allowed_keys = Produce::DeveloperCenter::ALLOWED_SERVICES.keys
+                                                     UI.user_error!("enabled_features has to be of type Hash") unless value.kind_of?(Hash)
+                                                     value.each do |key, v|
+                                                       UI.user_error!("The key: '#{key}' is not supported in `enabled_features' - following keys are available: [#{allowed_keys.join(',')}]") unless allowed_keys.include?(key.to_sym)
+                                                     end
+                                                   end),
+        FastlaneCore::ConfigItem.new(key: :enable_services,
+                                     display_in_shell: false,
+                                     env_name: "PRODUCE_ENABLE_SERVICES",
+                                     description: "Array with Spaceship App Services (e.g. #{allowed_services_description})",
+                                     is_string: false,
+                                     default_value: {},
+                                     verify_block: proc do |value|
+                                                     allowed_keys = Produce::DeveloperCenter::ALLOWED_SERVICES.keys
+                                                     UI.user_error!("enable_services has to be of type Hash") unless value.kind_of?(Hash)
+                                                     value.each do |key, v|
+                                                       UI.user_error!("The key: '#{key}' is not supported in `enable_services' - following keys are available: [#{allowed_keys.join(',')}]") unless allowed_keys.include?(key.to_sym)
+                                                     end
+                                                   end),
+
+        FastlaneCore::ConfigItem.new(key: :skip_devcenter,
+                                     short_option: "-d",
+                                     env_name: "PRODUCE_SKIP_DEVCENTER",
+                                     description: "Skip the creation of the app on the Apple Developer Portal",
+                                     is_string: false,
+                                     default_value: false),
+        FastlaneCore::ConfigItem.new(key: :team_id,
+                                     short_option: "-b",
+                                     env_name: "PRODUCE_TEAM_ID",
+                                     description: "The ID of your Developer Portal team if you're in multiple teams",
+                                     optional: true,
+                                     code_gen_sensitive: true,
+                                     default_value: CredentialsManager::AppfileConfig.try_fetch_value(:team_id),
+                                     default_value_dynamic: true,
+                                     verify_block: proc do |value|
+                                       ENV["FASTLANE_TEAM_ID"] = value.to_s
+                                     end),
+        FastlaneCore::ConfigItem.new(key: :team_name,
+                                     short_option: "-l",
+                                     env_name: "PRODUCE_TEAM_NAME",
+                                     description: "The name of your Developer Portal team if you're in multiple teams",
+                                     optional: true,
+                                     code_gen_sensitive: true,
+                                     default_value: CredentialsManager::AppfileConfig.try_fetch_value(:team_name),
+                                     default_value_dynamic: true,
+                                     verify_block: proc do |value|
+                                       ENV["FASTLANE_TEAM_NAME"] = value.to_s
+                                     end),
+        FastlaneCore::ConfigItem.new(key: :itc_team_id,
+                                     short_option: "-k",
+                                     env_name: "PRODUCE_ITC_TEAM_ID",
+                                     description: "The ID of your App Store Connect team if you're in multiple teams",
+                                     optional: true,
+                                     is_string: false, # as we also allow integers, which we convert to strings anyway
+                                     code_gen_sensitive: true,
+                                     default_value: CredentialsManager::AppfileConfig.try_fetch_value(:itc_team_id),
+                                     default_value_dynamic: true,
+                                     verify_block: proc do |value|
+                                       ENV["FASTLANE_ITC_TEAM_ID"] = value.to_s
+                                     end),
+        FastlaneCore::ConfigItem.new(key: :itc_team_name,
+                                     short_option: "-p",
+                                     env_name: "PRODUCE_ITC_TEAM_NAME",
+                                     description: "The name of your App Store Connect team if you're in multiple teams",
+                                     optional: true,
+                                     code_gen_sensitive: true,
+                                     default_value: CredentialsManager::AppfileConfig.try_fetch_value(:itc_team_name),
+                                     default_value_dynamic: true,
+                                     verify_block: proc do |value|
+                                       ENV["FASTLANE_ITC_TEAM_NAME"] = value.to_s
+                                     end)
+      ]
+    end
+
+    def self.allowed_services_description
+      return Produce::DeveloperCenter::ALLOWED_SERVICES.map do |k, v|
+        "#{k}: (#{v.join('|')})"
+      end.join(", ")
+    end
+  end
+end