Class: Fastlane::Actions::AppaloosaAction

Inherits:
Fastlane::Action show all
Defined in:
lib/fastlane/actions/appaloosa.rb

Constant Summary collapse

APPALOOSA_SERVER = 
'https://www.appaloosa-store.com/api/v2'.freeze

Documentation collapse

Class Method Summary collapse

Methods inherited from Fastlane::Action

action_name, author, output, return_value, sh, step_text

Class Method Details



125
126
127
128
129
130
131
132
133
134
135
136
137
138
 
# File 'lib/fastlane/actions/appaloosa.rb', line 125

def self.all_screenshots_links(screenshots)
  if screenshots.nil?
    screens = %w(screenshot1 screenshot2 screenshot3 screenshot4 screenshot5)
    screenshots = screens.map do |_k, _v|
      ''
    end
  else
    missings = 5 - screenshots.count
    (1..missings).map do |_i|
      screenshots << ''
    end
  end
  screenshots
end

.authors ⇒ Object 



212
213
214
 
# File 'lib/fastlane/actions/appaloosa.rb', line 212

def self.authors
  ['Appaloosa']
end

.available_options ⇒ Object 



176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
 
# File 'lib/fastlane/actions/appaloosa.rb', line 176

def self.available_options
  [
    FastlaneCore::ConfigItem.new(key: :binary,
                                 env_name: 'FL_APPALOOSA_BINARY',
                                 description: 'Binary path. Optional for ipa if you use the `ipa` or `xcodebuild` action',
                                 default_value: Actions.lane_context[SharedValues::IPA_OUTPUT_PATH],
                                 verify_block: proc do |value|
                                   UI.user_error!("Couldn't find ipa || apk file at path '#{value}'") unless File.exist?(value)
                                 end),
    FastlaneCore::ConfigItem.new(key: :api_token,
                                 env_name: 'FL_APPALOOSA_API_TOKEN',
                                 description: "Your API token"),
    FastlaneCore::ConfigItem.new(key: :store_id,
                                 env_name: 'FL_APPALOOSA_STORE_ID',
                                 description: "Your Store id"),
    FastlaneCore::ConfigItem.new(key: :group_ids,
                                 env_name: 'FL_APPALOOSA_GROUPS',
                                 description: 'Your app is limited to special users? Give us the group ids',
                                 default_value: '',
                                 optional: true),
    FastlaneCore::ConfigItem.new(key: :screenshots,
                                 env_name: 'FL_APPALOOSA_SCREENSHOTS',
                                 description: 'Add some screenshots application to your store or hit [enter]',
                                 default_value: Actions.lane_context[SharedValues::SNAPSHOT_SCREENSHOTS_PATH]),
    FastlaneCore::ConfigItem.new(key: :locale,
                                 env_name: 'FL_APPALOOSA_LOCALE',
                                 description: 'Select the folder locale for yours screenshots',
                                 default_value: 'en-US',
                                 optional: true),
    FastlaneCore::ConfigItem.new(key: :device,
                                 env_name: 'FL_APPALOOSA_DEVICE',
                                 description: 'Select the device format for yours screenshots',
                                 optional: true)
  ]
end

.description ⇒ Object 



163
164
165
 
# File 'lib/fastlane/actions/appaloosa.rb', line 163

def self.description
  'Upload your app to Appaloosa Store'
end

.details ⇒ Object 



167
168
169
170
171
172
173
174
 
# File 'lib/fastlane/actions/appaloosa.rb', line 167

def self.details
  [
    "Appaloosa is a private mobile application store. This action ",
    "offers a quick deployment on the platform. You can create an ",
    "account, push to your existing account, or manage your user ",
    "groups. We accept iOS and Android applications."
  ].join("\n")
end

.error_detected(errors) ⇒ Object 



146
147
148
149
150
151
152
 
# File 'lib/fastlane/actions/appaloosa.rb', line 146

def self.error_detected(errors)
  if errors
    UI.user_error!("ERROR: #{errors}")
  else
    false
  end
