pageflow 0.0.1

data/lib/pageflow/page_type.rb

@@ -0,0 +1,116 @@
+module Pageflow
+  # Base class for defining page types.
+  class PageType
+    # View path to the html template.
+    def template_path
+      File.join('pageflow', name, 'page')
+    end
+
+    # Name to display in editor.
+    def translation_key
+      "pageflow.#{name}.page_type_name"
+    end
+
+    # Override to return a string in snake_case.
+    def name
+      raise(NotImplementedError, 'PageType subclass needs to define a name.')
+    end
+
+    # Rails helper modules to make available in the html template.
+    #
+    # Example:
+    #
+    #     module RainbowsHelper
+    #       def rainbow
+    #         tag(:rainbow)
+    #       end
+    #     end
+    #
+    #     class RainbowPageType < Pageflow::PageType
+    #       name 'rainbow'
+    #
+    #       def view_helpers
+    #         [RainbowsHelper]
+    #       end
+    #     end
+    #
+    #     # page_types/pageflow/rainbow/page.html.erb
+    #     <%= rainbow %>
+    #
+    def view_helpers
+      []
+    end
+
+    # View path of a template containing additional json to pass to
+    # the editor. The data is available in the javascript definition
+    # of the page type's configuration editor. By default nothing is
+    # added.
+    #
+    # In particular this can be used to make configuration options of
+    # page type engines available to the editor.
+    #
+    # Example:
+    #
+    #     class RainbowPageType < Pageflow::PageType
+    #       name 'rainbow'
+    #
+    #       def json_seed_template
+    #         'pageflow/rainbow/page_type.json.jbuilder'
+    #       end
+    #     end
+    #
+    #     # page_types/pageflow/rainbow/page_type.json.jbuilder
+    #     json.colors ['red', 'blue', 'yellow']
+    #
+    #     # page_types/pageflow/rainbow/editor.js
+    #     pageflow.ConfigurationEditorView.register('rainbow', {
+    #       configure: function() {
+    #         var colors = this.options.pageType.colors;
+    #         // ...
+    #       }
+    #     });
+    #
+    def json_seed_template
+    end
+
+    # Helper method to define the name of a subclassed page type.
+    def self.name(name = nil)
+      return super() unless name
+      define_method :name do
+        name
+      end
+    end
+
+    # Include in your engine if it mainly defines new page types. Sets
+    # up load paths so you can place all files related to a page type
+    # in a single directory. The following structure is proposed for a
+    # page type engine:
+    #
+    #    pageflow-rainbow/
+    #      page_types/
+    #        pageflow/
+    #          rainbow/
+    #            editor.js
+    #            page.html.erb
+    #            page_type.json.jbuilder
+    #          rainbow.css.scss
+    #          rainbow.js
+    #      lib/
+    #        pageflow/
+    #          rainbow/
+    #            engine.rb
+    #            page_type.rb
+    #
+    module Engine
+      extend ActiveSupport::Concern
+
+      included do
+        paths["app/views"] << 'page_types'
+
+        initializer :assets do |config|
+          Rails.application.config.assets.paths << root.join('page_types')
+        end
+      end
+    end
+  end
+end

data/lib/pageflow/seeds.rb

@@ -0,0 +1,94 @@
+# Require this file in db/seeds.rb to create example records for development mode.
+
+module Pageflow
+  # Default Account
+
+  if Theme.any?
+    default_theme = Theme.first
+    puts "   Theme exists."
+  else
+    default_theme = Theme.create!(:name => 'default',
+      :imprint_link_label => 'Impressum',
+      :imprint_link_url => 'http://example.com/impressum.html',
+      :copyright_link_label => '© Pageflow 2014',
+      :copyright_link_url => 'http://www.example.com/copyright.html')
+    puts "   Created theme."
+  end
+
+  # Default Account
+
+  if Account.any?
+    default_account = Account.first
+    puts "   Account exists."
+  else
+    default_account = Account.create!(:name => 'Pageflow', :default_theme_id => default_theme.id)
+    puts "   Created default account."
+  end
+
+  # Users
+
+  def self.create_user(options)
+    options[:password_confirmation] = options[:password]
+    Account.first.users.create!(options)
+
+    puts <<-END
+   Created #{options[:admin] ? 'admin' : 'editor'} user:
+
+     email:     #{options[:email]}
+     password:  #{options[:password]}
+
+  END
+  end
+
+  if default_account.users.none?
+    create_user(:email => 'admin@example.com',
+                :password => '!Pass123',
+                :first_name => 'Alice',
+                :last_name => 'Adminson',
+                :role => 'admin')
+
+    create_user(:email => 'accountmanager@example.com',
+                :password => '!Pass123',
+                :first_name => 'Alfred',
+                :last_name => 'Mc Count',
+                :role => 'account_manager')
+
+    create_user(:email => 'editor@example.com',
+                :password => '!Pass123',
+                :first_name => 'Ed',
+                :last_name => 'Edison')
+  else
+    puts "   Users exist."
+  end
+
+  # Sample entry
+
+  unless Entry.any?
+    entry = default_account.entries.create!(:title => 'Fiese Flut', :theme_id => default_theme.id)
+
+    chapter = entry.draft.chapters.create!(:title => 'Kapitel 1')
+    chapter.pages.create!(:template => 'background_image')
+    chapter.pages.create!(:template => 'background_image')
+
+    chapter = entry.draft.chapters.create!(:title => 'Kapitel 2')
+    chapter.pages.create!(:template => 'video')
+
+    puts "   Created sample entry."
+  end
+
+  # Sample membership
+
+  unless Membership.any?
+    membership = Membership.create!(:user => default_account.users.editors.first,
+      :entry => Entry.first)
+    puts "   Created sample membership."
+  end
+
+  # Sample revision
+
+  unless Revision.any?
+    revision = Revision.create!(:creator => default_account.users.editors.first,
+      :entry => Entry.first)
+    puts "   Created sample revision."
+  end
+end

