ETLane 0.1.42 → 0.1.43

data/Lanes/actions/lokalise.rb

@@ -0,0 +1,180 @@
+module Fastlane
+  module Actions
+    class LokaliseAction < Action
+      def self.run(params)
+        require 'net/http'
+
+        token = params[:api_token]
+        project_identifier = params[:project_identifier]
+        destination = params[:destination]
+        clean_destination = params[:clean_destination]
+        include_comments = params[:include_comments] ? 1 : 0
+        use_original = params[:use_original] ? 1 : 0
+
+        request_data = {
+          original_filenames: true,
+          export_sort: "first_added", 
+          format: "strings",
+          directory_prefix: "",
+        }
+        languages = params[:languages]
+        if languages.kind_of? Array then
+          request_data["langs"] = languages.to_json
+        end
+
+        tags = params[:tags]
+        if tags.kind_of? Array then
+          request_data["include_tags"] = tags.to_json
+        end
+
+        uri = URI("https://api.lokalise.com/api2/projects/#{project_identifier}/files/download")
+        request = Net::HTTP::Post.new(uri)
+        request.body = request_data.to_json
+        request['X-Api-Token'] = token
+        request['Content-Type'] = 'application/json'
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = true
+        response = http.request(request)
+
+        jsonResponse = JSON.parse(response.body)
+        puts(jsonResponse.to_s)
+        UI.error "Bad response 🉐\n#{response.body}" unless jsonResponse.kind_of? Hash
+        fileURL = jsonResponse["bundle_url"]
+        if fileURL.kind_of?(String)  then
+          UI.message "Downloading localizations archive 📦"
+          FileUtils.mkdir_p("lokalisetmp")
+          uri = URI(fileURL)
+          http = Net::HTTP.new(uri.host, uri.port)
+          http.use_ssl = true
+          zipRequest = Net::HTTP::Get.new(uri)
+          response = http.request(zipRequest)
+          if response.content_type == "application/zip" or response.content_type == "application/octet-stream" then
+            FileUtils.mkdir_p("lokalisetmp")
+            open("lokalisetmp/a.zip", "wb") { |file| 
+              file.write(response.body)
+            }
+            unzip_file("lokalisetmp/a.zip", destination, clean_destination)
+            FileUtils.remove_dir("lokalisetmp")
+            UI.success "Localizations extracted to #{destination} 📗 📕 📘"
+            copy_fr_folder(File.join(destination, "Fitness/Resources"))
+            copy_fr_folder(File.join(destination, "Watch Extension/Resources"))
+          else
+            UI.error "Response did not include ZIP"
+          end
+        elsif jsonResponse["response"]["status"] == "error"
+          code = jsonResponse["response"]["code"]
+          message = jsonResponse["response"]["message"]
+          UI.error "Response error code #{code} (#{message}) 📟"
+        else
+          UI.error "Bad response 🉐\n#{jsonResponse}"
+        end
+      end
+
+      def self.copy_fr_folder(destination)
+        fr_path = File.join(destination, "fr.lproj")
+        puts fr_path
+        if File.exist?(fr_path)
+          FileUtils.copy_entry(fr_path, File.join(destination, "fr-CA.lproj"))
+        end
+      end
+
+      def self.unzip_file(file, destination, clean_destination)
+        require 'zip'
+        require 'rubygems'
+        Zip::File.open(file) { |zip_file|
+          if clean_destination then
+            UI.message "Cleaning destination folder ♻️"
+            FileUtils.remove_dir(destination)
+            FileUtils.mkdir_p(destination)
+          end
+          UI.message "Unarchiving localizations to destination 📚"
+           zip_file.each { |f|
+             f_path= File.join(destination, f.name)
+             FileUtils.mkdir_p(File.dirname(f_path))
+             FileUtils.rm(f_path) if File.file? f_path
+             zip_file.extract(f, f_path)
+           }
+        }
+      end
+
+
+      #####################################################
+      # @!group Documentation
+      #####################################################
+
+      def self.description
+        "Download Lokalise localization"
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :api_token,
+                                       env_name: "LOKALISE_API_TOKEN",
+                                       description: "API Token for Lokalise",
+                                       verify_block: proc do |value|
+                                          UI.user_error! "No API token for Lokalise given, pass using `api_token: 'token'`" unless (value and not value.empty?)
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :project_identifier,
+                                       env_name: "LOKALISE_PROJECT_ID",
+                                       description: "Lokalise Project ID",
+                                       verify_block: proc do |value|
+                                          UI.user_error! "No Project Identifier for Lokalise given, pass using `project_identifier: 'identifier'`" unless (value and not value.empty?)
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :destination,
+                                       description: "Localization destination",
+                                       verify_block: proc do |value|
+                                          UI.user_error! "Things are pretty bad" unless (value and not value.empty?)
+                                          UI.user_error! "Directory you passed is in your imagination" unless File.directory?(value)
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :clean_destination,
+                                       description: "Clean destination folder",
+                                       optional: true,
+                                       is_string: false,
+                                       default_value: false,
+                                       verify_block: proc do |value|
+                                          UI.user_error! "Clean destination should be true or false" unless [true, false].include? value
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :languages,
+                                       description: "Languages to download",
+                                       optional: true,
+                                       is_string: false,
+                                       verify_block: proc do |value|
+                                          UI.user_error! "Language codes should be passed as array" unless value.kind_of? Array
+                                       end),
+            FastlaneCore::ConfigItem.new(key: :include_comments,
+                                       description: "Include comments in exported files",
+                                       optional: true,
+                                       is_string: false,
+                                       default_value: false,
+                                       verify_block: proc do |value|
+                                         UI.user_error! "Include comments should be true or false" unless [true, false].include? value
+                                       end),
+            FastlaneCore::ConfigItem.new(key: :use_original,
+                                       description: "Use original filenames/formats (bundle_structure parameter is ignored then)",
+                                       optional: true,
+                                       is_string: false,
+                                       default_value: false,
+                                       verify_block: proc do |value|
+                                         UI.user_error! "Use original should be true of false." unless [true, false].include?(value)
+                                        end),
+            FastlaneCore::ConfigItem.new(key: :tags,
+                                        description: "Include only the keys tagged with a given set of tags",
+                                        optional: true,
+                                        is_string: false,
+                                        verify_block: proc do |value|
+                                          UI.user_error! "Tags should be passed as array" unless value.kind_of? Array
+                                        end),
+
+        ]
+      end
+
+      def self.authors
+        "Fedya-L"
+      end
+
+      def self.is_supported?(platform)
+        [:ios, :mac].include? platform 
+      end
+    end
+  end
+end