end

.get_binary_link(binary, api_key, store_id, group_ids) ⇒ Object 



16
17
18
19
20
 
# File 'lib/fastlane/actions/appaloosa.rb', line 16

def self.get_binary_link(binary, api_key, store_id, group_ids)
  key_s3 = upload_on_s3(binary, api_key, store_id, group_ids)
  return if key_s3.nil?
  get_s3_url(api_key, store_id, key_s3)
end

.get_env_value(option) ⇒ Object 



140
141
142
143
144
 
# File 'lib/fastlane/actions/appaloosa.rb', line 140

def self.get_env_value(option)
  available_options.map do |opt|
    opt if opt.key == option.to_sym
  end.compact[0].default_value
end

.get_s3_url(api_key, store_id, path) ⇒ Object 



41
42
43
44
45
46
47
48
49
50
51
52
 
# File 'lib/fastlane/actions/appaloosa.rb', line 41

def self.get_s3_url(api_key, store_id, path)
  uri = URI("#{APPALOOSA_SERVER}/#{store_id}/upload_services/url_for_download")
  params = { store_id: store_id, api_key: api_key, key: path }
  uri.query = URI.encode_www_form(params)
  url_for_download_response = Net::HTTP.get_response(uri)
  if url_for_download_response.kind_of?(Net::HTTPNotFound)
    UI.user_error!("ERROR: A problem occurred with your API token and your store id. Please try again.")
  end
  json_res = JSON.parse(url_for_download_response.body)
  return if error_detected(json_res['errors'])
  json_res['binary_url']
end

.get_screenshots(screenshots_path, locale, device) ⇒ Object 



83
84
85
86
87
 
# File 'lib/fastlane/actions/appaloosa.rb', line 83

def self.get_screenshots(screenshots_path, locale, device)
  get_env_value('screenshots').nil? ? locale = '' : locale.concat('/')
  device.nil? ? device = '' : device.concat('-')
  !screenshots_path.strip.empty? ? screenshots_list(screenshots_path, locale, device) : nil
end

.get_screenshots_links(api_key, store_id, screenshots_path, locale, device) ⇒ Object 



75
76
77
78
79
80
81
 
# File 'lib/fastlane/actions/appaloosa.rb', line 75

def self.get_screenshots_links(api_key, store_id, screenshots_path, locale, device)
  screenshots = get_screenshots(screenshots_path, locale, device)
  return if screenshots.nil?
  uploaded = upload_screenshots(screenshots, api_key, store_id)
  links = get_uploaded_links(uploaded, api_key, store_id)
  links.kind_of?(Array) ? links.flatten : nil
end

.get_uploaded_links(uploaded_screenshots, api_key, store_id) ⇒ Object 



67
68
69
70
71
72
73
 
# File 'lib/fastlane/actions/appaloosa.rb', line 67

def self.get_uploaded_links(uploaded_screenshots, api_key, store_id)
  return if uploaded_screenshots.nil?
  urls = []
  urls << uploaded_screenshots.flatten.map do |url|
    get_s3_url(api_key, store_id, url)
  end
end

.is_supported?(platform) ⇒ Boolean

Returns:

  • (Boolean) 


216
217
218
 
# File 'lib/fastlane/actions/appaloosa.rb', line 216

def self.is_supported?(platform)
  [:ios, :mac, :android].include? platform
end

.remove_extra_screenshots_file(screenshots_env) ⇒ Object 



54
55
56
57
 
# File 'lib/fastlane/actions/appaloosa.rb', line 54

def self.remove_extra_screenshots_file(screenshots_env)
  extra_file = "#{screenshots_env}/screenshots.html"
  File.unlink(extra_file) if File.exist?(extra_file)
end

.run(params) ⇒ Object 



5
6
7
8
9
10
11
12
13
14
 
# File 'lib/fastlane/actions/appaloosa.rb', line 5

