fastlane_iac_publish 0.1.0

data/pilot/lib/pilot/tester_exporter.rb

@@ -0,0 +1,58 @@
+require 'spaceship/tunes/application'
+require_relative 'tester_util'
+require_relative 'module'
+require_relative 'manager'
+
+module Pilot
+  class TesterExporter < Manager
+    def export_testers(options)
+      UI.user_error!("Export file path is required") unless options[:testers_file_path]
+
+      start(options)
+      require 'csv'
+
+      app = find_app(apple_id: options[:apple_id], app_identifier: options[:app_identifier])
+      if app
+        testers = app.get_beta_testers(includes: "apps,betaTesterMetrics,betaGroups")
+      else
+        testers = Spaceship::ConnectAPI::BetaTester.all(includes: "apps,betaTesterMetrics,betaGroups")
+      end
+
+      file = config[:testers_file_path]
+
+      CSV.open(file, "w") do |csv|
+        csv << ['First', 'Last', 'Email', 'Groups', 'Installed Version', 'Install Date']
+
+        testers.each do |tester|
+          group_names = tester.beta_groups.map(&:name).join(";") || ""
+
+          metric = (tester.beta_tester_metrics || []).first
+          if metric.installed?
+            install_version = "#{metric.installed_cf_bundle_short_version_string} (#{metric.installed_cf_bundle_version})"
+            pretty_date = metric.installed_cf_bundle_version
+          end
+
+          csv << [tester.first_name, tester.last_name, tester.email, group_names, install_version, pretty_date]
+        end
+
+        UI.success("Successfully exported CSV to #{file}")
+      end
+    end
+
+    def find_app(apple_id: nil, app_identifier: nil)
+      if app_identifier
+        app = Spaceship::ConnectAPI::App.find(app_identifier)
+        UI.user_error!("Could not find an app by #{app_identifier}") unless app
+        return app
+      end
+
+      if apple_id
+        app = Spaceship::ConnectAPI::App.get(app_id: apple_id)
+        UI.user_error!("Could not find an app by #{apple_id}") unless app
+        return app
+      end
+
+      UI.user_error!("You must include an `app_identifier` to `list_testers`")
+    end
+  end
+end

data/pilot/lib/pilot/tester_importer.rb

@@ -0,0 +1,53 @@
+require_relative 'module'
+require_relative 'manager'
+require_relative 'tester_manager'
+
+module Pilot
+  class TesterImporter < Manager
+    def import_testers(options)
+      UI.user_error!("Import file path is required") unless options[:testers_file_path]
+
+      start(options)
+
+      require 'csv'
+
+      file = config[:testers_file_path]
+      tester_manager = Pilot::TesterManager.new
+      imported_tester_count = 0
+
+      groups = options[:groups]
+
+      CSV.foreach(file, "r") do |row|
+        first_name, last_name, email, testing_groups = row
+
+        unless email
+          UI.error("No email found in row: #{row}")
+          next
+        end
+
+        unless email.index("@")
+          UI.error("No email found in row: #{row}")
+          next
+        end
+
+        # Add this the existing config hash to pass it to the TesterManager
+        config[:first_name] = first_name
+        config[:last_name] = last_name
+        config[:email] = email
+        config[:groups] = groups
+        if testing_groups
+          config[:groups] = testing_groups.split(";")
+        end
+
+        begin
+          tester_manager.add_tester(config)
+          imported_tester_count += 1
+        rescue => exception
+          UI.error("Error adding tester #{email}: #{exception}")
+        end
+      end
+
+      UI.success("Successfully imported #{imported_tester_count} testers from #{file}")
+    end
+  end
+end

data/pilot/lib/pilot/tester_manager.rb

