ETLane 0.1.42 → 0.1.46

data/Lanes/actions/lokalise_upload.rb

@@ -0,0 +1,165 @@
+require 'base64'
+
+module Fastlane
+  module Actions
+    class LokaliseUploadAction < Action
+      def self.run(params)
+        
+        self.snapshot(params)
+        sources = params[:sources]
+        languages = params[:languages]
+        accepted_formats = [".strings", ".stringsdict"]
+        for source in sources do
+          Dir.chdir(source) do
+            Dir.glob('*').select { |f| File.directory? f
+              for lang in languages
+                folder = "#{lang}.lproj"
+                if f == folder
+                  Dir.chdir(folder) do 
+                    Dir.glob('*').select { |f| accepted_formats.include? File.extname(f)
+                      upload_name = File.join(source, folder, f)
+                      File.open(f, 'rb') do |img|
+                        base64 = Base64.strict_encode64(img.read)
+                        upload(lang, upload_name, base64, params)
+                      end
+                    }
+                  end
+                end
+              end
+              
+            }
+          end
+        end
+
+
+        # 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} 📗 📕 📘"
+        #   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.snapshot(params)
+        require 'net/http'
+        project_identifier = params[:project_identifier]
+        uri = URI("https://api.lokalise.com/api2/projects/#{project_identifier}/snapshots")
+        request_data = {
+          title: params[:snapshot_version],
+        }
+        request = Net::HTTP::Post.new(uri)
+        request.body = request_data.to_json
+        request['X-Api-Token'] = params[:api_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
+      end
+
+      def self.upload(lang, name, data, params)
+        require 'net/http'
+        token = params[:api_token]
+        project_identifier = params[:project_identifier]
+        if lang == "es-419"
+          lang = "es_419"
+        end
+        puts "Lang: #{lang} #{name}"
+        request_data = {
+          filename: name,
+          data: data,
+          lang_iso: lang,
+          cleanup_mode: true,
+        }
+        uri = URI("https://api.lokalise.com/api2/projects/#{project_identifier}/files/upload")
+        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
+
+      end
+
+      #####################################################
+      # @!group Documentation
+      #####################################################
+
+      def self.description
+        "Upload 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: :snapshot_version,
+                                       env_name: "LOKALISE_SNAPSHOT_VERSION",
+                                       description: "snapshot version 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: :sources,
+                                       description: "Localization sources",
+                                       is_string: false,
+                                       verify_block: proc do |value|
+                                          UI.user_error! "Tags should be passed as array" unless value.kind_of? Array
+                                       end),
+            FastlaneCore::ConfigItem.new(key: :languages,
+                                        description: "Include only the languages",
+                                        optional: true,
+                                        is_string: false,
+                                        default_value: ["en"],
+                                        verify_block: proc do |value|
+                                          UI.user_error! "Tags should be passed as array" unless value.kind_of? Array
+                                        end),
+
+        ]
+      end
+
+      def self.authors
+        "teanet"
+      end
+
+      def self.is_supported?(platform)
+        [:ios, :mac].include? platform 
+      end
+    end
+  end
+end

data/Lanes/actions/previews.rb

