fastlane_pricing_fix 2.212.1

data/fastlane/lib/fastlane/actions/commit_version_bump.rb

@@ -0,0 +1,300 @@
+require 'pathname'
+
+module Fastlane
+  module Actions
+    module SharedValues
+      MODIFIED_FILES = :MODIFIED_FILES
+    end
+
+    class << self
+      # Add an array of paths relative to the repo root or absolute paths that have been modified by
+      # an action.
+      #
+      # :files: An array of paths relative to the repo root or absolute paths
+      def add_modified_files(files)
+        modified_files = lane_context[SharedValues::MODIFIED_FILES] || Set.new
+        modified_files += files
+        lane_context[SharedValues::MODIFIED_FILES] = modified_files
+      end
+    end
+
+    # Commits the current changes in the repo as a version bump, checking to make sure only files which contain version information have been changed.
+    class CommitVersionBumpAction < Action
+      def self.run(params)
+        require 'xcodeproj'
+        require 'set'
+        require 'shellwords'
+
+        xcodeproj_path = params[:xcodeproj] ? File.expand_path(File.join('.', params[:xcodeproj])) : nil
+
+        # find the repo root path
+        repo_path = Actions.sh('git rev-parse --show-toplevel').strip
+        repo_pathname = Pathname.new(repo_path)
+
+        if xcodeproj_path
+          # ensure that the xcodeproj passed in was OK
+          UI.user_error!("Could not find the specified xcodeproj: #{xcodeproj_path}") unless File.directory?(xcodeproj_path)
+        else
+          # find an xcodeproj (ignoring dependencies)
+          xcodeproj_paths = Fastlane::Helper::XcodeprojHelper.find(repo_path)
+
+          # no projects found: error
+          UI.user_error!('Could not find a .xcodeproj in the current repository\'s working directory.') if xcodeproj_paths.count == 0
+
+          # too many projects found: error
+          if xcodeproj_paths.count > 1
+            relative_projects = xcodeproj_paths.map { |e| Pathname.new(e).relative_path_from(repo_pathname).to_s }.join("\n")
+            UI.user_error!("Found multiple .xcodeproj projects in the current repository's working directory. Please specify your app's main project: \n#{relative_projects}")
+          end
+
+          # one project found: great
+          xcodeproj_path = xcodeproj_paths.first
+        end
+
+        # find the pbxproj path, relative to git directory
+        pbxproj_pathname = Pathname.new(File.join(xcodeproj_path, 'project.pbxproj'))
+        pbxproj_path = pbxproj_pathname.relative_path_from(repo_pathname).to_s
+
+        # find the info_plist files
+        project = Xcodeproj::Project.open(xcodeproj_path)
+        info_plist_files = project.objects.select do |object|
+          object.isa == 'XCBuildConfiguration'
+        end.map(&:to_hash).map do |object_hash|
+          object_hash['buildSettings']
+        end.select do |build_settings|
+          build_settings.key?('INFOPLIST_FILE')
+        end.map do |build_settings|
+          build_settings['INFOPLIST_FILE']
+        end.uniq.map do |info_plist_path|
+          Pathname.new(File.expand_path(File.join(xcodeproj_path, '..', info_plist_path))).relative_path_from(repo_pathname).to_s
+        end
+
+        # Removes .plist files that matched the given expression in the 'ignore' parameter
+        ignore_expression = params[:ignore]
+        if ignore_expression
+          info_plist_files.reject! do |info_plist_file|
+            info_plist_file.match(ignore_expression)
+          end
+        end
+
+        extra_files = params[:include]
+        extra_files += modified_files_relative_to_repo_root(repo_path)
+
+        # create our list of files that we expect to have changed, they should all be relative to the project root, which should be equal to the git workdir root
+        expected_changed_files = extra_files
+        expected_changed_files << pbxproj_path
+        expected_changed_files << info_plist_files
+
+        if params[:settings]
+          settings_plists_from_param(params[:settings]).each do |file|
+            settings_file_pathname = Pathname.new(settings_bundle_file_path(project, file))
+            expected_changed_files << settings_file_pathname.relative_path_from(repo_pathname).to_s
+          end
+        end
+
+        expected_changed_files.flatten!.uniq!
+
+        # get the list of files that have actually changed in our git workdir
+        git_dirty_files = Actions.sh('git diff --name-only HEAD').split("\n") + Actions.sh('git ls-files --other --exclude-standard').split("\n")
+
+        # little user hint
+        UI.user_error!("No file changes picked up. Make sure you run the `increment_build_number` action first.") if git_dirty_files.empty?
+
+        # check if the files changed are the ones we expected to change (these should be only the files that have version info in them)
+        changed_files_as_expected = Set.new(git_dirty_files.map(&:downcase)).subset?(Set.new(expected_changed_files.map(&:downcase)))
+        unless changed_files_as_expected
+          unless params[:force]
+            error = [
+              "Found unexpected uncommitted changes in the working directory. Expected these files to have ",
+              "changed: \n#{expected_changed_files.join("\n")}.\nBut found these actual changes: ",
+              "#{git_dirty_files.join("\n")}.\nMake sure you have cleaned up the build artifacts and ",
+              "are only left with the changed version files at this stage in your lane, and don't touch the ",
+              "working directory while your lane is running. You can also use the :force option to bypass this ",
+              "check, and always commit a version bump regardless of the state of the working directory."
+            ].join("\n")
+            UI.user_error!(error)
+          end
+        end
+
+        # get the absolute paths to the files
+        git_add_paths = expected_changed_files.map do |path|
+          updated = path.gsub("$(SRCROOT)", ".").gsub("${SRCROOT}", ".")
+          File.expand_path(File.join(repo_pathname, updated))
+        end
+
+        # then create a commit with a message
+        Actions.sh("git add #{git_add_paths.map(&:shellescape).join(' ')}")
+
+        begin
+          command = build_git_command(params)
+
+          Actions.sh(command)
+
+          UI.success("Committed \"#{params[:message]}\" 💾.")
+        rescue => ex
+          UI.error(ex)
+          UI.important("Didn't commit any changes.")
+        end
+      end
+
+      def self.description
+        "Creates a 'Version Bump' commit. Run after `increment_build_number`"
+      end
+
+      def self.output
+        [
+          ['MODIFIED_FILES', 'The list of paths of modified files']
+        ]
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :message,
+                                       env_name: "FL_COMMIT_BUMP_MESSAGE",
+                                       description: "The commit message when committing the version bump",
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :xcodeproj,
+                                       env_name: "FL_BUILD_NUMBER_PROJECT",
+                                       description: "The path to your project file (Not the workspace). If you have only one, this is optional",
+                                       optional: true,
+                                       verify_block: proc do |value|
+                                         UI.user_error!("Please pass the path to the project, not the workspace") if value.end_with?(".xcworkspace")
+                                         UI.user_error!("Could not find Xcode project") unless File.exist?(value)
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :force,
+                                       env_name: "FL_FORCE_COMMIT",
+                                       description: "Forces the commit, even if other files than the ones containing the version number have been modified",
+                                       type: Boolean,
+                                       optional: true,
+                                       default_value: false),
+          FastlaneCore::ConfigItem.new(key: :settings,
+                                       env_name: "FL_COMMIT_INCLUDE_SETTINGS",
+                                       description: "Include Settings.bundle/Root.plist with version bump",
+                                       skip_type_validation: true, # allows Boolean, String, Array
+                                       optional: true,
+                                       default_value: false),
+          FastlaneCore::ConfigItem.new(key: :ignore,
+                                       description: "A regular expression used to filter matched plist files to be modified",
+                                       skip_type_validation: true, # allows Regex
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :include,
+                                       description: "A list of extra files to be included in the version bump (string array or comma-separated string)",
+                                       optional: true,
+                                       default_value: [],
+                                       type: Array),
+          FastlaneCore::ConfigItem.new(key: :no_verify,
+                                      env_name: "FL_GIT_PUSH_USE_NO_VERIFY",
+                                      description: "Whether or not to use --no-verify",
+                                      type: Boolean,
+                                      default_value: false)
+        ]
+      end
+
+      def self.details
+        list = <<-LIST.markdown_list
+          All `.plist` files
+          The `.xcodeproj/project.pbxproj` file
+        LIST
+
+        [
+          "This action will create a 'Version Bump' commit in your repo. Useful in conjunction with `increment_build_number`.",
+          "It checks the repo to make sure that only the relevant files have changed. These are the files that `increment_build_number` (`agvtool`) touches:".markdown_preserve_newlines,
+          list,
+          "Then commits those files to the repo.",
+          "Customize the message with the `:message` option. It defaults to 'Version Bump'.",
+          "If you have other uncommitted changes in your repo, this action will fail. If you started off in a clean repo, and used the _ipa_ and or _sigh_ actions, then you can use the [clean_build_artifacts](https://docs.fastlane.tools/actions/clean_build_artifacts/) action to clean those temporary files up before running this action."
+        ].join("\n")
+      end
+
+      def self.author
+        "lmirosevic"
+      end
+
+      def self.is_supported?(platform)
+        [:ios, :mac].include?(platform)
+      end
+
+      def self.example_code
+        [
+          'commit_version_bump',
+          'commit_version_bump(
+            message: "Version Bump",                    # create a commit with a custom message
+            xcodeproj: "./path/to/MyProject.xcodeproj"  # optional, if you have multiple Xcode project files, you must specify your main project here
+          )',
+          'commit_version_bump(
+            settings: true # Include Settings.bundle/Root.plist
+          )',
+          'commit_version_bump(
+            settings: "About.plist" # Include Settings.bundle/About.plist
+          )',
+          'commit_version_bump(
+            settings: %w[About.plist Root.plist] # Include more than one plist from Settings.bundle
+          )',
+          'commit_version_bump(
+            include: %w[package.json custom.cfg] # include other updated files as part of the version bump
+          )',
+          'commit_version_bump(
+            ignore: /OtherProject/ # ignore files matching a regular expression
+          )',
+          'commit_version_bump(
+            no_verify: true           # optional, default: false
+          )'
+        ]
+      end
+
+      def self.category
+        :source_control
+      end
+
+      class << self
+        def settings_plists_from_param(param)
+          if param.kind_of?(String)
+            # commit_version_bump settings: "About.plist"
+            return [param]
+          elsif param.kind_of?(Array)
+            # commit_version_bump settings: ["Root.plist", "About.plist"]
+            return param
+          else
+            # commit_version_bump settings: true # Root.plist
+            return ["Root.plist"]
+          end
+        end
+
+        def settings_bundle_file_path(project, settings_file_name)
+          settings_bundle = project.files.find { |f| f.path =~ /Settings.bundle/ }
+          raise "No Settings.bundle in project" if settings_bundle.nil?
+
+          return File.join(settings_bundle.real_path, settings_file_name)
+        end
+
+        def modified_files_relative_to_repo_root(repo_root)
+          return [] if Actions.lane_context[SharedValues::MODIFIED_FILES].nil?
+
+          root_pathname = Pathname.new(repo_root)
+          all_modified_files = Actions.lane_context[SharedValues::MODIFIED_FILES].map do |path|
+            next path unless path =~ %r{^/}
+            Pathname.new(path).relative_path_from(root_pathname).to_s
+          end
+          return all_modified_files.uniq
+        end
+
+        def build_git_command(params)
+          build_number = Actions.lane_context[Actions::SharedValues::BUILD_NUMBER]
+
+          params[:message] ||= (build_number ? "Version Bump to #{build_number}" : "Version Bump")
+
+          command = [
+            'git',
+            'commit',
+            '-m',
+            "'#{params[:message]}'"
+          ]
+
+          command << '--no-verify' if params[:no_verify]
+
+          return command.join(' ')
+        end
+      end
+    end
+  end
+end

