station 0.0.0 → 0.0.100

data/lib/nexmo_developer/app/models/application_record.rb

@@ -0,0 +1,3 @@
+class ApplicationRecord < ActiveRecord::Base
+  self.abstract_class = true
+end

data/lib/nexmo_developer/app/models/concerns/publishable.rb

@@ -0,0 +1,13 @@
+module Publishable
+  extend ActiveSupport::Concern
+
+  included do
+    scope :published, -> { where(published: true) }
+  end
+
+  class_methods do
+    def visible_to(user)
+      user&.admin? ? all : published
+    end
+  end
+end

data/lib/nexmo_developer/app/models/event.rb

@@ -0,0 +1,38 @@
+class Event < ApplicationRecord
+  default_scope -> { order(:starts_at) }
+  scope :upcoming, -> { where('ends_at > ?', Time.zone.today) }
+  scope :past, -> { where('starts_at < ?', Time.zone.today).reverse_order }
+
+  geocoded_by :address
+  before_validation :geocode
+
+  has_many :sessions, dependent: :nullify
+
+  validates :title, presence: true
+  validates :description, presence: true
+  validates :starts_at, presence: true
+  validates :ends_at, presence: true
+  validates :url, presence: true
+
+  def self.search(search)
+    key = "%#{search}%"
+    columns = %w[title description city country]
+    @events = Event.where(
+      columns.map { |c| "#{c} ilike :search" }.join(' OR '),
+      search: key
+    ).upcoming
+  end
+
+  private
+
+  def address
+    # Provide the full country name to the geocoder,
+    # otherwise it thinks that IL is Illinois, not Israel
+    if country
+      country = ISO3166::Country[self.country.downcase]
+      country = country.name if country
+    end
+
+    [city, country].compact.join(', ')
+  end
+end

data/lib/nexmo_developer/app/models/feedback.rb

@@ -0,0 +1,5 @@
+module Feedback
+  def self.table_name_prefix
+    'feedback_'
+  end
+end

data/lib/nexmo_developer/app/models/feedback/author.rb

@@ -0,0 +1,5 @@
+module Feedback
+  class Author < ApplicationRecord
+    has_many :feedbacks, as: :owner, dependent: :nullify, inverse_of: :author
+  end
+end

data/lib/nexmo_developer/app/models/feedback/config.rb

@@ -0,0 +1,16 @@
+module Feedback
+  class Config < ApplicationRecord
+    has_many :feedbacks, inverse_of: :config, dependent: :nullify
+
+    def self.find_or_create_config(config)
+      last_config = last
+      if last_config && last_config.attributes.slice('title', 'paths') == config
+        return last_config
+      end
+
+      new_config = new(title: config['title'], paths: config['paths'])
+      new_config.save
+      new_config
+    end
+  end
+end

data/lib/nexmo_developer/app/models/feedback/feedback.rb

@@ -0,0 +1,34 @@
+module Feedback
+  class Feedback < ApplicationRecord
+    scope :created_after, ->(date) { where('feedback_feedbacks.created_at >= ?', date) if date.present? }
+    scope :created_before, ->(date) { where('feedback_feedbacks.created_at <= ?', date) if date.present? }
+    scope :created_between, ->(start_date, end_date) { created_after(start_date).created_before(end_date) }
+
+    belongs_to :resource, class_name: '::Feedback::Resource'
+    belongs_to :owner, polymorphic: true
+    belongs_to :config, optional: true, class_name: '::Feedback::Config', foreign_key: 'feedback_config_id', inverse_of: :feedbacks
+
+    attr_accessor :email, :source
+
+    before_validation :set_resource
+
+    validates :sentiment, presence: true
+    validates :owner, presence: true
+
+    scope :positive, -> { where(sentiment: 'positive') }
+    scope :negative, -> { where(sentiment: 'negative') }
+    scope :neutral,  -> { where(sentiment: 'neutral') }
+
+    after_commit :notify
+
+    def set_resource
+      self.resource ||= Resource.find_or_create_by!(uri: source)
+    end
+
+    def notify
+      return unless ENV['SLACK_WEBHOOK']
+
+      FeedbackSlackNotifier.call(self)
+    end
+  end
+end

data/lib/nexmo_developer/app/models/feedback/resource.rb