def self.run(params)
  api_key = params[:api_token]
  store_id = params[:store_id]
  binary = params[:binary]
  remove_extra_screenshots_file(params[:screenshots])
  binary_url = get_binary_link(binary, api_key, store_id, params[:group_ids])
  return if binary_url.nil?
  screenshots_url = get_screenshots_links(api_key, store_id, params[:screenshots], params[:locale], params[:device])
  upload_on_appaloosa(api_key, store_id, binary_url, screenshots_url, params[:group_ids])
end

.screenshots_list(path, locale, device) ⇒ Object 



89
90
91
92
93
94
95
96
 
# File 'lib/fastlane/actions/appaloosa.rb', line 89

def self.screenshots_list(path, locale, device)
  return warning_detected("screenshots folder not found") unless Dir.exist?("#{path}/#{locale}")
  list = Dir.entries("#{path}/#{locale}") - ['.', '..']
  list.map do |screen|
    next if screen.match(device).nil?
    "#{path}/#{locale}#{screen}" unless Dir.exist?("#{path}/#{locale}#{screen}")
  end.compact
end

.upload_on_appaloosa(api_key, store_id, binary_path, screenshots, group_ids) ⇒ Object 



98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
 
# File 'lib/fastlane/actions/appaloosa.rb', line 98

def self.upload_on_appaloosa(api_key, store_id, binary_path, screenshots, group_ids)
  screenshots = all_screenshots_links(screenshots)
  uri = URI("#{APPALOOSA_SERVER}/#{store_id}/mobile_application_updates/upload")
  http = Net::HTTP.new(uri.host, uri.port)
  req = Net::HTTP::Post.new(uri.path, { 'Content-Type' => 'application/json' })
  req.body = { store_id: store_id,
               api_key: api_key,
               mobile_application_update: {
                 binary_path: binary_path,
                 screenshot1: screenshots[0],
                 screenshot2: screenshots[1],
                 screenshot3: screenshots[2],
                 screenshot4: screenshots[3],
                 screenshot5: screenshots[4],
                 group_ids: group_ids,
                 provider: 'fastlane'
               }
             }.to_json
  uoa_response = http.request(req)
  json_res = JSON.parse(uoa_response.body)
  if json_res['errors']
    UI.error "App: #{json_res['errors']}"
  else
    UI.success "Binary processing: Check your app': #{json_res['link']}"
  end
end

.upload_on_s3(file, api_key, store_id, group_ids = '') ⇒ Object 



22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
 
# File 'lib/fastlane/actions/appaloosa.rb', line 22

def self.upload_on_s3(file, api_key, store_id, group_ids = '')
  file_name = file.split('/').last
  uri = URI("#{APPALOOSA_SERVER}/upload_services/presign_form")
  params = { file: file_name, store_id: store_id, group_ids: group_ids }
  uri.query = URI.encode_www_form(params)
  presign_form_response = Net::HTTP.get_response(uri)
  json_res = JSON.parse(presign_form_response.body)
  return if error_detected json_res['errors']
  s3_sign = json_res['s3_sign']
  path = json_res['path']
  uri = URI.parse(Base64.decode64(s3_sign))
  File.open(file, 'rb') do |f|
    Net::HTTP.start(uri.host) do |http|
      http.send_request('PUT', uri.request_uri, f.read, 'content-type' => '')
    end
  end
  path
end

.upload_screenshots(screenshots, api_key, store_id) ⇒ Object 



59
60
61
62
63
64
65
 
# File 'lib/fastlane/actions/appaloosa.rb', line 59

def self.upload_screenshots(screenshots, api_key, store_id)
  return if screenshots.nil?
  list = []
  list << screenshots.map do |screen|
    upload_on_s3(screen, api_key, store_id)
  end
end

.warning_detected(warning) ⇒ Object 



154
155
156
157
 
# File 'lib/fastlane/actions/appaloosa.rb', line 154

def self.warning_detected(warning)
  UI.important("WARNING: #{warning}")
  nil
end