data/fastlane/lib/fastlane/actions/copy_artifacts.rb

@@ -0,0 +1,113 @@
+require 'fileutils'
+
+module Fastlane
+  module Actions
+    class CopyArtifactsAction < Action
+      def self.run(params)
+        # expand the path to make sure we can deal with relative paths
+        target_path = File.expand_path(params[:target_path])
+
+        # we want to make sure that our target folder exist already
+        FileUtils.mkdir_p(target_path)
+
+        # Ensure that artifacts is an array
+        artifacts_to_search = [params[:artifacts]].flatten
+
+        # If any of the paths include "*", we assume that we are referring to the Unix entries
+        # e.g /tmp/fastlane/* refers to all the files in /tmp/fastlane
+        # We use Dir.glob to expand all those paths, this would create an array of arrays though, so flatten
+        artifacts = artifacts_to_search.flat_map { |f| f.include?("*") ? Dir.glob(f) : f }
+
+        UI.verbose("Copying artifacts #{artifacts.join(', ')} to #{target_path}")
+        UI.verbose(params[:keep_original] ? "Keeping original files" : "Not keeping original files")
+
+        if params[:fail_on_missing]
+          missing = artifacts.reject { |a| File.exist?(a) }
+          UI.user_error!("Not all files were present in copy artifacts. Missing #{missing.join(', ')}") unless missing.empty?
+        else
+          # If we don't fail on non-existent files, don't try to copy non-existent files
+          artifacts.select! { |artifact| File.exist?(artifact) }
+        end
+
+        if params[:keep_original]
+          FileUtils.cp_r(artifacts, target_path, remove_destination: true)
+        else
+          FileUtils.mv(artifacts, target_path, force: true)
+        end
+
+        UI.success('Build artifacts successfully copied!')
+      end
+
+      #####################################################
+      # @!group Documentation
+      #####################################################
+
+      def self.description
+        "Copy and save your build artifacts (useful when you use reset_git_repo)"
+      end
+
+      def self.details
+        [
+          "This action copies artifacts to a target directory. It's useful if you have a CI that will pick up these artifacts and attach them to the build. Useful e.g. for storing your `.ipa`s, `.dSYM.zip`s, `.mobileprovision`s, `.cert`s.",
+          "Make sure your `:target_path` is ignored from git, and if you use `reset_git_repo`, make sure the artifacts are added to the exclude list."
+        ].join("\n")
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :keep_original,
+                                       description: "Set this to false if you want move, rather than copy, the found artifacts",
+                                       type: Boolean,
+                                       optional: true,
+                                       default_value: true),
+          FastlaneCore::ConfigItem.new(key: :target_path,
+                                       description: "The directory in which you want your artifacts placed",
+                                       optional: false,
+                                       default_value: 'artifacts'),
+          FastlaneCore::ConfigItem.new(key: :artifacts,
+                                       description: "An array of file patterns of the files/folders you want to preserve",
+                                       type: Array,
+                                       optional: false,
+                                       default_value: []),
+          FastlaneCore::ConfigItem.new(key: :fail_on_missing,
+                                       description: "Fail when a source file isn't found",
+                                       type: Boolean,
+                                       optional: true,
+                                       default_value: false)
+        ]
+      end
+
+      def self.authors
+        ["lmirosevic"]
+      end
+
+      def self.is_supported?(platform)
+        true
+      end
+
+      def self.example_code
+        [
+          'copy_artifacts(
+            target_path: "artifacts",
+            artifacts: ["*.cer", "*.mobileprovision", "*.ipa", "*.dSYM.zip", "path/to/file.txt", "another/path/*.extension"]
+          )
+
+          # Reset the git repo to a clean state, but leave our artifacts in place
+          reset_git_repo(
+            exclude: "artifacts"
+          )',
+          '# Copy the .ipa created by _gym_ if it was successfully created
+          artifacts = []
+          artifacts << lane_context[SharedValues::IPA_OUTPUT_PATH] if lane_context[SharedValues::IPA_OUTPUT_PATH]
+          copy_artifacts(
+             artifacts: artifacts
+          )'
+        ]
+      end
+
+      def self.category
+        :misc
+      end
+    end
+  end
+end

