txbr 1.0.0

data/lib/txbr/braze_api.rb

@@ -0,0 +1,42 @@
+require 'faraday'
+require 'faraday_middleware'
+
+module Txbr
+  class BrazeApi
+    include RequestMethods
+
+    attr_reader :api_key, :api_url
+
+    def initialize(api_key, api_url)
+      @api_key = api_key
+      @api_url = api_url
+    end
+
+    def each_email_template
+      raise NotImplementedError, 'Braze does not support this operation yet'
+    end
+
+    def get_email_template_details(email_template_id:)
+      raise NotImplementedError, 'Braze does not support this operation yet'
+    end
+
+    private
+
+    def connection
+      @connection ||= begin
+        options = {
+          url: api_url,
+          params: { api_key: api_key },
+          headers: { Accept: 'application/json' }
+        }
+
+        Faraday.new(options) do |faraday|
+          faraday.request(:json)
+          faraday.response(:logger)
+          faraday.use(FaradayMiddleware::FollowRedirects)
+          faraday.adapter(:net_http)
+        end
+      end
+    end
+  end
+end

data/lib/txbr/braze_session.rb

@@ -0,0 +1,39 @@
+require 'cgi'
+require 'mechanize'
+
+module Txbr
+  class BrazeSession
+    attr_reader :api_url, :email_address, :password
+
+    def initialize(api_url, email_address, password)
+      @api_url = api_url
+      @email_address = email_address
+      @password = password
+
+      reset!
+    end
+
+    def session_id
+      @session_id ||= begin
+        agent = Mechanize.new
+        url = Txbr::Utils.url_join(api_url, "auth?email=#{CGI.escape(email_address)}")
+
+        agent.get(url) do |page|
+          page.form_with(id: 'developer_signin').tap do |form|
+            form['developer[password]'] = password
+            form.submit
+          end
+        end
+
+        agent
+          .cookies
+          .find { |cookie| cookie.name == '_session_id' }
+          .value
+      end
+    end
+
+    def reset!
+      @session_id = nil
+    end
+  end
+end

data/lib/txbr/braze_session_api.rb

@@ -0,0 +1,73 @@
+require 'faraday'
+require 'faraday_middleware'
+
+module Txbr
+  class BrazeSessionApi
+    EMAIL_TEMPLATE_BATCH_SIZE = 35
+
+    include RequestMethods
+
+    attr_reader :session, :app_group_id
+
+    def initialize(session, app_group_id, connection: nil)
+      @session = session
+      @app_group_id = app_group_id
+      @connection = connection
+    end
+
+    def each_email_template(start: 0, &block)
+      return to_enum(__method__, start: start) unless block_given?
+
+      loop do
+        templates = get_json(
+          'engagement/email_templates',
+          start: start,
+          limit: EMAIL_TEMPLATE_BATCH_SIZE
+        )
+
+        templates['results'].each(&block)
+        start += templates['results'].size
+        break if templates['results'].size < EMAIL_TEMPLATE_BATCH_SIZE
+      end
+    end
+
+    def get_email_template_details(email_template_id:)
+      get_json("engagement/email_templates/#{email_template_id}")
+    end
+
+    private
+
+    def act(*args)
+      retried = false
+
+      begin
+        super(*args, { cookie: "_session_id=#{session.session_id}" })
+      rescue BrazeUnauthorizedError => e
+        raise e if retried
+        reset!
+        retried = true
+        retry
+      end
+    end
+
+    def reset!
+      session.reset!
+    end
+
+    def connection
+      @connection ||= begin
+        options = {
+          url: session.api_url,
+          params: { app_group_id: app_group_id }
+        }
+
+        Faraday.new(options) do |faraday|
+          faraday.request(:json)
+          faraday.response(:logger)
+          faraday.use(FaradayMiddleware::FollowRedirects)
+          faraday.adapter(:net_http)
+        end
+      end
+    end
+  end
+end

data/lib/txbr/commands.rb

@@ -0,0 +1,14 @@
+module Txbr
+  module Commands
+    def self.upload_all
+      Txbr::Config.projects.each do |project|
+        begin
+          Txbr::Uploader.new(project).upload_all
+        rescue => e
+          puts "An error occurred: #{e.message}"
+          puts e.backtrace
+        end
+      end
+    end
+  end
+end

data/lib/txbr/config.rb

