station 0.0.0 → 0.0.100

data/lib/nexmo_developer/app/controllers/feedback/feedbacks_controller.rb

@@ -0,0 +1,85 @@
+module Feedback
+  class FeedbacksController < ApplicationController
+    skip_before_action :verify_authenticity_token
+
+    def new; end
+
+    def create
+      @feedback = ::Feedback::Feedback.find_by(id: params['feedback_feedback']['id'])
+      @feedback ||= ::Feedback::Feedback.new
+
+      @feedback.assign_attributes(feedback_params)
+      @feedback.ip = request.remote_ip
+
+      @feedback.owner = owner
+      set_email
+      @feedback.owner.save!
+      set_cookies
+
+      return render json: @feedback if @feedback.save
+
+      head 422
+    end
+
+    private
+
+    def set_cookies
+      return unless @feedback.owner.instance_of?(::Feedback::Author)
+
+      cookies[:feedback_author_id] = {
+        value: @feedback.owner.id,
+        expires: 20.years.from_now,
+      }
+    end
+
+    def feedback_params
+      params.require(:feedback_feedback).permit!.slice(
+        :sentiment,
+        :source,
+        :path,
+        :feedback_config_id,
+        :steps,
+        :code_language,
+        :code_language_set_by_url,
+        :code_language_selected_whilst_on_page
+      )
+    end
+
+    def should_use_cookied_author?(author)
+      # Always use the cookied author if cookies[:feedback_author_id] is present
+      # but the author is not known by email
+      return true if author.email.nil?
+
+      # Always used the cookied author if present but no email has been provided
+      # for this request
+      return true if params['feedback_feedback']['email'].nil?
+
+      # If the cookied author is known by email, only use it if it matches the
+      # email sent in the parameters
+      return true if author.email == params['feedback_feedback']['email']
+
+      # Otherwise let's continue to try and lookup the author by email or create
+      # a new author if one can not be foundd.
+      false
+    end
+
+    def owner
+      return current_user if current_user
+
+      if cookies[:feedback_author_id]
+        author = ::Feedback::Author.find_by(id: cookies[:feedback_author_id])
+        return author if author && should_use_cookied_author?(author)
+      end
+
+      ::Feedback::Author.find_by(email: params['feedback_feedback']['email']) ||
+        ::Feedback::Author.new
+    end
+
+    def set_email
+      return if @feedback.owner.instance_of?(User)
+      return if params['feedback_feedback']['email'].blank?
+
+      @feedback.owner.email = params['feedback_feedback']['email']
+    end
+  end
+end

data/lib/nexmo_developer/app/controllers/feeds_controller.rb

@@ -0,0 +1,20 @@
+require 'icalendar'
+
+class FeedsController < ApplicationController
+  def events
+    calendar = Icalendar::Calendar.new
+    calendar.x_wr_calname = 'Nexmo Developer Events'
+
+    Event.all.each do |event|
+      calendar.event do |e|
+        e.dtstart = Icalendar::Values::Date.new(event.starts_at)
+        e.dtend = Icalendar::Values::Date.new(event.ends_at + 1.day)
+        e.summary = event.title
+        e.description = event.description
+      end
+    end
+
+    calendar.publish
+    render plain: calendar.to_ical
+  end
+end

data/lib/nexmo_developer/app/controllers/jobs_controller.rb

@@ -0,0 +1,64 @@
+require 'octokit'
+
+class JobsController < ApplicationController
+  skip_before_action :verify_authenticity_token
+
+  def code_example_push
+    if validate_github_signature
+      if params['ref'] == 'refs/heads/master'
+        url = "https://api.travis-ci.org/repo/#{ENV['TRAVIS_REPO_ID']}/requests"
+        RestClient.post(url, {
+          "request": {
+            "branch": 'master',
+            "config": {
+              "script": 'bundle exec rake diff:execute',
+              "env": {
+                "SSH_KEY_REQUIRED": true,
+              },
+            },
+          },
+        }.to_json, {
+          content_type: :json,
+          accept: :json,
+          'Authorization': "token #{ENV['TRAVIS_TOKEN']}",
+          'Travis-API-Version': '3',
+        })
+
+        render plain: 'Request forwarded to CI', status: :accepted
+      else
+        render plain: 'Request understood. Not master, not continuing', status: :ok
+      end
+    else
+      head :unauthorized
+    end
+  end
+
+  def open_pull_request
+    if validate_ci_secret
+      repo = ENV['GITHUB_REPO']
+      branch_base = 'master'
+      branch_head = params[:branch]
+      title = '[AUTOMATED] Updated code examples'
+      body = params[:body]
+
+      client = Octokit::Client.new(access_token: ENV['GITHUB_PERSONAL_ACCESS_TOKEN'])
+      client.login
+      client.create_pull_request(repo, branch_base, branch_head, title, body)
+
+      head :accepted
+    else
+      head :unauthorized
+    end
+  end
+
+  private
+
+  def validate_github_signature
+    signature = "sha1=#{OpenSSL::HMAC.hexdigest(OpenSSL::Digest.new('sha1'), ENV['CI_SECRET'], request.raw_post)}"
+    Rack::Utils.secure_compare(signature, request.headers['X-Hub-Signature'])
+  end
+
+  def validate_ci_secret
+    params['secret'] = ENV['CI_SECRET']
+  end
+end