@@ -0,0 +1,168 @@
+require 'terminal-table'
+
+require_relative 'manager'
+require_relative 'tester_util'
+
+module Pilot
+  class TesterManager < Manager
+    def add_tester(options)
+      start(options)
+      app = find_app(apple_id: config[:apple_id], app_identifier: config[:app_identifier])
+      UI.user_error!("You must provide either a Apple ID for the app (with the `:apple_id` option) or app identifier (with the `:app_identifier` option)") unless app
+
+      groups_param = config[:groups]
+      UI.user_error!("You must provide 1 or more groups (with the `:groups` option)") unless groups_param
+
+      app.get_beta_groups.select do |group|
+        next unless groups_param.include?(group.name)
+        user = {
+          email: config[:email],
+          firstName: config[:first_name],
+          lastName: config[:last_name]
+        }
+        group.post_bulk_beta_tester_assignments(beta_testers: [user])
+      end
+
+      group_names = groups_param.join(';')
+      UI.success("Successfully added tester #{config[:email]} to app #{app.name} in group(s) #{group_names}")
+    end
+
+    def find_tester(options)
+      start(options)
+
+      app = find_app(apple_id: config[:apple_id], app_identifier: config[:app_identifier])
+
+      tester = find_app_tester(email: config[:email], app: app)
+      UI.user_error!("Tester #{config[:email]} not found") unless tester
+
+      describe_tester(tester)
+      return tester
+    end
+
+    def remove_tester(options)
+      start(options)
+
+      app = find_app(apple_id: config[:apple_id], app_identifier: config[:app_identifier])
+
+      tester = find_app_tester(email: config[:email], app: app)
+      UI.user_error!("Tester #{config[:email]} not found") unless tester
+
+      begin
+        # If no groups are passed to options, remove the tester from the app-level,
+        # otherwise remove the tester from the groups specified.
+        if config[:groups].nil?
+          tester.delete_from_apps(apps: [app])
+          UI.success("Successfully removed tester #{tester.email} from app: #{app.name}")
+        else
+          groups = tester.beta_groups.select do |group|
+            config[:groups].include?(group.name)
+          end
+          tester.delete_from_beta_groups(beta_groups: groups)
+
+          group_names = groups.map(&:name)
+          UI.success("Successfully removed tester #{tester.email} from app #{app.name} in group(s) #{group_names}")
+        end
+      rescue => ex
+        UI.error("Could not remove #{tester.email} from app: #{ex}")
+        raise ex
+      end
+    end
+
+    def list_testers(options)
+      start(options)
+
+      app = find_app(apple_id: config[:apple_id], app_identifier: config[:app_identifier])
+      if app
+        list_testers_by_app(app)
+      else
+        UI.user_error!("You must include an `app_identifier` to `list_testers`")
+      end
+    end
+
+    private
+
+    def find_app(apple_id: nil, app_identifier: nil)
+      if app_identifier
+        app = Spaceship::ConnectAPI::App.find(app_identifier)
+        UI.user_error!("Could not find an app by #{app_identifier}") unless app
+        return app
+      end
+
+      if apple_id
+        app = Spaceship::ConnectAPI::App.get(app_id: apple_id)
+        UI.user_error!("Could not find an app by #{apple_id}") unless app
+        return app
+      end
+
+      UI.user_error!("You must include an `app_identifier` to `list_testers`")
+    end
+
+    def find_app_tester(email: nil, app: nil)
+      tester = app.get_beta_testers(filter: { email: email }, includes: "apps,betaTesterMetrics,betaGroups").first
+
+      if tester
+        UI.success("Found existing tester #{email}")
+      end
+
+      return tester
+    end
+
+    def list_testers_by_app(app)
+      testers = app.get_beta_testers(includes: "apps,betaTesterMetrics,betaGroups")
+
+      list_by_app(testers, "All Testers")
+    end
+
+    def list_by_app(all_testers, title)
+      headers = ["First", "Last", "Email", "Groups"]
+      list(all_testers, "#{title} (#{all_testers.count})", headers) do |tester|
+        tester_groups = tester.beta_groups.nil? ? nil : tester.beta_groups.map(&:name).join(";")
+        [
+          tester.first_name,
+          tester.last_name,
+          tester.email,
+          tester_groups
+          # Testers returned by the query made in the context of an app do not contain
+          # the version, or install date information
+        ]
+      end
+    end
+
+    # Requires a block that accepts a tester and returns an array of tester column values
+    def list(all_testers, title, headings)
+      rows = all_testers.map { |tester| yield(tester) }
+      puts(Terminal::Table.new(
+             title: title.green,
+             headings: headings,
+             rows: FastlaneCore::PrintTable.transform_output(rows)
+      ))
+    end
+
+    # Print out all the details of a specific tester
+    def describe_tester(tester)
+      return unless tester
+
+      rows = []
+
+      rows << ["First name", tester.first_name]
+      rows << ["Last name", tester.last_name]
+      rows << ["Email", tester.email]
+
+      if tester.beta_groups
+        rows << ["Groups", tester.beta_groups.map(&:name).join(";")]
+      end
+
+      metric = (tester.beta_tester_metrics || []).first
+      if metric.installed?
+        rows << ["Latest Version", "#{metric.installed_cf_bundle_short_version_string} (#{metric.installed_cf_bundle_version})"]
+        rows << ["Latest Install Date", metric.installed_cf_bundle_version]
+        rows << ["Installed", metric.installed?]
+      end
+
+      puts(Terminal::Table.new(
+             title: tester.email.green,
+             rows: FastlaneCore::PrintTable.transform_output(rows)
+      ))
+    end
+  end
+end