data/Lanes/actions/lokalise_metadata.rb

@@ -0,0 +1,624 @@
+module Fastlane
+  module Actions
+
+    class LokaliseMetadataAction < Action
+      @params
+      def self.run(params)
+        @params = params
+        action = params[:action]
+
+        case action
+        when "update_itunes"
+          key_file = metadata_key_file_itunes()
+          metadata = get_metadata_from_lokalise_itunes()
+          run_deliver_action(metadata)
+        when "update_googleplay"
+          release_number = params[:release_number]
+          UI.user_error! "Release number is required when using `update_googleplay` action (should be an integer and greater that 0)" unless (release_number and release_number.is_a?(Integer) and release_number > 0)
+          key_file = metadata_key_file_googleplay
+          metadata = get_metadata_from_lokalise_googleplay()
+          save_metadata_to_files(metadata, release_number)
+          run_supply_action(params[:validate_only])
+        when "update_lokalise_itunes"
+          metadata = get_metadata_itunes_connect()
+          add_languages = params[:add_languages]
+          override_translation = params[:override_translation]
+          if add_languages == true 
+            create_languages(metadata.keys, true)
+          end
+          if override_translation == true
+            upload_metadata_itunes(metadata) unless metadata.empty?
+          else
+            lokalise_metadata = get_metadata_from_lokalise_itunes()
+            filtered_metadata = filter_metadata(metadata, lokalise_metadata)
+            upload_metadata_itunes(filtered_metadata) unless filtered_metadata.empty?
+          end
+        when "update_lokalise_googleplay"
+          metadata = get_metadata_google_play()
+          add_languages = params[:add_languages]
+          override_translation = params[:override_translation]
+          if add_languages == true 
+            create_languages(metadata.keys, false)
+          end
+          if override_translation == true
+            upload_metadata_google_play(metadata) unless metadata.empty?
+          else
+            lokalise_metadata = get_metadata_from_lokalise_googleplay()
+            filtered_metadata = filter_metadata(metadata, lokalise_metadata)
+            upload_metadata_google_play(filtered_metadata) unless filtered_metadata.empty?
+          end
+        end
+      end
+
+      def self.create_languages(languages, for_itunes)
+        data = {
+          iso: languages.map { |language| fix_language_name(language, for_itunes, true) } .to_json
+        }
+        make_request("language/add", data)
+      end
+
+      def self.filter_metadata(metadata, other_metadata)
+        filtered_metadata = {}
+        metadata.each { |language, translations|
+          other_translations = other_metadata[language]
+          filtered_translations = {}
+          
+          if other_translations != nil && other_translations.empty? == false
+            translations.each { |key, value|
+              other_value = other_translations[key]
+              filtered_translations[key] = value unless other_value != nil && other_value.empty? == false
+            }
+          else 
+            filtered_translations = translations
+          end
+
+          filtered_metadata[language] = filtered_translations unless filtered_translations.empty?
+        }
+        return filtered_metadata
+      end
+
+
+      def self.run_deliver_action(metadata)
+        config = FastlaneCore::Configuration.create(Actions::DeliverAction.available_options, {})
+        config.load_configuration_file("Deliverfile")
+        config[:metadata_path] = "./fastlane/no_metadata"
+        config[:screenshots_path] = "./fastlane/no_screenshot"
+        config[:skip_screenshots] = true
+        config[:run_precheck_before_submit] = false
+        config[:skip_binary_upload] = true
+        config[:skip_app_version_update] = true
+        config[:force] = true
+
+        metadata_key_file_itunes().each { |key, parameter|
+          final_translations = {}
+
+          metadata.each { |lang, translations|
+            if translations.empty? == false
+              translation = translations[key]
+              final_translations[lang] = translation if translation != nil && translation.empty? == false
+            end 
+          }
+
+          config[parameter.to_sym] = final_translations
+        }
+
+        Actions::DeliverAction.run(config)
+      end
+
+      def self.run_supply_action(validate_only)
+        config = FastlaneCore::Configuration.create(Actions::SupplyAction.available_options, {})
+        config[:skip_upload_apk] = true
+        config[:skip_upload_aab] = true
+        config[:skip_upload_screenshots] = true
+        config[:skip_upload_images] = true
+        config[:validate_only] = validate_only
+
+        Actions::SupplyAction.run(config)
+      end
+
+      def self.save_metadata_to_files(metadata, release_number)
+
+        translations = {}
+
+        metadata_key_file_googleplay().each { |key, parameter|
+          final_translations = {}
+
+          metadata.each { |lang, translations|
+            if translations.empty? == false
+              translation = translations[key]
+              final_translations[lang] = translation if translation != nil && translation.empty? == false
+            end 
+          }
+
+          translations[parameter.to_sym] = final_translations
+        }
+
+        FileUtils.rm_rf(Dir['fastlane/metadata/android/*'])
+
+        translations.each { |key, parameter|
+          parameter.each { |lang, text|
+            path = "fastlane/metadata/android/#{lang}/#{key}.txt"
+            if "#{key}" ==  "changelogs"
+              path = "fastlane/metadata/android/#{lang}/changelogs/#{release_number}.txt"
+            end
+            dirname = File.dirname(path)
+            unless File.directory?(dirname)
+              FileUtils.mkdir_p(dirname)
+            end
+            File.write(path, text)
+          }
+        }
+
+      end
+
+      def self.make_request(path, data)
+        require 'net/http'
+
+        request_data = {
+          api_token: @params[:api_token],
+          id: @params[:project_identifier]
+        }.merge(data)
+
+        uri = URI("https://api.lokalise.com/api/#{path}")
+        request = Net::HTTP::Post.new(uri)
+        request.set_form_data(request_data)
+  
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = true
+        response = http.request(request)
+
+        jsonResponse = JSON.parse(response.body)
+        raise "Bad response 🉐\n#{response.body}" unless jsonResponse.kind_of? Hash
+        if jsonResponse["response"]["status"] == "success"  then
+          UI.success "Response #{jsonResponse} 🚀"
+        elsif jsonResponse["response"]["status"] == "error"
+          code = jsonResponse["response"]["code"]
+          message = jsonResponse["response"]["message"]
+          raise "Response error code #{code} (#{message}) 📟"
+        else
+          raise "Bad response 🉐\n#{jsonResponse}"
+        end
+        return jsonResponse
+      end
+
+      def self.upload_metadata(metadata_keys, for_itunes, metadata)
+        
+        keys = []
+
+        metadata_keys.each do |key, value|
+          key = make_key_object_from_metadata(key, metadata, for_itunes)
+          if key 
+            keys << key
+          end
+        end
+
+        data = {
+          data: keys.to_json
+        }
+
+        make_request("string/set", data)
+      end
+
+      def self.upload_metadata_itunes(metadata)
+        upload_metadata(metadata_key_file_itunes, true, metadata)
+      end
+
+      def self.upload_metadata_google_play(metadata)
+        upload_metadata(metadata_key_file_googleplay, false, metadata)
+      end
+
+      def self.make_key_object_from_metadata(key, metadata, for_itunes)
+        key_data = {
+          "key" => key,
+          "platform_mask" => 16,
+          "translations" => {}
+        }
+        metadata.each { |iso_code, data|
+          translation = data[key]
+          unless translation == nil || translation.empty?
+            key_data["translations"][fix_language_name(iso_code, for_itunes, true)] = translation
+          end
+        }
+        unless key_data["translations"].empty? 
+          return key_data
+        else
+          return nil
+        end
+      end
+
+      def self.get_metadata_google_play()
+        available_languages = google_play_languages
+        return get_metadata(available_languages, "fastlane/metadata/android/", false)
+      end
+
+      def self.get_metadata_itunes_connect()
+        available_languages = itunes_connect_languages
+        return get_metadata(available_languages, "fastlane/metadata/", true)
+      end
+
+      def self.get_metadata(available_languages, folder, for_itunes)
+        complete_metadata = {}
+
+        available_languages.each { |iso_code|
+          language_directory = "#{folder}#{iso_code}"
+          if Dir.exist? language_directory
+            language_metadata = {}
+            if for_itunes
+              metadata_key_file_itunes().each { |key, file|
+                populate_hash_key_from_file(language_metadata, key, language_directory + "/#{file}.txt")
+              }
+            else 
+              metadata_key_file_googleplay().each { |key, file|
+                if file == "changelogs"
+                  changelog_directory = "#{folder}#{iso_code}/changelogs"
+                  files = Dir.entries("#{changelog_directory}")
+                  collectedFiles = files.collect { |s| s.partition(".").first.to_i }
+                  sortedFiles = collectedFiles.sort
+                  populate_hash_key_from_file(language_metadata, key, language_directory + "/changelogs/#{sortedFiles.last}.txt")
+                else 
+                  populate_hash_key_from_file(language_metadata, key, language_directory + "/#{file}.txt")
+                end
+              }
+            end
+            complete_metadata[iso_code] = language_metadata
+          end
+        }
+
+        return complete_metadata
+      end
+
+      def self.get_metadata_from_lokalise(valid_keys, for_itunes)
+
+        data = {
+          platform_mask: 16,
+          keys: valid_keys.to_json,
+        }
+
+        response = make_request("string/list", data)
+
+        if for_itunes
+          valid_languages = itunes_connect_languages_in_lokalise() 
+        else
+          valid_languages = google_play_languages_in_lokalise()        
+        end
+        metadata = {}
+
+        response["strings"].each { |lang, translation_objects|
+          if valid_languages.include?(lang)
+            translations = {}
+            translation_objects.each { |object|
+              key = object["key"]
+              translation = object["translation"]
+              if valid_keys.include?(key) && translation != nil && translation.empty? == false 
+                translations[key] = translation
+              end
+            }
+            if translations.empty? == false
+              metadata[fix_language_name(lang, for_itunes)] = translations
+            end
+          end
+        }
+        return metadata
+
+      end
+
+      def self.get_metadata_from_lokalise_itunes()
+
+        valid_keys = metadata_keys_itunes()
+        return get_metadata_from_lokalise(valid_keys, true)
+
+      end
+
+      def self.get_metadata_from_lokalise_googleplay()
+
+        valid_keys = metadata_keys_googleplay()
+        return get_metadata_from_lokalise(valid_keys, false)
+
+      end
+
+      def self.populate_hash_key_from_file(hash, key, filepath)
+        begin
+          text = File.read filepath
+          text.chomp!
+          hash[key] = text unless text.empty?
+        rescue => exception
+          raise exception
+        end        
+      end
+
+      def self.metadata_keys_itunes()
+        return metadata_key_file_itunes().keys
+      end
+
+      def self.metadata_keys_googleplay()
+        return metadata_key_file_googleplay().keys
+      end
+
+      def self.metadata_key_file_itunes()
+        return {
+          "appstore.app.name" => "name",
+          "appstore.app.description" => "description",
+          "appstore.app.keywords" => "keywords",
+          "appstore.app.promotional_text" => "promotional_text",
+          "appstore.app.release_notes" => "release_notes",
+          "appstore.app.subtitle" => "subtitle",
+        }
+      end
+
+      def self.metadata_key_file_googleplay()
+        return {
+          "googleplay.app.title" => "title",
+          "googleplay.app.full_description" => "full_description",
+          "googleplay.app.short_description" => "short_description",
+          "googleplay.app.changelogs" => "changelogs",
+        }
+      end
+
+      def self.itunes_connect_languages_in_lokalise()
+        return itunes_connect_languages().map { |lang| 
+          fix_language_name(lang, true, true) 
+        }
+      end
+
+      def self.google_play_languages_in_lokalise()
+        return google_play_languages().map { |lang| 
+          fix_language_name(lang, false, true) 
+        }
+      end
+
+      def self.itunes_connect_languages()
+        return [
+          "en-US",
+          "zh-Hans",
+          "zh-Hant",
+          "da",
+          "nl-NL",
+          "en-AU",
+          "en-CA",
+          "en-GB",
+          "fi",
+          "fr-FR",
+          "fr-CA",
+          "de-DE",
+          "el",
+          "id",
+          "it",
+          "ja",
+          "ko",
+          "ms",
+          "no",
+          "pt-BR",
+          "pt-PT",
+          "ru",
+          "es-MX",
+          "es-ES",
+          "sv",
+          "th",
+          "tr",
+          "vi"
+        ]
+      end
+
+      def self.google_play_languages()
+        return [
+          'af',
+          'am',
+          'ar',
+          'hy',
+          'az-AZ',
+          'eu-ES',
+          'be',
+          'bn-BD',
+          'bg',
+          'my',
+          'ca',
+          'zh-CN',
+          'zh-TW',
+          'zh-HK',
+          'hr',
+          'cs',
+          'da',
+          'nl-NL',
+          'en-AU',
+          'en-CA',
+          'en-IN',
+          'en-SG',
+          'en-ZA',
+          'en-GB',
+          'en-US',
+          'et-EE',
+          'fil',
+          'fi',
+          'fr-CA',
+          'fr-FR',
+          'gl-ES',
+          'ka-GE',
+          'de-DE',
+          'el-GR',
+          'he',
+          'hi-IN',
+          'hu',
+          'is-IS',
+          'id',
+          'it-IT',
+          'ja',
+          'kn-IN',
+          'km-KH',
+          'ko',
+          'ky',
+          'lo',
+          'lv-LV',
+          'lt-LT',
+          'mk-MK',
+          'ms',
+          'ml-IN',
+          'mr',
+          'mn-MN',
+          'ne-NP',
+          'no',
+          'fa',
+          'pl',
+          'pt-BR',
+          'pt-PT',
+          'ro',
+          'ru-RU',
+          'sr',
+          'si',
+          'sk',
+          'sl-SI',
+          'es-419',
+          'es-ES',
+          'es-US',
+          'sw',
+          'sv-SE',
+          'ta-IN',
+          'te-IN',
+          'th',
+          'tr',
+          'uk',
+          'vi',
+          'zu'
+        ]
+      end
+
+      def self.fix_language_name(name, for_itunes, for_lokalise = false)
+        if for_itunes
+          if for_lokalise
+            name =  name.gsub("-","_")
+            name = "en" if name == "en_US"
+            name = "de" if name == "de_DE"
+            name = "es" if name == "es_ES"
+            name = "fr" if name == "fr_FR"
+          else 
+            name = name.gsub("_","-")
+            name = "en-US" if name == "en"
+            name = "de-DE" if name == "de"
+            name = "es-ES" if name == "es"
+            name = "fr-FR" if name == "fr"
+          end
+        else
+          if for_lokalise
+            name =  name.gsub("-","_")
+            name = "tr" if name == "tr_TR"
+            name = "hy" if name == "hy_AM"
+            name = "my" if name == "my_MM"
+            name = "ms" if name == "ms_MY"
+            name = "cs" if name == "cs_CZ"
+            name = "da" if name == "da_DK"
+            name = "et_EE" if name == "et"
+            name = "fi" if name == "fi_FI"
+            name = "he" if name == "iw_IL"
+            name = "hu" if name == "hu_HU"
+            name = "ja" if name == "ja_JP"
+            name = "ko" if name == "ko_KR"
+            name = "ky" if name == "ky_KG"
+            name = "lo" if name == "lo_LA"
+            name = "lv_LV" if name == "lv"
+            name = "lt_LT" if name == "lt"
+            name = "mr" if name == "mr_IN"
+            name = "no" if name == "no_NO"
+            name = "pl" if name == "pl_PL"
+            name = "si" if name == "si_LK"
+            name = "sl_SI" if name == "sl"
+          else 
+            name = name.gsub("_","-")
+            name = "tr-TR" if name == "tr"
+            name = "hy-AM" if name == "hy"
+            name = "my-MM" if name == "my"
+            name = "ms-MY" if name == "ms"
+            name = "cs-CZ" if name == "cs"
+            name = "da-DK" if name == "da"
+            name = "et" if name == "et-EE"
+            name = "fi-FI" if name == "fi"
+            name = "iw-IL" if name == "he"
+            name = "hu-HU" if name == "hu"
+            name = "ja-JP" if name == "ja"
+            name = "ko-KR" if name == "ko"
+            name = "ky-KG" if name == "ky"
+            name = "lo-LA" if name == "lo"
+            name = "lv" if name == "lv-LV"
+            name = "lt" if name == "lt-LT"
+            name = "mr-IN" if name == "mr"
+            name = "no-NO" if name == "no"
+            name = "pl-PL" if name == "pl"
+            name = "si-LK" if name == "si"
+            name = "sl" if name == "sl-SI"
+          end
+        end
+        return name
+      end
+
+      #####################################################
+      # @!group Documentation
+      #####################################################
+
+      def self.description
+        "Upload metadata to lokalise."
+      end
+
+      def self.details
+        "This action scans fastlane/metadata folder and uploads metadata to lokalise.com"
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :api_token,
+                                       env_name: "LOKALISE_API_TOKEN",
+                                       description: "API Token for Lokalise",
+                                       verify_block: proc do |value|
+                                          UI.user_error! "No API token for Lokalise given, pass using `api_token: 'token'`" unless (value and not value.empty?)
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :project_identifier,
+                                       env_name: "LOKALISE_PROJECT_ID",
+                                       description: "Lokalise Project ID",
+                                       verify_block: proc do |value|
+                                          UI.user_error! "No Project Identifier for Lokalise given, pass using `project_identifier: 'identifier'`" unless (value and not value.empty?)
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :add_languages,
+                                       description: "Add missing languages in lokalise",
+                                       optional: true,
+                                       is_string: false,
+                                       default_value: false,
+                                       verify_block: proc do |value|
+                                         UI.user_error! "Add languages should be true or false" unless [true, false].include? value
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :override_translation,
+                                       description: "Override translations in lokalise",
+                                       optional: true,
+                                       is_string: false,
+                                       default_value: false,
+                                       verify_block: proc do |value|
+                                         UI.user_error! "Override translation should be true or false" unless [true, false].include? value
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :action,
+                                       description: "Action to perform (can be update_lokalise_itunes or update_lokalise_googleplay or update_itunes or update_googleplay)",
+                                       optional: false,
+                                       is_string: true,
+                                       verify_block: proc do |value|
+                                         UI.user_error! "Action should be update_lokalise_googleplay or update_lokalise_itunes or update_itunes or update_googleplay" unless ["update_lokalise_itunes", "update_lokalise_googleplay", "update_itunes", "update_googleplay"].include? value
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :release_number,
+                                      description: "Release number is required to update google play",
+                                      optional: true,
+                                      is_string: false),
+          FastlaneCore::ConfigItem.new(key: :validate_only,
+                                      description: "Only validate the metadata (works with only update_googleplay action)",
+                                      optional: true,
+                                      is_string: false,
+                                      default_value: false,
+                                      verify_block: proc do |value|
+                                        UI.user_error! "Validate only should be true or false" unless [true, false].include? value
+                                      end),
+        ]
+      end
+
+      def self.authors
+        ["Fedya-L"]
+      end
+
+      def self.is_supported?(platform)
+        platform == :ios
+      end
+    end
+  end
+end