data/lib/pageflow/user_mixin.rb

@@ -0,0 +1,72 @@
+module Pageflow
+  # ActiveRecord related functionality of the Pageflow users.
+  module UserMixin
+    extend ActiveSupport::Concern
+
+    NON_ADMIN_ROLES = ['editor', 'account_manager']
+    ROLES = NON_ADMIN_ROLES + ['admin']
+
+    include Suspendable
+
+    included do
+      belongs_to :account, :class_name => 'Pageflow::Account'
+
+      has_many :memberships, :dependent => :destroy, :class_name => 'Pageflow::Membership'
+      has_many :entries, :through => :memberships, :class_name => 'Pageflow::Entry'
+
+      has_many :revisions, :class_name => 'Pageflow::Revision'
+
+      validates :first_name, :last_name, :presence => true
+      validates :role, :inclusion => ROLES
+      validates :account, :presence => true
+
+      scope :admins, -> { where(:role => 'admin') }
+      scope :account_managers, -> { where(:role => 'account_manager') }
+      scope :editors, -> { where(:role => 'editor') }
+    end
+
+    def admin?
+      role == 'admin'
+    end
+
+    def account_manager?
+      role == 'account_manager'
+    end
+
+    def full_name
+      [first_name, last_name] * " "
+    end
+
+    def update_with_password(attributes)
+      if needs_password?(attributes)
+        super(attributes)
+      else
+        # remove the virtual current_password attribute update_without_password
+        # doesn't know how to ignore it
+        update_without_password(attributes.except(:current_password))
+      end
+    end
+
+    def destroy_with_password(password)
+      if valid_password?(password)
+        destroy
+        true
+      else
+        self.errors.add(:current_password, password.blank? ? :blank : :invalid)
+        false
+      end
+    end
+
+    module ClassMethods
+      def roles_accessible_by(ability)
+        ability.can?(:read, Account) ? ROLES : NON_ADMIN_ROLES
+      end
+    end
+
+    private
+
+    def needs_password?(attributes)
+      attributes[:password].present?
+    end
+  end
+end

data/lib/pageflow/version.rb

@@ -0,0 +1,3 @@
+module Pageflow
+  VERSION = "0.0.1"
+end

data/lib/pageflow/view_component.rb

@@ -0,0 +1,14 @@
+module Pageflow
+  # Base class for Arbre components defined by Pageflow. Store the
+  # builder method name to facilitate calling it in specs.
+  class ViewComponent < Arbre::Component
+    class << self
+      attr_reader :builder_method_name
+    end
+
+    def self.builder_method(name)
+      @builder_method_name = name
+      super
+    end
+  end
+end

data/lib/pageflow/zencoder_api.rb

