station 0.0.0 → 0.0.100

data/lib/nexmo_developer/app/services/email_validator.rb

@@ -0,0 +1,6 @@
+class EmailValidator
+  def self.valid?(email)
+    regex = /\A[\w+\-.]+@[a-z\d\-]+(\.[a-z\d\-]+)*\.[a-z]+\z/i
+    regex.match? email
+  end
+end

data/lib/nexmo_developer/app/services/feedback_slack_notifier.rb

@@ -0,0 +1,141 @@
+class FeedbackSlackNotifier
+  def self.call(feedback)
+    new(feedback).notify!
+  end
+
+  def initialize(feedback)
+    @feedback = feedback
+    @notifier = Slack::Notifier.new ENV['SLACK_WEBHOOK'], username: 'feedbot'
+  end
+
+  def emoji
+    case @feedback.sentiment
+    when 'negative' then ':-1:'
+    when 'positive' then ':+1:'
+    else ':neutral_face:'
+    end
+  end
+
+  def slack_color
+    case @feedback.sentiment
+    when 'negative' then 'danger'
+    when 'positive' then 'good'
+    else '#ccc'
+    end
+  end
+
+  def admin_url
+    "#{ENV['FEEDBOT_PROTOCOL']}://#{ENV['FEEDBOT_HOST']}/admin/feedbacks/#{@feedback.id}"
+  end
+
+  def state
+    @feedback.created_at == @feedback.updated_at ? 'New' : 'Updated'
+  end
+
+  def params
+    @params ||= begin
+      options = {
+        channel: '#documentation-feedbot-comments',
+        attachments: [
+          {
+            title: "#{emoji} #{state} #{@feedback.sentiment.upcase_first} feedback",
+            title_link: admin_url,
+            text: '-',
+            color: slack_color,
+            fields: [
+              {
+                title: ':link: URL',
+                value: @feedback.resource.uri,
+              },
+              {
+                title: ':hammer_and_wrench: Nexmo Developer Admin Link',
+                value: admin_url,
+              },
+            ],
+          },
+        ],
+      }
+
+      if @feedback.owner.email
+        options[:attachments][0][:fields] << {
+          title: ':bust_in_silhouette: Author',
+          value: @feedback.owner.email,
+        }
+      end
+
+      options[:attachments][0][:fields] << {
+        title: ':speech_balloon: Feedback',
+        value: body,
+      }
+
+      if @feedback.code_language
+        options[:attachments][0][:fields] << {
+          title: ':computer: Code Language',
+          value: @feedback.code_language,
+        }
+      end
+
+      options
+    end
+  end
+
+  def notify!
+    @notifier.post params
+  end
+
+  def body
+    <<~HEREDOC
+      #{@feedback.config.title}
+
+      *Paths:*
+      #{paths.map { |p| "\t#{p}" }.join("\n")}
+
+      *Answers:*
+      #{answers.map { |a| "\t#{a}" }.join("\n")}
+    HEREDOC
+  end
+
+  def paths
+    @paths ||= @feedback.config.paths.map.with_index do |path, path_index|
+      if @feedback.path == path_index
+        "*#{path['question']}*"
+      else
+        path['question']
+      end
+    end
+  end
+
+  def answers
+    @answers ||= @feedback.config.paths[@feedback.path]['steps'].map.with_index do |step, index|
+      case step['type']
+      when 'textarea'
+        <<~HEREDOC
+          *#{step['label'] || step['title']}*
+          \t\t#{@feedback.steps[index]}
+        HEREDOC
+      when 'plain'
+        "*#{step['title']}*"
+      when 'radiogroup'
+        options = step['questions'].map.with_index do |question, question_index|
+          if question_index == @feedback.steps[index]
+            "*#{question}*"
+          else
+            "#{question}"
+          end
+        end
+        <<~HEREDOC
+          *#{step['title']}*
+          #{options.map { |o| "\t\t#{o}" }.join("\n")}
+        HEREDOC
+      when 'fieldset'
+        fields = step['fields'].map.with_index do |field, _field_index|
+          "*#{field['label']}:* #{@feedback.steps[index][field['name']]}"
+        end
+        <<~HEREDOC
+          *#{step['title']}*
+          #{fields.map { |f| "\t\t#{f}" }.join("\n")}
+        HEREDOC
+      end
+    end
+  end
+end