@@ -0,0 +1,45 @@
+module Feedback
+  class Resource < ApplicationRecord
+    has_many :feedbacks, dependent: :destroy
+
+    before_validation :set_product
+    validates :uri, presence: true, allow_blank: false
+
+    def display_name
+      uri
+    end
+
+    def score
+      if feedbacks.any?
+        score_value.round(1)
+      else
+        'n/a'
+      end
+    end
+
+    def score_value
+      ((feedbacks.positive.count / feedbacks.count.to_f) * 100.to_f)
+    end
+
+    def relative_link
+      URI(uri).path
+    end
+
+    def self.worst_performing
+      all.select { |resource| resource.feedbacks.count > 5 }.sort_by(&:score_value)
+    end
+
+    def self.best_performing
+      worst_performing.reverse
+    end
+
+    private
+
+    def set_product
+      products = DocumentationConstraint.product_with_parent_list
+      self.product = products.detect do |product|
+        break product if URI(uri).path.start_with? "/#{product}"
+      end
+    end
+  end
+end

data/lib/nexmo_developer/app/models/product.rb

@@ -0,0 +1,22 @@
+class Product
+  # TODO: return instances
+  def self.all
+    raise "Application requires 'products.yml' inside /config folder in documentation path" unless defined?("#{Rails.configuration.docs_base_path}/config/products.yml")
+
+    config = YAML.safe_load(File.open("#{Rails.configuration.docs_base_path}/config/products.yml"))
+
+    config['products']
+  end
+
+  def self.normalize_title(product)
+    return 'SMS' if product == 'messaging/sms'
+    return 'Voice' if product == 'voice/voice-api'
+    return 'Number Insight' if product == 'number-insight'
+    return 'Messages' if product == 'messages'
+    return 'Dispatch' if product == 'dispatch'
+    return 'Client SDK' if product == 'client-sdk'
+    return 'Subaccounts' if product == 'account/subaccounts'
+
+    product.camelcase
+  end
+end

data/lib/nexmo_developer/app/models/redirect.rb

@@ -0,0 +1,2 @@
+class Redirect < ApplicationRecord
+end

data/lib/nexmo_developer/app/models/session.rb

@@ -0,0 +1,9 @@
+class Session < ApplicationRecord
+  include Publishable
+
+  belongs_to :event, optional: true
+
+  validates :title, presence: true
+  validates :author, presence: true
+  validates :video_url, presence: true
+end

data/lib/nexmo_developer/app/models/tutorial.rb

@@ -0,0 +1,189 @@
+class Tutorial
+  include ActiveModel::Model
+
+  attr_reader :name, :current_step
+
+  delegate :path, :yaml, to: :@file_loader
+  delegate :available_code_languages, to: :metadata
+
+  def initialize(name:, current_step:, current_product: nil, code_language: nil)
+    @name         = name
+    @current_step = current_step
+    @product      = current_product
+    @language     = code_language
+    @file_loader  = load_file!
+  end
+
+  def metadata
+    @metadata ||= Metadata.new(name: name)
+  end
+
+  def current_product
+    @current_product ||= @product || metadata.default_product
+  end
+
+  def code_language
+    @code_language ||= @language || metadata.code_language
+  end
+
+  def title
+    @title ||= yaml['title'] || metadata.title
+  end
+
+  def description
+    @description ||= yaml['description'] || metadata.description
+  end
+
+  def products
+    @products ||= yaml['products'] || metadata.products
+  end
+
+  def prerequisites
+    @prerequisites ||= (yaml['prerequisites'] || []).map do |prereq|
+      Prerequisite.new(name: prereq, code_language: code_language, current_step: current_step)
+    end
+  end
+
+  def content_for(step_name)
+    if ['introduction', 'conclusion'].include? step_name
+      raise "Invalid step: #{step_name}" unless yaml[step_name]
+
+      return yaml[step_name]['content']
+    end
+
+    path = Nexmo::Markdown::DocFinder.find(
+      root: self.class.task_content_path,
+      document: step_name,
+      language: ::I18n.locale,
+      code_language: code_language
+    ).path
+
+    File.read(path)
+  end
+
+  def first_step
+    subtasks.first&.name
+  end
+
+  def prerequisite?
+    prerequisites.map(&:name).include?(@current_step)
+  end
+
+  def next_step
+    current_task_index = subtasks.map(&:name).index(@current_step)
+    return nil unless current_task_index
+
+    subtasks[current_task_index + 1]
+  end
+
+  def previous_step
+    current_task_index = subtasks.map(&:name).index(@current_step)
+    return nil unless current_task_index
+    return nil if current_task_index <= 0
+
+    subtasks[current_task_index - 1]
+  end
+
+  def subtasks
+    @subtasks ||= begin
+      tasks = []
+
+      (yaml['tasks'] || []).map do |t|
+        tasks.push(
+          Task.make_from(
+            name: t,
+            code_language: code_language,
+            current_step: current_step
+          )
+        )
+      end
+
+      tasks.unshift(prerequisite_task)
+      tasks.unshift(introduction_task)
+      tasks.push(conclusion_task)
+
+      tasks.compact
+    end
+  end
+
+  def self.load_prerequisites(prerequisites, current_step)
+    return [] unless prerequisites
+
+    prerequisites.map do |t|
+      t_path = Nexmo::Markdown::DocFinder.find(
+        root: task_content_path,
+        document: t,
+        language: ::I18n.locale
+      ).path
+      raise "Prerequisite not found: #{t}" unless File.exist? t_path
+
+      content = File.read(t_path)
+      prereq = YAML.safe_load(content)
+      {
+        'path' => t,
+        'title' => prereq['title'],
+        'description' => prereq['description'],
+        'is_active' => t == current_step,
+        'content' => content,
+      }
+    end
+  end
+
+  def prerequisite_task
+    return if prerequisites.empty?
+
+    Task.new(
+      name: 'prerequisites',
+      title: 'Prerequisites',
+      description: 'Everything you need to complete this task',
+      current_step: current_step
+    )
+  end
+
+  def introduction_task
+    return unless yaml['introduction']
+
+    Task.new(
+      name: 'introduction',
+      title: yaml['introduction']['title'],
+      description: yaml['introduction']['description'],
+      current_step: current_step
+    )
+  end
+
+  def conclusion_task
+    return unless yaml['conclusion']
+
+    Task.new(
+      name: 'conclusion',
+      title: yaml['conclusion']['title'],
+      description: yaml['conclusion']['description'],
+      current_step: current_step
+    )
+  end
+
+  def self.load(name, current_step, current_product = nil, code_language = nil)
+    new(
+      name: name,
+      current_step: current_step,
+      current_product: current_product,
+      code_language: code_language
+    )
+  end
+
+  def load_file!
+    Tutorial::FileLoader.new(
+      root: self.class.tutorials_path,
+      code_language: code_language,
+      doc_name: name
+    )
+  end
+
+  def self.task_content_path
+    "#{Nexmo::Markdown::Config.docs_base_path}/_tutorials"
+  end
+
+  def self.tutorials_path
+    "#{Nexmo::Markdown::Config.docs_base_path}/config/tutorials"
+  end
+end