@@ -0,0 +1,57 @@
+require 'yaml'
+
+module Txbr
+  class Config
+    class << self
+      def projects
+        @projects ||= raw_config[:projects].map do |conf|
+          Project.new(conf)
+        end
+      end
+
+      def transifex_api_username
+        raw_config[:transifex_api_username]
+      end
+
+      def transifex_api_password
+        raw_config[:transifex_api_password]
+      end
+
+      private
+
+      def raw_config
+        @raw_config ||= begin
+          scheme_end_idx = ENV['TXBR_CONFIG'].index('://')
+          scheme = ENV['TXBR_CONFIG'][0...scheme_end_idx]
+          payload = ENV['TXBR_CONFIG'][(scheme_end_idx + 3)..-1]
+          send(:"load_#{scheme}", payload)
+        end
+      end
+
+      def load_file(payload)
+        deep_symbolize_keys(YAML.load_file(payload))
+      end
+
+      def load_raw(payload)
+        deep_symbolize_keys(YAML.load(payload))
+      end
+
+      def deep_symbolize_keys(obj)
+        case obj
+          when Hash
+            obj.each_with_object({}) do |(k, v), ret|
+              ret[k.to_sym] = deep_symbolize_keys(v)
+            end
+
+          when Array
+            obj.map do |elem|
+              deep_symbolize_keys(elem)
+            end
+
+          else
+            obj
+        end
+      end
+    end
+  end
+end

data/lib/txbr/email_template.rb

@@ -0,0 +1,70 @@
+require 'liquid'
+
+module Txbr
+  class EmailTemplate
+    attr_reader :project, :email_template_id
+
+    def initialize(project, email_template_id)
+      @project = project
+      @email_template_id = email_template_id
+    end
+
+    def each_resource
+      return to_enum(__method__) unless block_given?
+
+      strings_map.each_pair do |project_slug, resource_map|
+        resource_map.each_pair do |resource_slug, strings_manifest|
+          phrases = strings_manifest.each_string
+            .reject { |_, value| value.nil? }
+            .map do |path, value|
+              { 'key' => path.join('.'), 'string' => value }
+            end
+
+          next if phrases.empty?
+
+          resource = Txgh::TxResource.new(
+            project_slug,
+            resource_slug,
+            project.strings_format,
+            project.source_lang,
+            template_name,
+            {},   # lang_map (none)
+            nil   # translation_file (none)
+          )
+
+          yield Txgh::ResourceContents.from_phrase_list(resource, phrases)
+        end
+      end
+    end
+
+    private
+
+    def strings_map
+      @strings_map ||= %w(template subject preheader).each_with_object({}) do |name, ret|
+        component = EmailTemplateComponent.new(
+          Liquid::Template.parse(details[name])
+        )
+
+        next unless component.assignments['project_slug']
+        next unless component.assignments['resource_slug']
+        next unless component.translation_enabled?
+
+        (ret[component.project_slug] ||= {}).tap do |proj_map|
+          (proj_map[component.resource_slug] ||= StringsManifest.new).tap do |manifest|
+            manifest.merge!(component.strings)
+          end
+        end
+      end
+    end
+
+    def template_name
+      details['name']
+    end
+
+    def details
+      @details ||= project.braze_api.get_email_template_details(
+        email_template_id: email_template_id
+      )
+    end
+  end
+end

data/lib/txbr/email_template_component.rb