data/precheck/README.md

@@ -0,0 +1,17 @@
+<h3 align="center">
+  <a href="https://docs.fastlane.tools/actions/precheck/">
+    <img src="https://raw.githubusercontent.com/fastlane/fastlane/master/fastlane/assets/fastlane.png" width="100" />
+    <br />
+    fastlane
+  </a>
+</h3>
+
+------
+
+<p align="center">
+  <a href="https://docs.fastlane.tools/actions/precheck/">
+    <img src="https://raw.githubusercontent.com/fastlane/fastlane/master/precheck/assets/precheck.png" height="110">
+  </a>
+</p>
+
+<h3 align="center">The <i>precheck</i> docs were moved to <a href='https://docs.fastlane.tools/actions/precheck/'>docs.fastlane.tools</a></h3>

data/precheck/lib/assets/PrecheckfileTemplate

@@ -0,0 +1,27 @@
+# For more information about this configuration visit
+# https://docs.fastlane.tools/actions/precheck/
+
+# In general, you can use the options available
+# fastlane precheck --help
+
+# Remove the # in front of the line to enable the option
+
+# You have three possible values for each rule options
+# :skip
+# indicates that your metadata will not be checked by this rule
+
+# :warn
+# when triggered, this rule will warn you of a potential problem
+
+# :error
+# when triggered, this rule will cause an error to be displayed and it will prevent any further fastlane commands from running after precheck finishes
+
+# Examples:
+# negative_apple_sentiment(level: :skip)
+# curse_words(level: :warn)
+# future_functionality(level: :error)
+# other_platforms(level: :error)
+# placeholder_text(level: :error)
+# test_words(level: :error)
+# unreachable_urls(level: :error)
+# custom_text(data: ["fabric"], level: :warn)

data/precheck/lib/assets/PrecheckfileTemplate.swift

@@ -0,0 +1,19 @@
+// For more information about this configuration visit
+// https://docs.fastlane.tools/actions/precheck/#precheckfile
+
+// In general, you can use the options available
+// fastlane precheck --help
+
+class Precheckfile: PrecheckfileProtocol {
+    //var defaultRuleLevel: String { return "error" }
+}
+
+// You have three possible values for defaultRuleLevel
+// "skip"
+// indicates that your metadata will not be checked by this rule
+
+// "warn"
+// when triggered, this rule will warn you of a potential problem
+
+// "error"
+// when triggered, this rule will cause an error to be displayed and it will prevent any further fastlane commands from running after precheck finishes

data/precheck/lib/precheck.rb

@@ -0,0 +1,3 @@
+require_relative 'precheck/runner'
+require_relative 'precheck/options'
+require 'spaceship'

data/precheck/lib/precheck/commands_generator.rb

