porthos 3.0.0.beta

data/app/controllers/admin/redirects_controller.rb

@@ -0,0 +1,58 @@
+class Admin::RedirectsController < ApplicationController
+  include Porthos::Admin
+  
+  
+  def index
+    @redirects = Redirect.find(:all, :order => 'path')
+    respond_to do |format|
+      format.html {}
+    end
+  end
+  
+  def new
+    @redirect = Redirect.new
+    respond_to do |format|
+      format.html {}
+    end
+  end
+  
+  def create
+    @redirect = Redirect.new(params[:redirect])
+    respond_to do |format|
+      if @redirect.save
+        flash[:notice] = t(:saved, :scope => [:app, :admin_redirects])
+        format.html { redirect_to admin_redirects_path }
+      else
+        format.html { render :action => :new }
+      end
+    end
+  end
+  
+  def edit
+    @redirect = Redirect.find(params[:id])
+    respond_to do |format|
+      format.html {}
+    end
+  end
+  
+  def update
+    @redirect = Redirect.find(params[:id])
+    respond_to do |format|
+      if @redirect.update_attributes(params[:redirect])
+        flash[:notice] = t(:saved, :scope => [:app, :admin_redirects])
+        format.html { redirect_to admin_redirects_path }
+      else
+        format.html { render :action => :edit }
+      end
+    end
+  end
+  
+  def destroy
+    @redirect = Redirect.find(params[:id])
+    @redirect.destroy
+    respond_to do |format|
+      flash[:notice] = t(:deleted, :scope => [:app, :admin_redirects])
+      format.html { redirect_to admin_redirects_path }
+    end
+  end
+end

data/app/controllers/admin/sessions_controller.rb

@@ -0,0 +1,27 @@
+# This controller handles the login/logout function of the site.
+class Admin::SessionsController < ApplicationController
+  include Porthos::Admin
+  skip_before_filter :authenticate!
+  layout 'admin/sessions'
+
+  def index
+    redirect_to admin_root_path
+  end
+
+  def new
+  end
+
+  def create
+    user = warden.authenticate!
+    sign_in user
+    flash[:notice] = t(:'admin.sessions.signed_in')
+    redirect_to admin_root_path
+  end
+
+  def destroy
+    sign_out
+    flash[:notice] = t(:'admin.sessions.signed_out')
+    redirect_to admin_login_path
+  end
+
+end

data/app/controllers/admin/site_settings_controller.rb

@@ -0,0 +1,58 @@
+class Admin::SiteSettingsController < ApplicationController
+  include Porthos::Admin
+
+
+  def index
+    @site_settings = SiteSetting.all
+    respond_to do |format|
+      format.html {}
+    end
+  end
+
+  def new
+    @site_setting = SiteSetting.new
+    respond_to do |format|
+      format.html {}
+    end
+  end
+
+  def create
+    @site_setting = SiteSetting.new(params[:site_setting])
+    respond_to do |format|
+      if @site_setting.save
+        flash[:notice] = t(:saved, :scope => [:app, :admin_general])
+        format.html { redirect_to admin_site_settings_path }
+      else
+        format.html { render :action => :new }
+      end
+    end
+  end
+
+  def edit
+    @site_setting = SiteSetting.find(params[:id])
+    respond_to do |format|
+      format.html {}
+    end
+  end
+
+  def update
+    @site_setting = SiteSetting.find(params[:id])
+    respond_to do |format|
+      if @site_setting.update_attributes(params[:site_setting])
+        flash[:notice] = t(:saved, :scope => [:app, :admin_general])
+        format.html { redirect_to admin_site_settings_path }
+      else
+        format.html { render :action => :edit }
+      end
+    end
+  end
+
+  def destroy
+    @site_setting = SiteSetting.find(params[:id])
+    @site_setting.destroy
+    respond_to do |format|
+      flash[:notice] = t(:deleted, :scope => [:app, :admin_general])
+      format.html { redirect_to admin_site_settings_path }
+    end
+  end
+end

data/app/controllers/admin/tags_controller.rb