data/lib/nexmo_developer/app/controllers/markdown_controller.rb

@@ -0,0 +1,160 @@
+class MarkdownController < ApplicationController
+  before_action :set_navigation
+  before_action :set_product
+  before_action :set_tracking_cookie
+  before_action :check_redirects, only: :show
+  before_action :canonical_redirect, only: :show
+
+  def show
+    if path_is_folder?
+      @frontmatter, @content = content_from_folder
+    else
+      @document_path = document.path
+      @frontmatter, @content = content_from_file
+      set_canonical_url
+    end
+
+    @document_title = @frontmatter['meta_title'] || @frontmatter['title']
+
+    @sidenav = Sidenav.new(
+      namespace: params[:namespace],
+      locale: params[:locale],
+      request_path: request.path,
+      navigation: @navigation,
+      code_language: params[:code_language],
+      product: @product
+    )
+
+    if !Rails.env.development? && @frontmatter['wip']
+      render 'wip', layout: 'documentation'
+    else
+      render layout: 'documentation'
+    end
+  end
+
+  def api
+    redirect = Redirector.find(request)
+    if redirect
+      redirect_to redirect
+    else
+      render_not_found
+    end
+  end
+
+  private
+
+  def set_navigation
+    @navigation = :documentation
+  end
+
+  def set_product
+    @product = params[:product]
+  end
+
+  def set_tracking_cookie
+    helpers.dashboard_cookie(params[:product])
+  end
+
+  def document
+    @document ||= Nexmo::Markdown::DocFinder.find(
+      root: root_folder,
+      document: params[:document],
+      language: params[:locale],
+      product: params[:product],
+      code_language: params[:code_language]
+    )
+  end
+
+  def root_folder
+    if params[:namespace].present?
+      "app/views/#{params[:namespace]}"
+    else
+      "#{Rails.configuration.docs_base_path}/_documentation"
+    end
+  end
+
+  def path_is_folder?
+    folder_config_path
+  rescue Nexmo::Markdown::DocFinder::MissingDoc
+    false
+  end
+
+  def folder_config_path
+    @folder_config_path ||= Nexmo::Markdown::DocFinder.find(
+      root: root_folder,
+      document: "#{params[:document]}/.config.yml",
+      language: params[:locale],
+      product: params[:product],
+      code_language: params[:code_language]
+    ).path
+  end
+
+  def content_from_folder
+    frontmatter = YAML.safe_load(File.read(folder_config_path))
+    path = folder_config_path.chomp('/.config.yml')
+
+    content = Nexmo::Markdown::Renderer.new({
+      code_language: @code_language,
+      current_user: current_user,
+    }).call(<<~HEREDOC
+      <h1>#{@document_title}</h1>
+
+      ```tabbed_folder
+      source: #{path}
+      ```
+    HEREDOC
+           )
+
+    [frontmatter, content]
+  end
+
+  def content_from_file
+    content = File.read(document.path)
+    frontmatter = YAML.safe_load(content)
+
+    raise Errno::ENOENT if frontmatter['redirect']
+
+    content = Nexmo::Markdown::Renderer.new({
+      code_language: @code_language,
+      current_user: current_user,
+      locale: params[:locale],
+    }).call(content)
+
+    [frontmatter, content]
+  end
+
+  def set_canonical_url
+    if params[:namespace] || !params[:locale] || document.available_languages.include?(params[:locale])
+      @canonical_url = canonical_url
+    else
+      @canonical_url = "#{canonical_base}#{canonical_path.sub("#{params[:locale]}/", '')}"
+    end
+  end
+
+  def check_redirects
+    redirect = Redirector.find(request)
+    return redirect_to redirect if redirect
+  end
+
+  def canonical_redirect
+    # TODO: change this to use the locale from the domain
+    # once we add support for that.
+
+    return if params[:namespace]
+    return if params[:locale].nil? && session[:locale].nil?
+    return if params[:locale] && params[:locale] != I18n.default_locale.to_s
+
+    if params[:locale]
+      redirect_to url_for(
+        controller: :markdown,
+        action: :show,
+        only_path: true,
+        locale: nil,
+        document: params[:document],
+        product: params[:product]
+      )
+    elsif session[:locale] && session[:locale] != I18n.default_locale.to_s
+      redirect_to "/#{session[:locale]}/#{params[:product]}/#{params[:document]}"
+    end
+  end
+end