@@ -0,0 +1,157 @@
+require 'credentials_manager/account_manager'
+require 'fastlane_core/itunes_transporter'
+require 'rexml/document'
+        # a = CredentialsManager::AccountManager.new(user: user, prefix: "deliver.appspecific", note: "application-specific")
+        # @password = a.password(ask_if_missing: true) # to ask the user for the missing value
+
+module Fastlane
+  module Actions
+    class PreviewsAction < Action
+      def self.run(params)
+        user = params[:username]
+        product_bundle_identifier = CredentialsManager::AppfileConfig.try_fetch_value(:app_identifier)
+        spaceship = Spaceship::Tunes.login(user)
+        spaceship.team_id = CredentialsManager::AppfileConfig.try_fetch_value(:itc_team_id)
+        app = Spaceship::Tunes::Application.find(product_bundle_identifier)
+        app_id = app.apple_id()
+        transporter = FastlaneCore::ItunesTransporter.new(user)
+        destination = "/tmp"
+        itmsp_path = File.join(destination, "#{app_id}.itmsp")
+        transporter.download(app_id, destination)
+        patch_itmsp(itmsp_path)
+        transporter.upload(app_id, destination)
+      end
+
+      def self.patch_itmsp(itmsp_path)
+        metadata_path = File.join(itmsp_path, "metadata.xml")
+        doc = REXML::Document.new(File.read(metadata_path))
+        current_version = doc.root.elements["software/software_metadata/versions[1]/version"]
+
+        software_metadata = doc.root.elements["software/software_metadata"]
+        software_metadata.elements.delete("products")
+        software_metadata.elements.delete("in_app_purchases")
+        versions = doc.root.elements["software/software_metadata/versions"]
+
+        old_version = versions.elements[2]
+        if old_version
+          puts "Romove old version"
+          versions.elements.delete(old_version)
+        end
+
+        build_folder = File.join(Dir.pwd, "build")
+        preview_path = File.join(build_folder, "previews")
+
+        current_version.elements.each("locales/locale") do |element| 
+
+          element.elements.delete("app_previews")
+          element.elements.delete("software_screenshots")
+          element.elements.delete("title")
+          element.elements.delete("subtitle")
+          element.elements.delete("description")
+          element.elements.delete("version_whats_new")
+          element.elements.delete("privacy_url")
+          element.elements.delete("support_url")
+          element.elements.delete("keywords")
+
+          locale = element.attributes["name"]
+          locale_path = File.join(preview_path, locale)
+          # если нет папки с локалью, значит удаляем видео
+          app_previews = REXML::Element.new('app_previews')
+          if File.directory?(locale_path)
+            locale_files = Dir.entries(locale_path).select {|f| not File.directory?(f) }
+
+            timestamp = "00:00:08:00"
+            for file in locale_files do
+              if file == "timestamp.txt"
+                timestamp = File.read(File.join(locale_path, file))
+              end
+            end
+            for file in locale_files do
+              video_path = File.join(locale_path, file)
+              if File.extname(file).downcase == ".mp4"
+                size = File.size(video_path)
+                if size > 500000
+                  app_preview = generate_app_preview(itmsp_path, locale, video_path, timestamp)
+                  app_previews.elements.add(app_preview)
+                else
+                  puts "#{video_path} too small, #{size}b"
+                end
+              end
+            end
+          end
+          element.elements.add(app_previews)
+        end  
+        formatter = REXML::Formatters::Pretty.new
+        formatter.compact = true
+        formatter.width = 9999
+        File.open(metadata_path,"w"){|file| file.puts formatter.write(doc.root,"")}
+      end
+
+      def self.generate_app_preview(itmsp_path, locale, video_path, timestamp)
+        file = last = File.basename(video_path)
+        file_with_locale = "#{locale}_#{file}"
+        itmsp_video_path = File.join(itmsp_path, file_with_locale)
+        FileUtils.cp(video_path, itmsp_video_path)
+        file_name = File.basename(file, File.extname(file))
+
+        app_preview = REXML::Element.new('app_preview')
+        app_preview.add_attribute(REXML::Attribute.new('display_target', file_name))
+        app_preview.add_attribute(REXML::Attribute.new('position', '1'))
+
+        data_file = REXML::Element.new('data_file')
+        data_file.add_attribute(REXML::Attribute.new('role', 'source'))
+
+        size_node = REXML::Element.new('size')
+        size = File.size(video_path)
+        size_node.add_text("#{size}")
+        data_file.elements.add(size_node)
+
+        file_name_node = REXML::Element.new('file_name')
+        file_name_node.add_text(file_with_locale)
+        data_file.elements.add(file_name_node)
+
+        checksum = REXML::Element.new('checksum')
+        checksum.add_text(Digest::MD5.file(video_path).hexdigest)
+        data_file.elements.add(checksum)
+
+        app_preview.elements.add(data_file)
+
+        preview_image_time = REXML::Element.new('preview_image_time')
+        preview_image_time.add_attribute(REXML::Attribute.new('format', "30/1:1/nonDrop"))
+        preview_image_time.add_text(timestamp)
+        app_preview.elements.add(preview_image_time)
+
+        app_preview
+      end
+
+      #####################################################
+      # @!group Documentation
+      #####################################################
+
+      def self.description
+        "Download Lokalise localization"
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(
+            key: :username,
+            env_name: "PREVIEW_USER_NAME",
+            description: "User",
+            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
+          ),
+        ]
+      end
+
+      def self.authors
+        "teanet"
+      end
+
+      def self.is_supported?(platform)
+        [:ios].include? platform 
+      end
+    end
+  end
+end

data/Scripts/Sources/Common/Api.swift