@@ -0,0 +1,78 @@
+require 'pageflow/zencoder_output_definition'
+require 'pageflow/zencoder_video_output_definition'
+require 'pageflow/zencoder_audio_output_definition'
+
+module Pageflow
+  class ZencoderApi
+    class Error < StandardError; end
+    class RecoverableError < Error; end
+    class UnrecoverableError < Error; end
+
+    def create_job(definition)
+      with_exception_translation do
+        response = Zencoder::Job.create(:input => definition.input_s3_url,
+                                        :outputs => definition.outputs)
+        if response.success?
+          response.body['id']
+        else
+          raise translate_zencoder_errors(response.errors)
+        end
+      end
+    end
+
+    def get_info(job_id)
+      with_exception_translation do
+        response = Zencoder::Job.progress(job_id)
+
+        if response.success?
+          {
+            :state => response.body["state"],
+            :progress => response.body["progress"],
+            :finished => response.body["state"] == 'finished'
+          }
+        else
+          raise translate_zencoder_errors(response.errors)
+        end
+      end
+    end
+
+    def get_input_details(job_id)
+      with_exception_translation do
+        response = Zencoder::Job.details(job_id)
+
+        if response.success?
+          input_details = response.body['job']['input_media_file']
+
+          {
+            :format => input_details["format"],
+            :duration_in_ms => input_details["duration_in_ms"],
+            :width => input_details["width"],
+            :height => input_details["height"]
+          }
+        else
+          raise translate_zencoder_errors(response.errors)
+        end
+      end
+    end
+
+    def self.instance
+      ZencoderApi.new
+    end
+
+    private
+
+    def with_exception_translation
+      begin
+        yield
+      rescue Timeout::Error
+        raise RecoverableError, 'Zencoder timed out.'
+      rescue Zencoder::HTTPError => e
+        raise RecoverableError, e.message
+      end
+    end
+
+    def translate_zencoder_errors(errors)
+      raise UnrecoverableError, "Zencoder responded with errors:\n#{errors * "\n"}"
+    end
+  end
+end

data/lib/pageflow/zencoder_audio_output_definition.rb

@@ -0,0 +1,54 @@
+module Pageflow
+  class ZencoderAudioOutputDefinition < ZencoderOutputDefinition
+    attr_reader :audio_file
+
+    def initialize(audio_file, options = {})
+      super(options)
+      @audio_file = audio_file
+    end
+
+    def input_s3_url
+      @audio_file.attachment_s3_url
+    end
+
+    def outputs
+      [
+        s3_and_transfer(m4a_definition),
+        s3_and_transfer(mp3_definition),
+        s3_and_transfer(ogg_definition)
+      ].flatten
+    end
+
+    private
+
+    def m4a_definition
+      {
+        :label => 'm4a',
+        :format => 'm4a',
+        :path => audio_file.m4a.path,
+        :public => 1,
+        :headers => {
+          'Content-Type' => 'audio/mp4'
+        }
+      }
+    end
+
+    def mp3_definition
+      {
+        :label => 'mp3',
+        :format => 'mp3',
+        :path => audio_file.mp3.path,
+        :public => 1
+      }
+    end
+
+    def ogg_definition
+      {
+        :label => 'ogg',
+        :format => 'ogg',
+        :path => audio_file.ogg.path,
+        :public => 1
+      }
+    end
+  end
+end

data/lib/pageflow/zencoder_output_definition.rb

@@ -0,0 +1,82 @@
+module Pageflow
+  class ZencoderOutputDefinition
+    cattr_accessor :default_output_bucket_name, :default_sftp_host
+
+    attr_accessor :options
+
+    def initialize(options)
+      @options = options
+    end
+
+    def input_s3_url
+      raise "Not implemented"
+    end
+
+    def outputs
+      raise "Not implemented"
+    end
+
+    def ==(other)
+      other.class == self.class &&
+        other.input_s3_url == input_s3_url &&
+        other.outputs == outputs
+    end
+    alias_method :eql?, :==
+
+      protected
+
+    def s3_and_transfer(definition)
+      [s3_definition(definition), transfer_definition(definition)].compact
+    end
+
+    def s3_and_sftp(definition)
+      [s3_definition(definition), sftp_definition(definition)].compact
+    end
+
+    def s3_url(path)
+      "s3://#{File.join(output_bucket_name, path)}"
+    end
+
+    def output_bucket_name
+      options.fetch(:output_bucket_name, default_output_bucket_name)
+    end
+
+    def sftp_url(path)
+      "#{File.join(sftp_host, path)}"
+    end
+
+    def sftp_host
+      options.fetch(:sftp_host, default_sftp_host)
+    end
+
+    def sftp_configured?
+      sftp_host.present?
+    end
+
+    private
+
+    def transfer_definition(definition)
+      return unless sftp_configured?
+      {
+        :label => "transfer_#{definition[:label]}",
+        :source => definition[:label],
+        :type => 'transfer-only',
+        :url => sftp_url(definition[:path])
+      }
+    end
+
+    def s3_definition(source_defintion)
+      source_defintion.dup.tap do |definiton|
+        definiton[:url] = s3_url(definiton.delete(:path))
+      end
+    end
+
+    def sftp_definition(source_defintion)
+      return unless sftp_configured?
+      source_defintion.dup.tap do |definiton|
+        definiton[:label] = "sftp_#{definiton[:label]}"
+        definiton[:url] = sftp_url(definiton.delete(:path))
+      end
+    end
+  end
+end