data/lib/nexmo_developer/app/controllers/search_controller.rb

@@ -0,0 +1,35 @@
+class SearchController < ApplicationController
+  include ApplicationHelper
+
+  before_action :validate_query_is_present
+  before_action :check_search_is_enabled
+
+  def results
+    @results = JSON.parse(get_results.to_json, object_class: OpenStruct).results
+    @results_total = @results.sum(&:nbHits)
+  end
+
+  private
+
+  def validate_query_is_present
+    redirect_to root_path unless params['query']
+  end
+
+  def get_results # rubocop:disable Naming/AccessorMethodName
+    return unless params['query']
+
+    parameters = ALGOLIA_CONFIG.keys.map do |index|
+      {
+        index_name: index,
+        query: params['query'],
+        hitsPerPage: 20,
+      }
+    end
+
+    Algolia.multiple_queries(parameters)
+  end
+
+  def check_search_is_enabled
+    redirect_to root_path unless search_enabled?
+  end
+end

data/lib/nexmo_developer/app/controllers/sessions_controller.rb

@@ -0,0 +1,12 @@
+class SessionsController < ApplicationController
+  def destroy
+    sign_out
+    cookies.delete :feedback_author_id
+    redirect_back(fallback_location: root_path)
+  end
+
+  def set_user_locale
+    session[:locale] = params[:preferred_locale]
+    @path = LocaleRedirector.new(request, params).path
+  end
+end

data/lib/nexmo_developer/app/controllers/slack_controller.rb

@@ -0,0 +1,61 @@
+class SlackController < ApplicationController
+  before_action :set_navigation
+  before_action :set_email, only: [:invite]
+  before_action :validate_recapcha, only: [:invite]
+  before_action :validate_email, only: [:invite]
+
+  def join; end
+
+  def invite
+    response = RestClient.post "https://#{ENV['SLACK_SUBDOMAIN']}.slack.com/api/users.admin.invite", {
+      token: ENV['SLACK_TOKEN'],
+      email: @email,
+    }
+
+    response = JSON.parse(response)
+
+    if response['ok']
+      @invitation_sent_successfully = true
+      @notice = "An invitation has been sent to #{@email}"
+    else
+      case response['error']
+      when 'already_invited'
+        @notice = "It looks like you've already been sent an invitation."
+      when 'already_in_team'
+        @notice = 'You are already a member of this Slack'
+      else
+        Bugsnag.notify('Slack Error') do |notification|
+          notification.add_tab(:slack, { response: response })
+        end
+        @notice = 'Something went wrong. Please try again later.'
+      end
+    end
+
+    render 'join'
+  end
+
+  private
+
+  def set_navigation
+    @navigation = :community
+  end
+
+  def set_email
+    @email = params[:email]
+  end
+
+  def validate_recapcha
+    return unless ENV['RECAPTCHA_ENABLED']
+    return if verify_recaptcha
+
+    @notice = 'Are you a robot? It looks like you failed our reCAPTCHA. Try again.'
+    render 'join'
+  end
+
+  def validate_email
+    return if EmailValidator.valid?(@email)
+
+    @notice = 'Invalid email, try again.'
+    render 'join'
+  end
+end

data/lib/nexmo_developer/app/controllers/static_controller.rb

