fastlane-plugin-taiwan_number_one 0.2.0 → 0.2.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c476927219f7b1a3dcc7a6b5028143512ade17422dabd2068c1e17ed3694e9d3
-  data.tar.gz: c68e731269bfaa3dbe968aa439bc3259d2dfde16967ad3b7ebfa190eae36369e
+  metadata.gz: 38998812e7cb61b9ab73987cd633e0a1a8eef8ef10b1ce12724316112e7ffc4f
+  data.tar.gz: 50a7d3caf5a59ced69c251792d8c5a6aa5d1f0710ec37d66dc5b16a424360e35
 SHA512:
-  metadata.gz: bf4d2fc1e683b7f2d7c39cedea1952342a89aae659c40095310ea1b6ba7cf6dc93febcc861157431229271a5727ffc48e2647299154ca5a84e4ca21b38a8c319
-  data.tar.gz: 6f8868bbdad6f94983f435816ecd3f8fef9475f90e87a3ece2f49584538655fa53f81d63b38159105a03eb30d655962958e823248e724b864261d4afe766fb02
+  metadata.gz: 2964c997b6f0e2b438f28ecae85f41d60e0bbb5dcf0019c983efc59b8003f14e5f5404fc45d32382b2703b27840869e9ccb3af9b566cabd9e618b68f6a2f9329
+  data.tar.gz: ef10e5896baeb418ea40dacac2ef93a8bc279a872d29816ae41058085bbe5ede053690e381cf1cf1d09466a2ffbd50f40256fff56ae2cfb1b483a818ff0e5a16

data/README.md

@@ -12,7 +12,7 @@ fastlane add_plugin taiwan_number_one
 
 ## About taiwan_number_one
 
-To approve or reject if status is Pending Developer Release.
+To approve or reject if status is `Pending Developer Release`, otherwise do nothing.
 
 #### This feature is requsted for a while:
 
@@ -33,10 +33,10 @@ https://github.com/fastlane/fastlane/issues/17539
 
 ## Usage
 
-##### install plugin for fastlane
+##### Install plugin for fastlane
 [install instructions](https://docs.fastlane.tools/plugins/using-plugins/)
 ```
-bundle exce fastlane add_plugin taiwan_number_one
+bundle exec fastlane add_plugin taiwan_number_one
 ```
 but I personally prefer adding plugin in `Gemfile` like this to avoid additional `Pluginfile` in ~'your_ios_project_dir'/fastlane
 
@@ -59,11 +59,23 @@ lane :release_decision do |options|
   taiwan_number_one(
     username: username,
     app_identifier: app_identifier,
-    app_decision: options[:app_decision]
+    app_decision: options[:app_decision],
+    api_key: api_key
   )
 end
 ```
 
+and this:
+```
+desc "release App store version"
+lane :release_app do
+  result = release_decision(app_decision: Fastlane::Actions::TaiwanNumberOneAction::DicisionType::RELEASE)
+  if result == Fastlane::Actions::TaiwanNumberOneAction::ActionResult::SUCCESS
+    # do your thing here!
+  end
+end
+```
+
 or this:
 ```
 desc "reject App store version"
@@ -73,10 +85,7 @@ lane :reject_app do
     issuer_id: ENV["ISSUER_ID"],
     key_content: ENV["ASC_API_KEY"]
   )