@@ -0,0 +1,142 @@
+import Foundation
+
+public final class Api {
+
+	public struct NoContent: Decodable {
+		init() {}
+	}
+
+	public enum ApiError: Error {
+		case nilDataError
+		case pathError
+		case repeatCountLimitReached
+	}
+
+	enum Method: String {
+		case get = "GET"
+		case post = "POST"
+		case put = "PUT"
+	}
+
+	private let session = URLSession(configuration: URLSessionConfiguration.default)
+	private let baseURL: URL
+
+	public init(baseURL: String) {
+		self.baseURL = URL(string: baseURL)!
+	}
+
+	public func get<T: Codable>(
+		path: String,
+		query: [String: String] = [:],
+		headers: [String: String] = [:],
+		timeoutInterval: TimeInterval
+	) throws -> T {
+		return try self.method(.get, path: path, query: query, headers: headers, timeoutInterval: timeoutInterval)
+	}
+
+	public func post<T: Codable, TBody: Encodable>(
+		path: String,
+		body: TBody,
+		query: [String: String] = [:],
+		headers: [String: String] = [:],
+		timeoutInterval: TimeInterval
+	) throws -> T {
+		let body = try JSONEncoder().encode(body)
+		return try self.method(.post, path: path, query: query, headers: headers, timeoutInterval: timeoutInterval, body: body)
+	}
+
+	private func get<T: Codable>(path: String, completion: @escaping (Result<T, Error>) -> Void) {
+		self.method(.get, path: path, completion: completion)
+	}
+
+	private func post<T: Codable, TBody: Encodable>(
+		path: String,
+		body: TBody, headers: [String: String] = [:],
+		completion: @escaping (Result<T, Error>) -> Void
+	) {
+		let body = try? JSONEncoder().encode(body)
+		self.method(.post, path: path, headers: headers, body: body, completion: completion)
+	}
+
+	private func method<T: Decodable>(
+		_ method: Method,
+		path: String,
+		query: [String: String] = [:],
+		headers: [String: String] = [:],
+		timeoutInterval: TimeInterval,
+		body: Data? = nil
+	) throws -> T {
+		let s = DispatchSemaphore(value: 0)
+		var statsResponse: Result<T, Error>!
+		let completion: (Result<T, Error>) -> Void = { result in
+			statsResponse = result
+			s.signal()
+		}
+		self.method(
+			method,
+			path: path,
+			query: query,
+			headers: headers,
+			body: body,
+			timeoutInterval: timeoutInterval,
+			completion: completion
+		)
+		s.wait()
+		return try statsResponse.get()
+	}
+
+	private func method<T: Decodable>(
+		_ method: Method,
+		path: String,
+		query: [String: String] = [:],
+		headers: [String: String] = [:],
+		body: Data? = nil,
+		timeoutInterval: TimeInterval = 60,
+		completion: @escaping (Result<T, Error>) -> Void
+	) {
+		let baseURL = self.baseURL.appendingPathComponent(path)
+		var cmp = URLComponents(url: baseURL, resolvingAgainstBaseURL: false)
+		cmp?.queryItems = query.map { URLQueryItem(name: $0.key, value: $0.value) }
+		guard let url = cmp?.url else { completion(.failure(ApiError.pathError)); return }
+		var request = URLRequest(url: url)
+		request.timeoutInterval = timeoutInterval
+		request.httpBody = body
+		request.httpMethod = method.rawValue
+		var allHTTPHeaderFields = headers
+		if headers["content-type"] == nil {
+			allHTTPHeaderFields["content-type"] = "application/json"
+		}
+		request.allHTTPHeaderFields = allHTTPHeaderFields
+		print("Start request: \(method.rawValue) \(url)")
+		self.session.dataTask(with: request) { (data, _, error) in
+
+			if let error = error {
+				completion(.failure(error))
+				return
+			}
+			guard let data = data else {
+				completion(.failure(ApiError.nilDataError))
+				return
+			}
+			if data.isEmpty, let noContent = NoContent() as? T {
+				completion(.success(noContent))
+				return
+			}
+
+			if let string = String(data: data, encoding: .utf8)?.prefix(3000) {
+				print("Finish: \(string)...")
+			} else {
+				print("Finish")
+			}
+
+			do {
+				let response = try JSONDecoder().decode(T.self, from: data)
+				completion(.success(response))
+			} catch {
+				print("Decode response \(url) error: \(error)")
+				completion(.failure(error))
+			}
+		}.resume()
+	}
+
+}