data/fastlane/lib/fastlane/actions/create_app_on_managed_play_store.rb

@@ -0,0 +1,168 @@
+require 'google/apis/playcustomapp_v1'
+require 'supply'
+
+module Fastlane
+  module Actions
+    class CreateAppOnManagedPlayStoreAction < Action
+      def self.run(params)
+        client = PlaycustomappClient.make_from_config(params: params)
+
+        FastlaneCore::PrintTable.print_values(
+          config: params,
+          mask_keys: [:json_key_data],
+          title: "Summary for create_app_on_managed_play_store"
+        )
+
+        client.create_app(
+          app_title: params[:app_title],
+          language_code: params[:language],
+          developer_account: params[:developer_account_id],
+          apk_path: params[:apk]
+        )
+      end
+
+      def self.description
+        "Create Managed Google Play Apps"
+      end
+
+      def self.authors
+        ["janpio"]
+      end
+
+      def self.return_value
+        # If your method provides a return value, you can describe here what it does
+      end
+
+      def self.details
+        "Create new apps on Managed Google Play."
+      end
+
+      def self.example_code
+        [
+          "create_app_on_managed_play_store(
+            json_key: 'path/to/you/json/key/file',
+            developer_account_id: 'developer_account_id', # obtained using the `get_managed_play_store_publishing_rights` action (or looking at the Play Console url)
+            app_title: 'Your app title',
+            language: 'en_US', # primary app language in BCP 47 format
+            apk: '/files/app-release.apk'
+          )"
+        ]
+      end
+
+      def self.available_options
+        [
+          # Authorization
+          FastlaneCore::ConfigItem.new(key: :json_key,
+                                       env_name: "SUPPLY_JSON_KEY",
+                                       short_option: "-j",
+                                       conflicting_options: [:json_key_data],
+                                       optional: true, # optional until it is possible specify either json_key OR json_key_data are required
+                                       description: "The path to a file containing service account JSON, used to authenticate with Google",
+                                       code_gen_sensitive: true,
+                                       default_value: CredentialsManager::AppfileConfig.try_fetch_value(:json_key_file),
+                                       default_value_dynamic: true,
+                                       verify_block: proc do |value|
+                                         UI.user_error!("Could not find service account json file at path '#{File.expand_path(value)}'") unless File.exist?(File.expand_path(value))
+                                         UI.user_error!("'#{value}' doesn't seem to be a JSON file") unless FastlaneCore::Helper.json_file?(File.expand_path(value))
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :json_key_data,
+                                       env_name: "SUPPLY_JSON_KEY_DATA",
+                                       short_option: "-c",
+                                       conflicting_options: [:json_key],
+                                       optional: true,
+                                       description: "The raw service account JSON data used to authenticate with Google",
+                                       code_gen_sensitive: true,
+                                       default_value: CredentialsManager::AppfileConfig.try_fetch_value(:json_key_data_raw),
+                                       default_value_dynamic: true,
+                                       verify_block: proc do |value|
+                                         begin
+                                           JSON.parse(value)
+                                         rescue JSON::ParserError
+                                           UI.user_error!("Could not parse service account json: JSON::ParseError")
+                                         end
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :developer_account_id,
+                                       short_option: "-k",
+                                       env_name: "SUPPLY_DEVELOPER_ACCOUNT_ID",
+                                       description: "The ID of your Google Play Console account. Can be obtained from the URL when you log in (`https://play.google.com/apps/publish/?account=...` or when you 'Obtain private app publishing rights' (https://developers.google.com/android/work/play/custom-app-api/get-started#retrieve_the_developer_account_id)",
+                                       code_gen_sensitive: true,
+                                       default_value: CredentialsManager::AppfileConfig.try_fetch_value(:developer_account_id),
+                                       default_value_dynamic: true),
+          # APK
+          FastlaneCore::ConfigItem.new(key: :apk,
+                                       env_name: "SUPPLY_APK",
+                                       description: "Path to the APK file to upload",
+                                       short_option: "-b",
+                                       code_gen_sensitive: true,
+                                       default_value: Dir["*.apk"].last || Dir[File.join("app", "build", "outputs", "apk", "app-release.apk")].last,
+                                       default_value_dynamic: true,
+                                       verify_block: proc do |value|
+                                         UI.user_error!("No value found for 'apk'") if value.to_s.length == 0
+                                         UI.user_error!("Could not find apk file at path '#{value}'") unless File.exist?(value)
+                                         UI.user_error!("apk file is not an apk") unless value.end_with?('.apk')
+                                       end),
+          # Title
+          FastlaneCore::ConfigItem.new(key: :app_title,
+                                       env_name: "SUPPLY_APP_TITLE",
+                                       short_option: "-q",
+                                       description: "App Title"),
+          # Language
+          FastlaneCore::ConfigItem.new(key: :language,
+                                       short_option: "-m",
+                                       env_name: "SUPPLY_LANGUAGE",
+                                       description: "Default app language (e.g. 'en_US')",
+                                       default_value: "en_US",
+                                       verify_block: proc do |language|
+                                         unless Supply::Languages::ALL_LANGUAGES.include?(language)
+                                           UI.user_error!("Please enter one of the available languages: #{Supply::Languages::ALL_LANGUAGES}")
+                                         end
+                                       end),
+          # Google Play API
+          FastlaneCore::ConfigItem.new(key: :root_url,
+                                       env_name: "SUPPLY_ROOT_URL",
+                                       description: "Root URL for the Google Play API. The provided URL will be used for API calls in place of https://www.googleapis.com/",
+                                       optional: true,
+                                       verify_block: proc do |value|
+                                         UI.user_error!("Could not parse URL '#{value}'") unless value =~ URI.regexp
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :timeout,
+                                       env_name: "SUPPLY_TIMEOUT",
+                                       optional: true,
+                                       description: "Timeout for read, open, and send (in seconds)",
+                                       type: Integer,
+                                       default_value: 300)
+        ]
+      end
+
+      def self.is_supported?(platform)
+        [:android].include?(platform)
+      end
+
+      def self.category
+        :misc
+      end
+    end
+  end
+end
+
+require 'supply/client'
+class PlaycustomappClient < Supply::AbstractGoogleServiceClient
+  SERVICE = Google::Apis::PlaycustomappV1::PlaycustomappService
+  SCOPE = Google::Apis::PlaycustomappV1::AUTH_ANDROIDPUBLISHER
+
+  #####################################################
+  # @!group Create
+  #####################################################
+
+  def create_app(app_title: nil, language_code: nil, developer_account: nil, apk_path: nil)
+    custom_app = Google::Apis::PlaycustomappV1::CustomApp.new(title: app_title, language_code: language_code)
+
+    call_google_api do
+      client.create_account_custom_app(
+        developer_account,
+        custom_app,
+        upload_source: apk_path
+      )
+    end
+  end
+end