-  release_decision(
-    app_decision: Fastlane::Actions::TaiwanNumberOneAction::DicisionType::REJECT,
-    api_key: api_key
-  )
+  release_decision(app_decision: Fastlane::Actions::TaiwanNumberOneAction::DicisionType::REJECT)
 end
 ```
 
@@ -126,6 +135,11 @@ team_name     |The name of your App Store Connect team if you're in multiple tea
 api_key_path	|Path to your App Store Connect API Key JSON file (https://docs.fastlane.tools/app-store-connect-api/#using-fastlane-api-key-json-file)	|
 api_key	      |Your App Store Connect API Key information (https://docs.fastlane.tools/app-store-connect-api/#use-return-value-and-pass-in-as-an-option) |
 
+## Action Return
+`Fastlane::Actions::TaiwanNumberOneAction::ActionResult::SUCCESS`
+or 
+`Fastlane::Actions::TaiwanNumberOneAction::ActionResult::DO_NOTHING`
+
 ## Run tests for this plugin
 
 Not supported right now.

data/lib/fastlane/plugin/taiwan_number_one/actions/taiwan_number_one_action.rb

@@ -1,5 +1,4 @@
 require "fastlane/action"
-require "Spaceship"
 require_relative "../helper/taiwan_number_one_helper"
 
 module Fastlane
@@ -10,77 +9,98 @@ module Fastlane
         REJECT = "reject"
       end
 
-      def self.run(params)
-        params[:api_key] ||= Actions.lane_context[SharedValues::APP_STORE_CONNECT_API_KEY]
-
-        app_id = params.fetch(:app_identifier)
-        username = params.fetch(:username)
-        unless app_id && username
-          UI.message("Could not find app_id and username.")
-          return
-        end
+      module ActionResult
+        SUCCESS = "Success"
+        DO_NOTHING = "Nothing has changed"
+      end
 
-        token = self.api_token(params)
-        if token
-          UI.message("Using App Store Connect API token...")
-          Spaceship::ConnectAPI.token = token
-        else
-          UI.message("Login to App Store Connect (#{params[:username]})")
-          Spaceship::ConnectAPI.login(
-            params[:username],
-            use_portal: false,
-            use_tunes: true,
-            tunes_team_id: params[:team_id],
-            team_name: params[:team_name]
-          )
-          UI.message("Login successful")
-        end
+      def self.run(params)
+        require 'spaceship'
+        begin
+          params[:api_key] ||= Actions.lane_context[SharedValues::APP_STORE_CONNECT_API_KEY]
 
-        app = Spaceship::ConnectAPI::App.find(app_id)
-        version = app.get_app_store_versions.first
-        UI.message("app_store_state is #{version.app_store_state}")
-        client ||= Spaceship::ConnectAPI
-        platform ||= Spaceship::ConnectAPI::Platform::IOS
-        filter = {
-          appStoreState: [
-            Spaceship::ConnectAPI::AppStoreVersion::AppStoreState::PENDING_DEVELOPER_RELEASE
-          ].join(","),
-          platform: platform
-        }
-        app_store_version = app.get_app_store_versions(client: client, filter: filter, includes: "appStoreVersionSubmission")
-                               .sort_by { |v| Gem::Version.new(v.version_string) }
-                               .last
-        if app_store_version
-          version_string = app_store_version.version_string
-          state = app_store_version.app_store_state
-          UI.message("version #{version_string} is #{state}")
-          unless state == Spaceship::ConnectAPI::AppStoreVersion::AppStoreState::PENDING_DEVELOPER_RELEASE
-            UI.message("AppStoreState is not PENDING_DEVELOPER_RELEASE")
+          app_id = params.fetch(:app_identifier)
+          username = params.fetch(:username)
+          unless app_id && username
+            UI.message("Could not find app_id and username.")
             return
           end
-          decision = params[:app_decision]
-          decision ||= fetch_decision
-          case decision
-          when DicisionType::RELEASE
-            UI.message("decision is release")
-            release_version_if_possible(app: app, app_store_version: app_store_version)
-          when DicisionType::REJECT
-            UI.message("decision is reject")
-            reject_version_if_possible(app: app, app_store_version: app_store_version)
+
+          token = self.api_token(params)
+          if token
+            UI.message("Using App Store Connect API token...")
+            Spaceship::ConnectAPI.token = token
+          else
+            UI.message("Login to App Store Connect (#{params[:username]})")
+            Spaceship::ConnectAPI.login(
+              params[:username],
+              use_portal: false,
+              use_tunes: true,
+              tunes_team_id: params[:team_id],
+              team_name: params[:team_name]
+            )
+            UI.message("Login successful")
+          end
+
+          app = Spaceship::ConnectAPI::App.find(app_id)
+          version = app.get_app_store_versions.first
+          UI.message("app_store_state is #{version.app_store_state}")
+          client ||= Spaceship::ConnectAPI
+          platform ||= Spaceship::ConnectAPI::Platform::IOS
+          filter = {
+            appStoreState: [
+              Spaceship::ConnectAPI::AppStoreVersion::AppStoreState::PENDING_DEVELOPER_RELEASE
+            ].join(","),
+            platform: platform
+          }
+          app_store_version = app.get_app_store_versions(client: client, filter: filter, includes: "appStoreVersionSubmission")
+                                 .sort_by { |v| Gem::Version.new(v.version_string) }
+                                 .last
+          if app_store_version
+            version_string = app_store_version.version_string
+            state = app_store_version.app_store_state
+            UI.message("version #{version_string} is #{state}")
+            unless state == Spaceship::ConnectAPI::AppStoreVersion::AppStoreState::PENDING_DEVELOPER_RELEASE
+              UI.message("AppStoreState is not PENDING_DEVELOPER_RELEASE")
+              UI.message("🇹🇼 Taiwan helps you do nothing!")
+              return
+            end
+            decision ||= fetch_decision(params)
+
+            result = ActionResult::DO_NOTHING
+            case decision
+            when DicisionType::RELEASE
+              UI.message("decision is release")
+              result = release_version_if_possible(app: app, app_store_version: app_store_version)
+            when DicisionType::REJECT
+              UI.message("decision is reject")
+              result = reject_version_if_possible(app: app, app_store_version: app_store_version)
+            else
+              UI.user_error!("App's decision must be release or reject")
+              result = ActionResult::DO_NOTHING
+            end
+
+            UI.message("The taiwan_number_one plugin action is finished!")
+            UI.message("🇹🇼 Taiwan can help!")
+            return result
           else
-            decision ||= fetch_decision
+            UI.message("no pending release version exist.")
+            UI.message("The taiwan_number_one plugin action is finished!")
+            UI.message("🇹🇼 Taiwan can help!")
+            return ActionResult::DO_NOTHING
           end
-        else
-          UI.message("no pending release version exist.")
+        rescue => error
+          UI.message("🇹🇼 Taiwan might not be able to help you with this...")
+          UI.user_error!("The taiwan_number_one plugin action is finished with error: #{error.message}!")
+          return ActionResult::DO_NOTHING
         end
-        UI.message("The taiwan_number_one plugin action is finished!")
       end
 
-      def self.fetch_decision
-        decision = nil
+      def self.fetch_decision(params)
+        decision = params[:app_decision]
         until ["release", "reject"].include?(decision)
-          decision = UI.input("Please enter the app's release decision (release, reject): ")
-          UI.message("App's decision must be release or reject")
+          UI.user_error!("App's decision must be release or reject.")
+          return
         end
         # return decision
         UI.message("return type #{decision}")
@@ -94,26 +114,31 @@ module Fastlane
       def self.release_version_if_possible(app: nil, app_store_version: Spaceship::ConnectAPI::AppStoreVersion)
         unless app
           UI.user_error!("Could not find app with bundle identifier '#{params[:app_identifier]}' on account #{params[:username]}")
+          return ActionResult::DO_NOTHING
         end
 
         begin
           app_store_version.create_app_store_version_release_request
           UI.message("release version #{app_store_version.version_string} successfully!")
+          return ActionResult::SUCCESS
         rescue => e
-          UI.user_error!("An error occurred while releasing version #{app_store_version}")
-          UI.error("#{e.message}\n#{e.backtrace.join("\n")}") if FastlaneCore::Globals.verbose?
+          UI.user_error!("An error occurred while releasing version #{app_store_version}, #{e.message}\n#{e.backtrace.join("\n")}")
+          return ActionResult::DO_NOTHING
         end
       end
 
       def self.reject_version_if_possible(app: nil, app_store_version: Spaceship::ConnectAPI::AppStoreVersion)
         unless app
           UI.user_error!("Could not find app with bundle identifier '#{params[:app_identifier]}' on account #{params[:username]}")
+          return ActionResult::DO_NOTHING
         end
 
         if app_store_version.reject!
           UI.success("rejected version #{app_store_version.version_string} Successfully!")
+          return ActionResult::SUCCESS
         else
           UI.user_error!("An error occurred while rejected version #{app_store_version}")
+          return ActionResult::DO_NOTHING
         end
       end
 
@@ -133,14 +158,20 @@ module Fastlane
       end
 
       def self.return_value
-        # If your method provides a return value, you can describe here what it does
+        return "'Success' if action passes, else, 'Nothing has changed'"
       end
 
       def self.details
-        # Optional:
         "use fastlane to release or reject reviewed version"
       end
 
+      def self.output
+        [
+          [ActionResult::SUCCESS, 'Successfully release or reject.'],
+          [ActionResult::DO_NOTHING, 'Do nothing.']
+        ]
+      end
+
       def self.available_options
         user = CredentialsManager::AppfileConfig.try_fetch_value(:itunes_connect_id)
         user ||= CredentialsManager::AppfileConfig.try_fetch_value(:apple_id)
@@ -218,7 +249,7 @@ module Fastlane
         [
           'taiwan_number_one(
             app_decision: "release",
-            api_key: "api_key" # your app_store_connect_api_key 
+            api_key: "api_key" # your app_store_connect_api_key
           )'
         ]
       end

data/lib/fastlane/plugin/taiwan_number_one/version.rb

@@ -1,5 +1,5 @@
 module Fastlane
   module TaiwanNumberOne
-    VERSION = "0.2.0"
+    VERSION = "0.2.5"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fastlane-plugin-taiwan_number_one
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.2.5
 platform: ruby
 authors:
 - andrew54068
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-03-22 00:00:00.000000000 Z
+date: 2021-03-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pry