data/lib/nexmo_developer/app/services/greenhouse.rb

@@ -0,0 +1,45 @@
+class Greenhouse
+  DEPARTMENT_ID = 4019731002
+  TITLES = ['sdk', 'advocate', 'community manager', 'education', 'dashboard', 'documentation'].freeze
+
+  def self.devrel_careers
+    new.devrel_positions
+  end
+
+  def self.careers
+    new.jobs
+  end
+
+  def self.offices
+    new.offices
+  end
+
+  def self.expire_cache
+    Rails.cache.delete('careers')
+    Rails.cache.delete('offices')
+  end
+
+  def initialize
+    @client = GreenhouseIo::JobBoard.new
+  end
+
+  def devrel_positions
+    @devrel_positions ||= jobs.select(&:devrel?)
+  end
+
+  def jobs
+    @jobs ||= Rails.cache.fetch('careers', expires_in: 1.hour) do
+      fetch_jobs.map { |j| Career.new(j) }
+    end
+  end
+
+  def offices
+    @offices ||= Rails.cache.fetch('offices', expires_in: 5.hours) do
+      @client.offices[:offices]
+    end
+  end
+
+  def fetch_jobs
+    @client.jobs(content: 'true')[:jobs]
+  end
+end

data/lib/nexmo_developer/app/services/load_config.rb

@@ -0,0 +1,14 @@
+class LoadConfig
+  def self.docs_base_path
+    Rails.configuration.docs_base_path || '.'
+  end
+
+  def self.load_file(file_path)
+    full_path = "#{docs_base_path}/#{file_path}"
+    if File.exist?(full_path)
+      YAML.load_file(full_path)
+    else
+      YAML.load_file("#{Rails.root}/#{file_path}")
+    end
+  end
+end

data/lib/nexmo_developer/app/services/locale_redirector.rb

@@ -0,0 +1,29 @@
+class LocaleRedirector
+  def initialize(request, params)
+    @request = request
+    @params  = params
+  end
+
+  def path
+    if add_locale?
+      "/#{@params[:preferred_locale]}#{current_path}"
+    else
+      current_path
+    end
+  end
+
+  def current_path
+    @request
+      .referrer
+      .sub(@request.protocol, '')
+      .sub(@request.host_with_port, '')
+      .sub(%r{/\w{2}/}, '/')
+      .gsub(/\?.*/, '')
+  end
+
+  def add_locale?
+    @params[:preferred_locale] != I18n.default_locale.to_s &&
+      (DocumentationConstraint.product_with_parent_list.any? { |path| current_path.include?(path) } ||
+       ['tutorials', 'use-cases'].any? { |path| current_path.include?(path) })
+  end
+end

data/lib/nexmo_developer/app/services/not_found_notifier.rb

@@ -0,0 +1,34 @@
+IGNORED_FORMATS = %w[php action swf].freeze
+
+class NotFoundNotifier
+  def self.notify(request, exception)
+    return if ignored_format?(request.params['format'])
+    return if crawler?(request.user_agent)
+
+    Bugsnag.notify(notification_name(exception)) do |notification|
+      notification.add_tab(:request, {
+        params: request.params,
+        path: request.path,
+        base_url: request.base_url,
+      })
+    end
+  end
+
+  def self.ignored_format?(format)
+    return false unless format
+
+    IGNORED_FORMATS.include? format.downcase
+  end
+
+  def self.crawler?(user_agent)
+    Woothee.parse(user_agent)[:category] == :crawler
+  end
+
+  def self.notification_name(exception)
+    if exception.instance_of? Nexmo::Markdown::DocFinder::MissingDoc
+      'Missing Document'
+    else
+      '404 - Not Found'
+    end
+  end
+end