@@ -0,0 +1,195 @@
+class StaticController < ApplicationController
+  before_action :canonical_redirect, only: :documentation
+
+  def default_landing
+    yaml_name = request[:landing_page]
+
+    if File.exist?("#{Rails.configuration.docs_base_path}/custom/landing_pages/#{yaml_name}.yml")
+      @landing_config = YAML.load_file("#{Rails.configuration.docs_base_path}/custom/landing_pages/#{yaml_name}.yml")
+    else
+      @landing_config = YAML.load_file("#{Rails.root}/config/landing_pages/#{yaml_name}.yml")
+    end
+
+    @landing_config['page'].each do |row|
+      some_columns_have_widths = row['row'].select { |c| c['width'] }.count.positive?
+      if some_columns_have_widths
+        row['row'] = row['row'].map do |c|
+          c['width'] ||= 1
+          c
+        end
+        row['column_count'] = row['row'].map { |c| c['width'] }.sum
+      end
+    end
+
+    if request.path.delete('/') == 'community'
+      @upcoming_events = Event.upcoming
+      @past_events_count = Event.past.count
+      @navigation = :community
+
+      @hash = Gmaps4rails.build_markers(@upcoming_events.reject(&:remote?)) do |event, marker|
+        event.geocode
+        marker.lat event.latitude
+        marker.lng event.longitude
+        marker.infowindow event.title
+      end
+    end
+
+    if request.path.delete('/') == 'team'
+      @team ||= LoadConfig.load_file('config/team.yml')
+      @careers = Greenhouse.devrel_careers
+    end
+
+    if request.path.sub!('/', '') == 'migrate/tropo/sms'
+      migrate_tropo
+    elsif request.path.sub!('/', '') == 'migrate/tropo/voice'
+      migrate_tropo
+    end
+
+    @navigation = yaml_name.to_sym
+    render layout: 'landing'
+  end
+
+  def event_search
+    @events = Event.search(params[:query]) if params[:query]
+
+    @hash = Gmaps4rails.build_markers(@events.reject(&:remote?)) do |event, marker|
+      event.geocode
+      marker.lat event.latitude
+      marker.lng event.longitude
+      marker.infowindow event.title
+    end
+
+    respond_to do |format|
+      format.js { render partial: 'static/default_landing/partials/event_search_results.js.erb' }
+    end
+  end
+
+  def landing
+    render layout: 'landing'
+  end
+
+  def documentation
+    document ||= Nexmo::Markdown::DocFinder.find(
+      root: "#{Rails.configuration.docs_base_path}/_documentation",
+      document: 'index',
+      language: params[:locale]
+    )
+
+    @document_path = document.path
+
+    # Parse frontmatter
+    @frontmatter = YAML.safe_load(document.path)
+
+    @document_title = @frontmatter['title']
+
+    @content = Nexmo::Markdown::Renderer.new(locale: params[:locale]).call(File.read(document.path))
+
+    @navigation = :documentation
+
+    @sidenav = Sidenav.new(
+      request_path: request.path,
+      navigation: @navigation,
+      product: @product,
+      locale: params[:locale]
+    )
+
+    render layout: 'documentation'
+  end
+
+  def community
+    @navigation = :community
+    @document_title = 'Community'
+    @upcoming_events = Event.upcoming
+    @past_events_count = Event.past.count
+    @sessions = Session.visible_to(current_user).order(created_at: :desc)
+    render layout: 'page'
+  end
+
+  def past_events
+    @navigation = :community
+    @document_title = 'Community'
+    @past_events = Event.past
+    render layout: 'page'
+  end
+
+  def robots
+    render 'robots.txt'
+  end
+
+  def podcast
+    # Get URL and split the / to retrieve the landing page name
+    yaml_name = request.fullpath.split('/')[1]
+
+    # Load the YAML for that particular page
+    @content = YAML.load_file("#{Rails.root}/config/landing_pages/#{yaml_name}.yml")
+
+    render layout: 'landing'
+  end
+
+  def team
+    @team ||= LoadConfig.load_file('config/team.yml')
+    @careers = Greenhouse.devrel_careers
+
+    render layout: 'page'
+  end
+
+  def migrate_tropo
+    @active_title = 'Migrate from Tropo'
+
+    @building_blocks = @landing_config['page'][0]['row'][0]['column'][0]['migrate_details']['blocks'].map do |block|
+      block['nexmo'] = "<h2>Nexmo</h2>
+        ```code_snippets
+          code_only: true
+          source: #{block['nexmo']}
+        ```"
+
+      block['tropo'] = "<h2>Tropo</h2>
+        ```code_snippets
+          code_only: true
+          source: #{block['tropo']}
+        ```"
+
+      block
+    end
+  end
+
+  def spotlight
+    response = RestClient.post(
+      'https://hooks.zapier.com/hooks/catch/1936493/oyzjr4i/',
+      params.permit(:name, :email_address, :background, :outline, :previous_content).to_h
+    )
+
+    if response.code == 200
+      head :ok
+    else
+      head :unprocessable_entity
+    end
+  end
+
+  def blog_cookie
+    # This is the first touch time so we only want to set it if it's not already set
+    set_utm_cookie('ft', Time.now.getutc.to_i) unless cookies[:ft]
+
+    # Clear out old values that might not be set
+    cookies.delete('utm_campaign', domain: :all)
+    cookies.delete('utm_term', domain: :all)
+    cookies.delete('utm_content', domain: :all)
+
+    # These are the things we'll be tracking through the customer dashboard
+    set_utm_cookie('utm_medium', 'dev_education')
+    set_utm_cookie('utm_source', 'blog')
+    set_utm_cookie('utm_campaign', params['c']) if params['c']
+    set_utm_cookie('utm_content', params['ct']) if params['ct']
+    set_utm_cookie('utm_term', params['t']) if params['t']
+
+    redirect_to 'https://dashboard.nexmo.com/sign-up'
+  end
+
+  private
+
+  def canonical_redirect
+    return if params[:locale] != I18n.default_locale.to_s
+
+    redirect_to documentation_path(locale: nil)
+  end
+end