@@ -0,0 +1,71 @@
+class Admin::TagsController < ApplicationController
+  include Porthos::Admin
+  
+
+  skip_before_filter :clear_content_context, :only => [:search]
+
+  def index
+    @tags = Tag.find(:all, :order => 'name')
+  end
+
+  def new
+    @tag = Tag.new
+  end
+
+  def create
+    @tag = Tag.new(params[:tag])
+    respond_to do |format|
+      if @tag.save
+        flash[:notice] = "#{@tag.name}  #{t(:saved, :scope => [:app, :admin_general])}"
+        format.html { redirect_to admin_tags_path }
+      else
+        format.html { render :action => 'new' }
+      end
+    end
+  end
+
+  def show
+    @tag = Tag.find(params[:id])
+  end
+
+  def edit
+    @tag = Tag.find(params[:id])
+  end
+
+  def update
+    @tag = Tag.find(params[:id])
+    new_attributes = params[:tag]
+    if @existing_tag = Tag.find_by_name(new_attributes[:name].strip)
+      @tag.taggings.update_all(:tag_id => @existing_tag.id)
+      @tag.destroy
+      @tag = @existing_tag
+    else
+      @tag.update_attributes(params[:tag])
+    end
+    respond_to do |format|
+      if @tag.valid?
+        flash[:notice] = "#{@tag.name}  #{t(:saved, :scope => [:app, :admin_general])}"
+        format.html { redirect_to admin_tag_path(@tag) }
+      else
+        format.html { render :action => 'edit' }
+      end
+    end
+  end
+
+  def destroy
+    @tag = Tag.find(params[:id])
+    if @tag.destroy
+      flash[:notice] = "#{@tag.name}  #{t(:deleted, :scope => [:app, :admin_general])}"
+    end
+    respond_to do |format|
+      format.html { redirect_to admin_tags_path }
+    end
+  end
+
+  def search
+    @tags = Tag.where("name LIKE ?", "#{params[:query].downcase.strip}%")
+    respond_to do |format|
+      format.js
+    end
+  end
+end

data/app/controllers/admin/users_controller.rb

@@ -0,0 +1,55 @@
+class Admin::UsersController < ApplicationController
+  respond_to :html
+  include Porthos::Admin
+
+  def index
+    @users = apply_scopes(User).page(params[:page])
+    respond_with @users
+  end
+
+  def search
+    query = params[:query]
+    page  = params[:page] || 1
+    @search = User.search do
+      keywords(query)
+      paginate :page => page
+    end
+    @query = query
+    @page = page
+    respond_to do |format|
+      format.html
+    end
+  end
+
+  def new
+    @user = User.new
+  end
+
+  def create
+    @user = User.new(params[:user])
+    if @user.save
+      flash[:notice] = "#{@user.name} #{t(:saved, :scope => [:app, :admin_general])}"
+    end
+    respond_with @user, :location => (params[:return_to] || admin_users_path)
+  end
+
+  def edit
+    @user = User.find(params[:id])
+  end
+
+  def update
+    @user = User.find(params[:id])
+    if @user.update_attributes(params[:user])
+      flash[:notice] = "#{@user.name} #{t(:saved, :scope => [:app, :admin_general])}"
+    end
+    respond_with @user, :location => (params[:return_to] || admin_users_path)
+  end
+
+  def destroy
+    @user = User.find(params[:id])
+    @user.destroy
+    flash[:notice] = "#{@user.name} #{t(:deleted, :scope => [:app, :admin_general])}"
+    respond_with @user, :location => (params[:return_to] || admin_users_path)
+  end
+
+end

data/app/controllers/application_controller.rb

@@ -0,0 +1,8 @@
+class ApplicationController < ActionController::Base
+  rescue_from ActiveRecord::RecordNotFound, :with => :record_not_found
+
+private
+  def record_not_found
+    render :file => 'shared/404', :status => 404
+  end
+end

data/app/controllers/pages_controller.rb