data/lib/nexmo_developer/app/services/open_api_definition_resolver.rb

@@ -0,0 +1,25 @@
+class OpenApiDefinitionResolver
+  def self.find(name)
+    path = paths(name).detect do |p|
+      break p if File.file? p
+    end
+
+    return resolve(path) if path
+
+    raise "Could not find definition '#{name}'"
+  end
+
+  def self.paths(name)
+    ['json', 'yaml', 'yml'].map do |format|
+      path(name, format)
+    end
+  end
+
+  def self.path(name, format)
+    "#{Rails.configuration.docs_base_path}/_open_api/api_specs/definitions/#{name}.#{format}"
+  end
+
+  def self.resolve(path)
+    OasParser::Definition.resolve(path)
+  end
+end

data/lib/nexmo_developer/app/services/redirector.rb

@@ -0,0 +1,33 @@
+CORE_REDIRECTS = LoadConfig.load_file('config/redirects.yml') || {}
+STITCH_REDIRECTS = LoadConfig.load_file('config/stitch-redirects.yml') || {}
+
+REDIRECTS = CORE_REDIRECTS.merge(STITCH_REDIRECTS)
+
+ENVIRONMENT_REDIRECTS = YAML.safe_load(ENV['ENVIRONMENT_REDIRECTS'] || '')
+
+class Redirector
+  def self.find(request)
+    url = find_by_config(request) || find_by_environment_redirect(request) # rubocop:disable Rails/DynamicFindBy
+    return unless url
+
+    url
+  end
+
+  def self.find_by_config(request)
+    REDIRECTS[strip_locale_from_path(request.path)] || false
+  end
+
+  def self.find_by_environment_redirect(request)
+    return false unless ENVIRONMENT_REDIRECTS
+
+    ENVIRONMENT_REDIRECTS.each do |path, new_url|
+      return new_url if Regexp.new(path).match(strip_locale_from_path(request.path))
+    end
+
+    false
+  end
+
+  def self.strip_locale_from_path(path)
+    path.sub("/#{I18n.locale}", '')
+  end
+end

data/lib/nexmo_developer/app/services/search/article.rb

@@ -0,0 +1,39 @@
+module Search
+  class Article
+    delegate :config, :title, :description, :body, :path, :doc_type, to: :@doc
+
+    def initialize(doc, html)
+      @doc  = doc
+      @html = html
+    end
+
+    def relative_path
+      @relative_path ||= "#{config[:base_url_path]}/#{path.relative_path_from(config[:origin])}".gsub('.md', '')
+    end
+
+    def product
+      @product ||= begin
+        product = relative_path.split('/')[1]
+        if product == 'messaging'
+          "#{relative_path.split('/')[1]} > #{relative_path.split('/')[2]}"
+        else
+          product
+        end
+      end
+    end
+
+    def to_h
+      {
+        title: title,
+        heading: @html.css('body').children[0].text.strip,
+        anchor: @html.css('body').children[0].text.parameterize,
+        description: description,
+        document_class: doc_type,
+        path: relative_path,
+        document_path: path,
+        body: @html.text,
+        product: product,
+      }
+    end
+  end
+end

data/lib/nexmo_developer/app/services/search/document.rb