@@ -0,0 +1,74 @@
+require "commander"
+require "fastlane_core/globals"
+require "fastlane_core/configuration/commander_generator"
+require "fastlane_core/configuration/configuration"
+require "fastlane_core/helper"
+require "fastlane/version"
+
+require_relative 'module'
+require_relative 'options'
+require_relative 'runner'
+
+HighLine.track_eof = false
+
+module Precheck
+  class CommandsGenerator
+    include Commander::Methods
+
+    def self.start
+      new.run
+    end
+
+    def run
+      program :name, 'precheck'
+      program :version, Fastlane::VERSION
+      program :description, Precheck::DESCRIPTION
+      program :help, "Author", "Joshua Liebowitz <taquitos@gmail.com>, @taquitos"
+      program :help, "Website", "https://fastlane.tools"
+      program :help, "Documentation", "https://docs.fastlane.tools/actions/precheck/"
+      program :help_formatter, :compact
+
+      global_option("--verbose") { FastlaneCore::Globals.verbose = true }
+
+      command :check_metadata do |c|
+        c.syntax = "fastlane precheck"
+        c.description = Precheck::DESCRIPTION
+
+        FastlaneCore::CommanderGenerator.new.generate(Precheck::Options.available_options, command: c)
+
+        c.action do |_args, options|
+          Precheck.config = FastlaneCore::Configuration.create(Precheck::Options.available_options, options.__hash__)
+          Precheck::Runner.new.run
+        end
+      end
+
+      command :init do |c|
+        c.syntax = "fastlane precheck init"
+        c.description = "Creates a new Precheckfile for you"
+        c.action do |args, options|
+          containing = FastlaneCore::Helper.fastlane_enabled_folder_path
+          path = File.join(containing, Precheck.precheckfile_name)
+          UI.user_error!("Precheckfile already exists") if File.exist?(path)
+
+          is_swift_fastfile = args.include?("swift")
+          if is_swift_fastfile
+            path = File.join(containing, Precheck.precheckfile_name + ".swift")
+            UI.user_error!("Precheckfile.swift already exists") if File.exist?(path)
+          end
+
+          if is_swift_fastfile
+            template = File.read("#{Precheck::ROOT}/lib/assets/PrecheckfileTemplate.swift")
+          else
+            template = File.read("#{Precheck::ROOT}/lib/assets/PrecheckfileTemplate")
+          end
+          File.write(path, template)
+          UI.success("Successfully created '#{path}'. Open the file using a code editor.")
+        end
+      end
+
+      default_command(:check_metadata)
+
+      run!
+    end
+  end
+end

data/precheck/lib/precheck/item_to_check.rb

@@ -0,0 +1,58 @@
+module Precheck
+  # each attribute on a app version is a single item.
+  # for example: .name, .keywords, .description, will all have a single item to represent them
+  # which includes their name and a more user-friendly name we can use to print out information
+  class ItemToCheck
+    attr_accessor :item_name
+    attr_accessor :friendly_name
+    attr_accessor :is_optional
+
+    def initialize(item_name, friendly_name, is_optional = false)
+      @item_name = item_name
+      @friendly_name = friendly_name
+      @is_optional = is_optional
+    end
+
+    def item_data
+      not_implemented(__method__)
+    end
+
+    def inspect
+      "#{self.class}(friendly_name: #{@friendly_name}, data: #{@item_data})"
+    end
+
+    def to_s
+      "#{self.class}: #{item_name}: #{friendly_name}"
+    end
+  end
+
+  # if the data point we want to check is a text field (like 'description'), we'll use this object to encapsulate it
+  # this includes the text, the property name, and what that name maps to in plain english so that we can print out nice, friendly messages.
+  class TextItemToCheck < ItemToCheck
+    attr_accessor :text
+
+    def initialize(text, item_name, friendly_name, is_optional = false)
+      @text = text
+      super(item_name, friendly_name, is_optional)
+    end
+
+    def item_data
+      return text
+    end
+  end
+
+  # if the data point we want to check is a URL field (like 'marketing_url'), we'll use this object to encapsulate it
+  # this includes the url, the property name, and what that name maps to in plain english so that we can print out nice, friendly messages.
+  class URLItemToCheck < ItemToCheck
+    attr_accessor :url
+
+    def initialize(url, item_name, friendly_name, is_optional = false)
+      @url = url
+      super(item_name, friendly_name, is_optional)
+    end
+
+    def item_data
+      return url
+    end
+  end
+end