@@ -0,0 +1,115 @@
+class PagesController < ApplicationController
+  include Porthos::Public
+
+  before_filter :only => :preview do |c|
+    c.send :authenticate!
+  end
+
+  def index
+    @page_template = PageTemplate.first(handle: node.handle)
+    template = @page_template ? @page_template.template : PageFileTemplate.default
+    @page_renderer = page_renderer(template, {
+      :page_template => @page_template
+    })
+
+    respond_to do |format|
+      format.html { render template: template.views.index }
+      format.rss  { render template: template.views.index, layout: false }
+    end
+  end
+
+  def show
+    @page = if params[:id].is_a?(BSON::ObjectId) || BSON::ObjectId.legal?(params[:id])
+      Item.published.find(params[:id])
+    else
+      Item.published.where(uri: params[:id], handle: params[:handle]).first
+    end
+    raise ActiveRecord::RecordNotFound unless @page
+
+    template = @page.template
+    @page_renderer = page_renderer(template, page_template: @page.page_template, page: @page)
+
+    if !@page.restricted? || signed_in?
+      respond_to do |format|
+        format.html { render :template => template.views.show }
+      end
+    else
+      return authenticate!
+    end
+  end
+
+  def preview
+    @page = Page.find(params[:id])
+    template = @page.page_template.template
+    @page_renderer = page_renderer(template, page_template: @page.page_template, page: @page)
+    respond_to do |format|
+      format.html { render :template => template.views.show }
+    end
+  end
+
+  def search
+    filters = params[:filters] || {}
+    @page_template = PageTemplate.where(handle: node.handle).first
+
+    template = @page_template ? @page_template.template : PageTemplate.default
+
+    search_query = params[:query] if params[:query].present?
+    if search_query.present? or filters.any?
+      page_template = @page_template
+      @search = Page.search do
+        keywords search_query
+        if filters.any?
+          dynamic :custom_attributes do
+            filters.each do |key, value|
+              with(key.to_sym, value) unless value.blank?
+            end
+          end
+        end
+        with(:is_active, true)
+        with(:is_restricted, false)
+        with(:page_template_id, page_template.id) if page_template
+        with(:published_on).less_than Time.now
+      end
+      @query, @filters = params[:query], filters
+    end
+    respond_to do |format|
+      format.html { render :template => template.views.search }
+    end
+  end
+
+  def categories
+    @page_template = PageTemplate.where(handle: node.handle).first
+    template = @page_template ? @page_template.template : PageTemplate.default
+    @page_renderer = page_renderer(template, page_template: @page_template)
+
+    respond_to do |format|
+      format.html { render template: template.views.categories }
+    end
+  end
+
+  def category
+    @page_template = PageTemplate.where(handle: node.handle).first
+    template = @page_template ? @page_template.template : PageTemplate.default
+    @page_renderer = page_renderer(template, page_template: @page_template)
+    respond_to do |format|
+      format.html { render template: template.views.category }
+    end
+  end
+
+  def tagged_with
+    @page_template = PageTemplate.where(handle: node.handle).first
+    template = @page_template ? @page_template.template : PageTemplate.default
+    @page_renderer = page_renderer(template, page_template: @page_template)
+
+    respond_to do |format|
+      format.html { render template: template.views.tagged_with }
+    end
+  end
+
+protected
+
+  def page_renderer(template, objects = {})
+    "#{template.name.camelize}Renderer::#{self.action_name.camelize}".constantize.new(self, objects)
+  end
+
+end

data/app/helpers/data_helper.rb

@@ -0,0 +1,11 @@
+module DataHelper
+  def link_path(link)
+    if link
+      if link['url'].present?
+        link.url
+      elsif link.resource
+        link.resource['url'] ? link.resource.url : page_path(link.resource)
+      end
+    end
+  end
+end

data/app/helpers/link_lists_helper.rb

@@ -0,0 +1,16 @@
+module LinkListsHelper
+  def navigation(link_list, options = {})
+    seperator = options.delete(:seperator) || ' '
+    content_tag 'nav', navigation_links(link_list).join(seperator).html_safe, { :class => link_list.handle }.merge(options)
+  end
+
+  def navigation_links(link_list)
+    link_list.links.map do |link|
+      if !!request.fullpath.starts_with?(link.url)
+        link_to(link.title, link.url, :class => 'current')
+      else
+        link_to(link.title, link.url)
+      end
+    end
+  end
+end

data/app/models/asset.rb