@@ -0,0 +1,94 @@
+module Txbr
+  class EmailTemplateComponent
+    ASSIGNMENTS = %w(project_slug resource_slug translation_enabled)
+
+    attr_reader :liquid_template
+
+    def initialize(liquid_template)
+      @liquid_template = liquid_template
+    end
+
+    def project_slug
+      # blow up with KeyError if not found
+      assignments.fetch('project_slug')
+    end
+
+    def resource_slug
+      # blow up with KeyError if not found
+      assignments.fetch('resource_slug')
+    end
+
+    def translation_enabled?
+      # translation is disabled by default
+      assignments.fetch('translation_enabled', true)
+    end
+
+    def assignments
+      @assignments ||= {}.tap do |assgn|
+        liquid_template.root.nodelist.each do |node|
+          case node
+            when Liquid::Assign
+              to = node.instance_variable_get(:@to)
+
+              if ASSIGNMENTS.include?(to)
+                from = node.instance_variable_get(:@from).name
+                assgn[to] = from
+              end
+          end
+        end
+      end
+    end
+
+    def strings
+      @strings ||= StringsManifest.new.tap do |manifest|
+        extract_strings_from(liquid_template.root, manifest)
+      end
+    end
+
+    private
+
+    def extract_strings_from(root, manifest)
+      return unless root.nodelist
+
+      root.nodelist.each do |node|
+        case node
+          # We only care about Liquid variables, which are written
+          # like {{prefix.foo.bar}}. We identify the prefix (i.e.
+          # the first lookup, or path segment) to verify it's
+          # associated with a connected_content call. Then we add
+          # the prefix and the rest of the lookups to the strings
+          # manifest along with the value. The prefix is used to
+          # divide the strings into individual Transifex resources
+          # while the rest of the lookups form the string's key.
+          when Liquid::Variable
+            prefix = node.name.name
+            path = node.name.lookups
+
+            # the English translation (or whatever language your
+            # source strings are written in) is provided using
+            # Liquid's built-in "default" filter
+            next unless connected_content_prefixes.include?(prefix)
+            default = node.filters.find { |f| f.first == 'default' }
+
+            manifest.add(path, default&.last&.first)
+        end
+
+        if node.respond_to?(:nodelist)
+          extract_strings_from(node, manifest)
+        end
+      end
+    end
+
+    def connected_content_prefixes
+      @connected_content_prefixes ||= connected_content_tags.map(&:prefix)
+    end
+
+    def connected_content_tags
+      # this assumes these are basically at the top of the template and not
+      # nested inside other liquid tags
+      @connected_content_tags ||= liquid_template.root.nodelist.select do |node|
+        node.is_a?(Txbr::ConnectedContentTag)
+      end
+    end
+  end
+end

data/lib/txbr/email_template_handler.rb

@@ -0,0 +1,24 @@
+module Txbr
+  class EmailTemplateHandler
+    attr_reader :project
+
+    def initialize(project)
+      @project = project
+    end
+
+    def each_resource(&block)
+      return to_enum(__method__) unless block_given?
+      each_template { |tmpl| tmpl.each_resource(&block) }
+    end
+
+    private
+
+    def each_template
+      return to_enum(__method__) unless block_given?
+
+      project.braze_api.each_email_template do |tmpl|
+        yield EmailTemplate.new(project, tmpl['id'])
+      end
+    end
+  end
+end

data/lib/txbr/project.rb

@@ -0,0 +1,50 @@
+require 'txgh'
+
+module Txbr
+  class Project
+    attr_reader :braze_api_url, :braze_api_key, :handler_id
+    attr_reader :strings_format, :source_lang
+
+    # @TODO: remove these when Braze gives us the endpoints we asked for
+    attr_reader :braze_app_group_id, :braze_email_address, :braze_password
+
+    def initialize(options = {})
+      @braze_api_url = options.fetch(:braze_api_url)
+      @braze_api_key = options.fetch(:braze_api_key)
+      @handler_id = options.fetch(:handler_id)
+      @strings_format = options.fetch(:strings_format)
+      @source_lang = options.fetch(:source_lang)
+
+      # @TODO: remove these when Braze gives us the endpoints we asked for
+      @braze_app_group_id = options.fetch(:braze_app_group_id)
+      @braze_email_address = options.fetch(:braze_email_address)
+      @braze_password = options.fetch(:braze_password)
+
+      @braze_api = options[:braze_api]
+      @transifex_api = options[:transifex_api]
+    end
+
+    def braze_session
+      @@braze_session ||= Txbr::BrazeSession.new(
+        braze_api_url, braze_email_address, braze_password
+      )
+    end
+
+    def braze_api
+      # @TODO: use BrazeApi when Braze gives us the endpoints we asked for
+      # @braze_api ||= Txbr::BrazeApi.new(braze_api_key, braze_api_url)
+      @braze_api ||= Txbr::BrazeSessionApi.new(braze_session, braze_app_group_id)
+    end
+
+    def transifex_api
+      @transifex_api ||= Txgh::TransifexApi.create_from_credentials(
+        Txbr::Config.transifex_api_username,
+        Txbr::Config.transifex_api_password
+      )
+    end
+
+    def handler
+      @handler ||= Txbr.handler_for(self)
+    end
+  end
+end