data/lib/nexmo_developer/app/models/tutorial/file_loader.rb

@@ -0,0 +1,28 @@
+class Tutorial::FileLoader
+  attr_reader :root, :code_language, :doc_name, :format
+
+  def initialize(root:, code_language:, doc_name:, format: 'yml')
+    @root          = root
+    @code_language = code_language
+    @doc_name      = doc_name
+    @format        = format
+  end
+
+  def path
+    @path ||= Nexmo::Markdown::DocFinder.find(
+      root: root,
+      document: doc_name,
+      language: ::I18n.locale,
+      code_language: code_language,
+      format: format
+    ).path
+  end
+
+  def content
+    @content ||= File.read(path)
+  end
+
+  def yaml
+    @yaml ||= YAML.safe_load(content)
+  end
+end

data/lib/nexmo_developer/app/models/tutorial/metadata.rb

@@ -0,0 +1,54 @@
+class Tutorial::Metadata
+  attr_reader :name, :file_loader
+
+  delegate :path, :yaml, to: :file_loader
+
+  def initialize(name:)
+    @name        = name
+    @file_loader = load_file!
+  end
+
+  def products
+    @products ||= yaml['products'] || []
+  end
+
+  def title
+    @title ||= yaml['title']
+  end
+
+  def description
+    @description ||= yaml['description']
+  end
+
+  def external_link
+    @external_link ||= yaml['external_link']
+  end
+
+  def available_code_languages
+    @available_code_languages ||= begin
+      Nexmo::Markdown::DocFinder
+        .code_languages_for_tutorial(path: path.sub('.yml', '/'))
+        .map { |file_path| File.basename(Pathname.new(file_path).basename, '.yml') }
+        .sort_by { |l| Nexmo::Markdown::CodeLanguage.find(l).weight }
+    end
+  end
+
+  def code_language
+    @code_language ||= begin
+      available_code_languages
+        .min_by { |k| Nexmo::Markdown::CodeLanguage.languages.map(&:key).index(k) }
+    end
+  end
+
+  def default_product
+    @default_product ||= products.first
+  end
+
+  def load_file!
+    Tutorial::FileLoader.new(
+      root: Tutorial.tutorials_path,
+      code_language: nil,
+      doc_name: @name
+    )
+  end
+end