@@ -0,0 +1,189 @@
+class Asset
+  include MongoMapper::Document
+  include Tanker
+
+  taggable
+
+  key :name, String
+  key :extension, String
+  key :mime_type, String
+  key :filetype, String
+  key :size, Integer
+  key :title, String
+  key :author, String
+  key :description, String
+  key :reference_number, String
+  key :hidden, Boolean, :default => lambda { false }
+  key :created_by_id, ObjectId
+  key :_usages, Array, default: lambda { [] }
+  timestamps!
+
+  tankit Porthos.config.tanking.index_name, :as => 'Asset' do
+    indexes :name
+    indexes :title
+    indexes :author
+    indexes :description
+    indexes :reference_number
+    indexes :tag_names
+    indexes :hidden
+  end
+
+  class_attribute :filetypes
+  self.filetypes = {
+    :image => %w(jpg jpeg png gif tiff tif),
+    :video => %w(flv mov qt mpg avi mp4),
+    :sound => %w(mp3 wav aiff aif),
+    :pdf   => %w(pdf),
+    :document => []
+  }
+
+  belongs_to :created_by,
+             :class_name => 'User'
+
+  scope :is_hidden,  lambda { |hidden|
+    where(:hidden => hidden)
+  }
+
+  scope :created_by, lambda { |user_id|
+    where(:created_by_id => user_id)
+  }
+
+  scope :by_type, lambda { |type|
+    where(:_type => type)
+  }
+
+  scope :by_filetype, lambda { |filetype|
+    where(:filetype => filetype)
+  }
+
+  scope :by_extension, lambda { |extension|
+    if extension.is_a?(Array)
+      where(:extension.in => extension)
+    else
+      where(:extension => extension)
+    end
+  }
+
+  scope :order_by, lambda { |order|
+    sort(order)
+  }
+
+  attr_accessor :file
+  validates_presence_of :file, :if => :new_record?
+
+  before_validation :process, :if => :new_record?
+  after_destroy :cleanup
+
+  after_save proc { |asset| asset.delay.update_tank_indexes }
+  after_destroy proc { |asset| asset.delay.delete_tank_indexes }
+
+  def self.default_filetype
+    filetypes.keys.detect do |key|
+      filetypes[key].empty?
+    end.to_s
+  end
+
+  def full_name
+    @full_name ||= "#{name}.#{extension}"
+  end
+
+  def remote_url
+    @remote_url ||= Porthos.s3_storage.url(full_name)
+  end
+
+  def of_the_type(filetype)
+    type = self.filetypes[filetype.to_sym]
+    type && type.include?(self.extension)
+  end
+
+  def usages
+    @usages ||= _usages.map do |u|
+      u.except('container_id')
+    end.uniq.collect { |u| u['usage_type'].constantize.find(u['usage_id']) }
+  end
+
+  def remove_usage(association)
+    usage = usage_from_association(association)
+    if _usages.include?(usage)
+      _usages.reject! { |u| u == usage }
+      save
+    end
+  end
+
+  def add_usage(association)
+    usage = usage_from_association(association)
+    unless _usages.include?(usage)
+      _usages << usage
+      save
+    end
+  end
+
+  class << self
+    def uploaders
+      User.find(self.fields(:created_by_id).distinct(:created_by_id))
+    end
+
+    def from_upload(attrs)
+      extension = File.extname(attrs[:file].original_filename.downcase).gsub(/\./,'')
+      if filetypes[:image].include?(extension)
+        klass = ImageAsset
+      else
+        klass = Asset
+      end
+      klass.new(attrs)
+    end
+
+    def filetype_for_extension(_extension)
+      Asset.default_filetype.tap do |_filetype|
+        filetypes.each { |key, extensions| _filetype.replace(key.to_s) and break if extensions.include?(_extension) }
+      end
+    end
+  end
+
+protected
+
+  # before validation on create
+  def process
+    extract_attributes_from_file
+    ensure_unique_name
+    store
+  end
+
+  def extract_attributes_from_file
+    self.size      = file.size
+    self.mime_type = MIME::Types.type_for(file.original_filename).first.to_s
+    self.extension = File.extname(file.original_filename).gsub(/\./,'').gsub(/\?.*/,'').downcase
+    file.original_filename.gsub(".#{read_attribute(:extension)}",'').tap do |original_filename|
+      self.name    = original_filename.parameterize.to_s unless self.name.present?
+      self.title   = original_filename unless self.title.present?
+    end
+    self.filetype = Asset.filetype_for_extension(extension)
+  end
+
+  def ensure_unique_name
+    while !Asset.where(:name => self.name).count.zero? do
+      self.name = "#{self.name}_#{SecureRandom.hex(8)}"
+    end
+  end
+
+  def store
+    unless Porthos.s3_storage.store(file, full_name)
+      errors[:file] << t(:unable_to_store)
+    end
+    File.unlink(file.path) if file.respond_to?(:path)
+  end
+
+  # after destroy
+  def cleanup
+    Porthos.s3_storage.destroy(full_name)
+  end
+
+  def usage_from_association(association)
+    {
+      'container_id' => association.id,
+      'usage_type' => association._root_document.class.model_name,
+      'usage_id' => association._root_document.id.to_s
+    }
+  end
+
+end