@@ -0,0 +1,37 @@
+module Search
+  class Document
+    attr_reader :doc_type, :config, :path
+
+    def initialize(doc_type, config, path)
+      @doc_type = doc_type
+      @config   = config
+      @path     = Pathname.new(path)
+    end
+
+    def articles
+      @articles ||= Nokogiri::HTML(body).split_html.map do |section_html|
+        Search::Article.new(self, section_html)
+      end
+    end
+
+    def document
+      @document ||= File.read(@path)
+    end
+
+    def frontmatter
+      @frontmatter ||= YAML.safe_load(document)
+    end
+
+    def title
+      @title ||= frontmatter['title']
+    end
+
+    def description
+      @description ||= frontmatter['description']
+    end
+
+    def body
+      @body ||= Nexmo::Markdown::Renderer.new.call(document)
+    end
+  end
+end

data/lib/nexmo_developer/app/services/search_terms.rb

@@ -0,0 +1,27 @@
+class SearchTerms
+  def self.generate(locale = I18n.default_locale)
+    document_paths = {
+      documentation: {
+        documents: Dir.glob("#{Rails.configuration.docs_base_path}/_documentation/#{locale}/**/*.md"),
+        origin: Pathname.new("#{Rails.configuration.docs_base_path}/_documentation/#{locale}"),
+        base_url_path: '',
+      },
+      api: {
+        documents: Dir.glob("#{Rails.configuration.docs_base_path}/_api/**/*.md"),
+        origin: Pathname.new("#{Rails.configuration.docs_base_path}/_api"),
+        base_url_path: '/api',
+      },
+      use_cases: {
+        documents: Dir.glob("#{Rails.configuration.docs_base_path}/_use_cases/#{locale}/**/*.md"),
+        origin: Pathname.new("#{Rails.configuration.docs_base_path}/_use_cases/#{locale}"),
+        base_url_path: '/use-cases',
+      },
+    }
+
+    document_paths.map do |document_class, config|
+      config[:documents].map do |document_path|
+        Search::Document.new(document_class, config, document_path).articles.map(&:to_h)
+      end
+    end.flatten
+  end
+end

data/lib/nexmo_developer/app/services/smartling_api.rb

@@ -0,0 +1,72 @@
+class SmartlingAPI
+  include ::Translator::Utils
+
+  def initialize(user_id:, user_secret:, project_id:)
+    @client = Smartling::File.new(
+      userId: user_id,
+      userSecret: user_secret,
+      projectId: project_id
+    )
+  end
+
+  def upload(filename)
+    file_uri = file_uri(filename)
+    file = Tempfile.new
+    file.write Nexmo::Markdown::Pipelines::Smartling::Preprocessor.new.call(
+      File.read("#{Rails.configuration.docs_base_path}/#{filename}")
+    )
+    file.rewind
+
+    wrap_in_rescue do
+      @client.upload(
+        file.path,
+        file_uri,
+        file_type(filename),
+        'smartling.markdown_code_notranslate': true
+      )
+    end
+  ensure
+    file.close
+    file.unlink
+  end
+
+  def file_type(filename)
+    case Pathname.new(filename).extname
+    when '.md', '.markdown'
+      'markdown'
+    when '.yml', '.yaml'
+      'yaml'
+    else
+      raise 'Unsupported file type.'
+    end
+  end
+
+  def last_modified(filename:, locale:)
+    file_uri = file_uri(filename)
+    wrap_in_rescue { @client.last_modified(file_uri, locale) }
+  end
+
+  def download_translated(filename:, locale:, type: :published)
+    file_uri = file_uri(filename)
+    wrap_in_rescue do
+      response = @client.download_translated(file_uri, locale, retrievalType: type)
+
+      locale = locale_without_region(locale.to_s)
+      folder = storage_folder(filename, locale)
+      FileUtils.mkdir_p(folder) unless File.exist?(folder)
+      File.open(file_path(filename, locale), 'w+') do |file|
+        file.write(Nexmo::Markdown::Pipelines::Smartling::Download.call(response))
+      end
+    end
+  end
+
+  private
+
+  def wrap_in_rescue
+    yield
+  rescue StandardError => e
+    p e.message # rubocop:disable Rails/Output
+    Bugsnag.notify(e)
+    Rails.logger.error(e.message)
+  end
+end