data/fastlane/lib/fastlane/actions/create_app_online.rb

@@ -0,0 +1,75 @@
+module Fastlane
+  module Actions
+    module SharedValues
+      PRODUCE_APPLE_ID = :PRODUCE_APPLE_ID
+    end
+
+    class CreateAppOnlineAction < Action
+      def self.run(params)
+        require 'produce'
+
+        return if Helper.test?
+
+        Produce.config = params # we alread have the finished config
+
+        Dir.chdir(FastlaneCore::FastlaneFolder.path || Dir.pwd) do
+          # This should be executed in the fastlane folder
+          apple_id = Produce::Manager.start_producing.to_s
+
+          Actions.lane_context[SharedValues::PRODUCE_APPLE_ID] = apple_id
+          ENV['PRODUCE_APPLE_ID'] = apple_id
+        end
+      end
+
+      def self.description
+        "Creates the given application on iTC and the Dev Portal (via _produce_)"
+      end
+
+      def self.details
+        [
+          "Create new apps on App Store Connect and Apple Developer Portal via _produce_.",
+          "If the app already exists, `create_app_online` will not do anything.",
+          "For more information about _produce_, visit its documentation page: [https://docs.fastlane.tools/actions/produce/](https://docs.fastlane.tools/actions/produce/)."
+        ].join("\n")
+      end
+
+      def self.available_options
+        require 'produce'
+        Produce::Options.available_options
+      end
+
+      def self.output
+        [
+          ['PRODUCE_APPLE_ID', 'The Apple ID of the newly created app. You probably need it for `deliver`']
+        ]
+      end
+
+      def self.author
+        "KrauseFx"
+      end
+
+      def self.is_supported?(platform)
+        platform == :ios
+      end
+
+      def self.example_code
+        [
+          'create_app_online(
+            username: "felix@krausefx.com",
+            app_identifier: "com.krausefx.app",
+            app_name: "MyApp",
+            language: "English",
+            app_version: "1.0",
+            sku: "123",
+            team_name: "SunApps GmbH" # Only necessary when in multiple teams.
+          )',
+          'produce   # alias for "create_app_online"'
+        ]
+      end
+
+      def self.category
+        :app_store_connect
+      end
+    end
+  end
+end