muck-raker 0.2.11 → 0.3.1

data/.gitignore

@@ -1,30 +0,0 @@
-**/*.pid
-log/*.log
-log/*.pid
-tmp
-.DS_Store
-public/cache/**/*
-public/system/**/*
-doc/**/*
-db/*.sqlite3
-.project
-.loadpath
-nbproject/
-.idea
-testjour.log
-*.so
-*.o
-Makefile
-mkmf.log
-*.bundle
-conftest
-content/
-REVISION
-deploy.rb
-pkg/*
-*.sw?
-.DS_Store
-coverage
-rdoc
-pkg
-test/feed_archive

data/app/controllers/admin/muck/feeds_controller.rb

@@ -1,40 +0,0 @@
-class Admin::Muck::FeedsController < Admin::Muck::BaseController
-
-  unloadable
-
-  def index
-    @feeds = Feed.find(:all, :order => (params[:order] || 'created_at') + (params[:asc] == 'false' ? ' DESC' : ' ASC') + ', title', :include => [:default_language]).paginate(:page => @page, :per_page => @per_page)
-    respond_to do |format|
-      format.html { render :template => 'admin/feeds/index' }
-      format.xml  { render :xml => @feeds.to_xml }
-    end
-  end
-
-  def update
-    feed = Feed.find(params[:id])
-    if params[:status] == 'approve'
-      approve(feed)
-      flash[:notice] = t('muck.raker.feed_validated_message')
-    elsif params[:status] == 'ban'
-      ban(feed)
-      flash[:notice] = t('muck.raker.feed_banned_message')
-    end
-    respond_to do |format|
-      format.html { redirect_to admin_feeds_path }
-    end
-  end
-
-  protected
-  
-    def ban(feed)
-      feed.entries.destroy_all
-      feed.status = MuckRaker::Status::BANNED
-      feed.save!
-    end
-
-    def approve(feed)
-      feed.status = MuckRaker::Status::APPROVED
-      feed.save!
-    end
-  
-end

data/app/controllers/admin/muck/oai_endpoints_controller.rb

@@ -1,13 +0,0 @@
-class Admin::Muck::OaiEndpointsController < Admin::Muck::BaseController
-
-  unloadable
-  
-  def index
-    @oai_endpoints = OaiEndpoint.by_newest.paginate(:page => @page, :per_page => @per_page)
-    respond_to do |format|
-      format.html { render :template => 'admin/oai_endpoints/index' }
-      format.xml  { render :xml => @oai_endpoints.to_xml }
-    end
-  end
-
-end

data/app/controllers/muck/aggregation_feeds_controller.rb

@@ -1,43 +0,0 @@
-class Muck::AggregationFeedsController < ApplicationController
-
-  unloadable
-  
-  before_filter :login_required
-
-  def destroy
-    @aggregation_feed = AggregationFeed.find(params[:id]) rescue nil if params[:id] && params[:id].to_i > 0
-    @aggregation_feed ||= AggregationFeed.find_by_feed_id_and_aggregation_id(params[:feed_id], params[:aggregation_id])
-    @aggregation = @aggregation_feed.aggregation
-    if has_aggregation_permission?
-      @aggregation_feed.destroy
-      respond_to do |format|
-        message = I18n.t('muck.raker.feed_remove')
-        format.html do
-          flash[:notice] = message
-          redirect_to polymorphic_url([@aggregation.ownable, @aggregation])
-        end
-        format.json { render :json => { :success => true, :message => message }.as_json }
-        format.xml  { head :ok }
-      end
-    end
-  end
-
-  protected
-  
-    def has_aggregation_permission?
-      if !@aggregation.can_edit?(current_user)
-        message = I18n.t('muck.raker.cant_modify_aggregation')
-        respond_to do |format|
-          format.html do
-            flash[:notice] = message
-            redirect_to polymorphic_url([@aggregation.ownable, @aggregation])
-          end
-          format.js { render(:update) {|page| page.alert message} }
-          format.json { render :json => { :success => false, :message => message }.as_json }
-        end
-      else
-        true
-      end
-    end
-  
-end

data/app/controllers/muck/aggregations_controller.rb

@@ -1,234 +0,0 @@
-class Muck::AggregationsController < ApplicationController
-
-  unloadable
-  
-  #before_filter :adjust_format_for_iphone
-  
-  require 'cgi'
-  
-  before_filter :login_required, :except => [:index, :show, :preview, :rss_discovery]
-  before_filter :get_owner, :only => [:index, :preview, :new, :create]
-  before_filter :check_user_permissions, :only => [:create]
-  before_filter :get_aggregation, :only => [:destroy, :edit, :update, :show, :rss_discovery]
-  before_filter :has_aggregation_permission?, :only => [:destroy, :edit, :update]
-  before_filter :setup_feed_display_variables, :only => [:preview, :update]
-  def index
-    if @parent
-      @aggregations = @parent.aggregations.by_title
-    else
-      @aggregations = Aggregation.newest
-    end
-    respond_to do |format|
-      format.html { render(:template => 'aggregations/index') }
-      format.iphone { render(:template => 'aggregations/index') }
-    end
-  end
-  
-  def rss_discovery
-    @feeds = @aggregation.feeds
-    render :template => 'aggregations/rss_discovery'
-  end
-  
-  def show
-    @page_title = @aggregation.title
-    
-    @photo_feeds = @aggregation.photo_feeds
-    @video_feeds = @aggregation.video_feeds
-    @bookmark_feeds = @aggregation.bookmark_feeds
-    @music_feeds = @aggregation.music_feeds
-    @general_feeds = @aggregation.general_feeds
-    
-    if GlobalConfig.render_feeds_client_side
-      
-    elsif GlobalConfig.render_feeds_server_side
-      @feeds = @aggregation.feeds
-    else
-      @entries = @aggregation.feeds.entries.paginate(:page => @page, :per_page => @per_page)
-    end
-    respond_to do |format|
-      format.html { render(:template => 'aggregations/show') }
-      format.opml { render(:layout => false) }
-      format.rss {}
-    end
-  end
-  
-  def preview
-    if params[:terms].blank?
-      flash[:error] = I18n.t('muck.raker.no_terms_error')
-      redirect_to new_polymorphic_url([@parent, :aggregation])
-    else
-      terms = params[:terms]
-      terms = terms.join(' ') if terms.is_a?(Array)
-      
-      #@feeds = Service.build_tag_feeds(terms, current_user, params[:service_ids])
-      
-      @photo_feeds = Service.build_photo_feeds(terms, current_user)
-      @video_feeds = Service.build_video_feeds(terms, current_user)
-      @bookmark_feeds = Service.build_bookmark_feeds(terms, current_user)
-      @music_feeds = Service.build_music_feeds(terms, current_user)
-      @general_feeds = Service.build_general_feeds(terms, current_user)
-
-      @discovered_feeds = Overlord::GoogleFeedRequest.find_feeds(terms)
-      @title = terms.titleize
-      @terms = terms
-      
-      @aggregation = Aggregation.new(:title => @title, :terms => @terms)
-
-      respond_to do |format|
-        format.html { render :template => 'aggregations/preview' }
-      end
-    end
-  end
-
-  def new
-    @page_title = I18n.t('muck.raker.new_aggregation')
-    @service_categories = ServiceCategory.sorted.find(:all, :include => [:tag_services])
-    respond_to do |format|
-      format.html { render :template => 'aggregations/new' }
-    end
-  end
-  
-  def create
-    @aggregation = Aggregation.create(params[:aggregation])
-    @parent.aggregations << @aggregation if @parent # associate the parent if present
-    
-    # build a list of feeds and associate them with the aggregation
-    @aggregation.add_feeds(current_user, params[:service_ids])
-    @aggregation.add_feeds_by_uri(current_user, params[:uris])
-
-    respond_to do |format|
-      flash[:notice] = I18n.t('muck.raker.add_feeds_to_aggregation', :title => @aggregation.title)
-      format.html { redirect_to(edit_aggregation_path(@aggregation)) }
-      format.xml  { render :xml => @aggregation, :status => :created, :location => @aggregation }
-    end
-
-  rescue ActiveRecord::RecordInvalid => ex
-    respond_to do |format|
-      format.html { render :action => "aggregations/new" }
-      format.xml  { render :xml => @aggregation.errors }
-    end
-  end
-  
-  def edit
-    setup_edit
-    respond_to do |format|
-      format.html { render :template => 'aggregations/edit' }
-    end
-  end
-
-  def update
-    if params[:aggregation]
-      @aggregation.update_attributes!(params[:aggregation])
-      flash[:notice] = I18n.t('muck.raker.aggregation_updated')
-    end
-    @feeds = []
-    if params[:uri]
-      @feeds = Feed.feeds_from_uri(params[:uri], current_user)
-      @aggregation.safe_add_feeds(@feeds)
-    elsif params[:service_ids]
-      @aggregation.terms = @aggregation.terms + ",#{params[:terms]}"
-      @aggregation.save!
-      @feeds = @aggregation.add_feeds(current_user, params[:service_ids])
-    end
-    
-    message = I18n.t('muck.raker.no_feeds_found') if @feeds.blank?
-    
-    respond_to do |format|
-      format.html { redirect_to edit_polymorphic_url([@aggregation.ownable, @aggregation]) }
-      format.xml  { head :ok }
-      format.json do
-        render :json => { :aggregation => @aggregation,
-                          :feeds => @feeds,
-                          :message => message,
-                          :success => true,
-                          :html => get_google_feed_html }.as_json
-      end
-    end
-  rescue ActiveRecord::RecordInvalid => ex
-    respond_to do |format|
-      format.html do
-        setup_edit
-        render :template => "aggregations/edit"
-      end
-      format.json { render :json => { :aggregation => @aggregation, 
-                                      :feeds => @feeds, 
-                                      :message => ex.to_s, 
-                                      :success => false, 
-                                      :html => '' }.as_json }
-      format.xml  { render :xml => @aggregation.errors }
-    end
-  end
-
-  def destroy
-    @aggregation = Aggregation.find(params[:id])
-    @aggregation.destroy
-    respond_to do |format|
-      flash[:notice] = I18n.t('muck.raker.aggregation_deleted', :title => @aggregation.title)
-      format.html { redirect_to polymorphic_url([@aggregation.ownable, :aggregations]) }
-      format.xml  { head :ok }
-    end
-  end
-
-  protected
-    
-    def setup_edit
-      @feeds = @aggregation.all_feeds
-      setup_feed_display_variables
-      @service_categories = ServiceCategory.sorted.find(:all, :include => [:tag_services])
-      @page_title = I18n.t('muck.raker.edit_aggregation_title', :title => @aggregation.title)
-    end
-    
-    def get_owner
-      @parent = get_parent
-    end
-    
-    def check_user_permissions
-      unless has_permission?
-        permission_denied
-      end
-    end
-    
-    def get_aggregation
-      @aggregation = Aggregation.find(params[:id])
-    end
-    
-    def has_aggregation_permission?
-      if !@aggregation.can_edit?(current_user)
-        message = I18n.t('muck.raker.cant_modify_aggregation')
-        respond_to do |format|
-          format.html do
-            flash[:notice] = message
-            redirect_back_or_default current_user
-          end
-          format.js { render(:update) {|page| page.alert message} }
-        end
-      end
-    end
-    
-    def has_permission?
-      if @parent.blank?
-        admin?
-      else
-        @parent.can_edit?(current_user)
-      end
-    end
-  
-    def setup_feed_display_variables
-      @show_controls = show_controls?
-      @number_of_items = 4
-      @number_of_images = 6
-      @number_of_videos = 6
-    end
-    
-    # determines whether or not to show admin controls (ie save aggregation)
-    def show_controls?
-      logged_in?
-    end
-    
-    def get_google_feed_html
-      render_as_html do
-        render_to_string(:partial => 'aggregations/feeds')
-      end
-    end
-    
-end

data/app/controllers/muck/entries_controller.rb

@@ -1,102 +0,0 @@
-class Muck::EntriesController < ApplicationController
-  
-  unloadable
-  
-  def initialize
-    @no_index = true
-  end
-  
-  def index
-    @grain_size = params[:grain_size] || 'all'
-    @tag_cloud = TagCloud.language_tags(Language.locale_id, @grain_size) unless fragment_exist?({:controller => 'entries', :action => 'index', :language => Language.locale_id})
-    respond_to do |format|
-      format.html { render :template => 'entries/index' }
-    end
-  end
-  
-  def browse_by_tags
-    @tag_filter = params[:tags]
-    @grain_size = params[:grain_size] || 'all'
-    if !fragment_exist?({:controller => 'entries', :action => 'index', :language => Language.locale_id, :filter => @tag_filter, :grain_size => @grain_size})
-      @search = @tag_filter.split('/').join(' AND ') if !@tag_filter.empty? 
-      @tag_cloud = TagCloud.language_tags(Language.locale_id, @grain_size, @tag_filter)
-      _search(:and)
-    end
-    respond_to do |format|
-      format.html { render :template => 'entries/browse_by_tags' }
-    end
-  end
-  
-  def search
-    @search = params[:q]
-    @grain_size = params[:grain_size] || 'all'
-    _search
-    respond_to do |format|
-      format.html { render :template => 'entries/search' }
-    end
-  end
-  
-  def show
-    @entry = Entry.find(params[:id], :include => :feed)
-    if @entry.nil?
-      render_text "Unable to find the specified document"
-      return
-    end
-    @entry_title = @entry.title + ' (' + @entry.feed.short_title + ')'
-    @page_title = @entry_title + ' - ' + I18n.t('muck.raker.related_resources_title')
-#    I18n.locale = @entry.language[0..1]
-    @limit = params[:limit] ? params[:limit].to_i : 20
-    @limit = 40 if @limit > 40
-
-    respond_to do |format|
-      format.html do
-        @recommendations = @entry.recommendations(@limit, 'relevance', params[:details] == 'true')
-        if params[:details] == 'true'
-          render :template => "entries/details"
-        else
-          render :template => "entries/show"
-        end
-      end
-      format.xml  { render :xml => @entry }
-    end
-  end
-  
-  def track_clicks
-    user_agent = request.env['HTTP_USER_AGENT']
-    redirect_to Entry.track_click(session, params[:id], request.env['HTTP_REFERER'], params[:target], request.env['HTTP_X_FORWARDED_FOR'], user_agent) if !/Googlebot/.match(user_agent) 
-  end
-  
-  def collections
-    @feeds = Feed.find(:all, :order => "harvested_from_title, title")
-    @languages = Language.find(:all, :order => "name")
-    render :template => "documents/collections", :layout => "default"
-  end
-
-  protected
-
-  def _search operator = :or
-    @page = (params[:page] || 1).to_i
-    @per_page = (params[:per_page] || 10).to_i
-    @offset = (@page-1)*@per_page
-    if !@search.nil?
-      @term_list = URI.escape(@search) 
-      results = Entry.search(@search, @grain_size, I18n.locale.to_s, @per_page, @offset, operator)
-      @hit_count = results.total
-      @results = results.results
-      @paginated_results = @results.paginate(:page => @page, :per_page => @per_page, :total_entries => @hit_count)
-      log_query(current_user.nil? ? request.remote_addr : current_user.id, Language.locale_id, @tag_filter.nil? ? 'search' : 'browse', @search, @grain_size, @hit_count)
-    end
-  rescue MuckRaker::Exceptions::LanguageNotSupported => ex
-    @hit_count = 0
-    @results = []
-    flash[:error] = ex.to_s
-  end
-  
-  def query_logger
-    @@query_logger ||= Logger.new("#{RAILS_ROOT}/log/queries_#{Date.today}.log")
-  end
-  
-  def log_query(user_id, locale, search_type, query, grain_size, hits)
-    query_logger.info "#{Time.new.to_i},#{user_id},#{locale},#{search_type},\"#{query.gsub(/"/, '\\\\"')}\",#{grain_size},#{hits}"
-  end
-end

data/app/controllers/muck/feed_previews_controller.rb

@@ -1,33 +0,0 @@
-class Muck::FeedPreviewsController < ApplicationController
-
-  unloadable
-
-  def new
-    respond_to do |format|
-      format.pjs do
-        render_as_html do
-          render :template => 'feed_previews/new', :layout => false
-        end
-      end
-      format.html { render :template => 'feed_previews/new' }
-    end
-  end
-
-  def select_feeds
-    @feed = Feed.new(params[:feed])
-    @feeds = Feed.gather_information(@feed.uri).compact
-    respond_to do |format|
-      format.pjs do
-        render_as_html do
-          render :template => 'feed_previews/select_feeds', :layout => false
-        end
-      end
-      format.html { render :template => 'feed_previews/select_feeds' }
-    end
-  end
-  
-  def create
-    
-  end
-
-end

data/app/controllers/muck/feeds_controller.rb

@@ -1,157 +0,0 @@
-class Muck::FeedsController < ApplicationController
-
-  unloadable
-  
-  before_filter :login_required, :except => ['index', 'show']
-  before_filter :get_owner, :except => ['index', 'show']
-  
-  def index
-    @feeds = Feed.find(:all, :conditions => 'status >= 0', :order => (params[:order] || 'title') + (params[:asc] == 'false' ? ' DESC' : ' ASC') + ', title', :include => [:default_language]).paginate(:page => @page, :per_page => @per_page)
-    respond_to do |format|
-      format.html { render :template => 'feeds/index' }
-      format.xml  { render :xml => @feeds.to_xml }
-    end
-  end
-
-  # pass layout=popup to remove most of the chrome
-  def show
-    @feed = Feed.find(params[:id])
-    @entries = @feed.entries.paginate(:page => @page, :per_page => @per_page)
-    respond_to do |format|
-      format.html { render :template => 'feeds/show', :layout => params[:layout] || true  }
-      format.pjs do
-        render :update do |page|
-          page.replace_html('feed-container', :partial => 'feeds/feed', :object => @feed)
-        end
-      end
-      format.json { render :json => @feed.as_json }
-    end
-  end
-
-  def new
-    respond_to do |format|
-      format.html { render :template => 'feeds/new', :layout => params[:layout] || true }
-    end
-  end
-
-  def new_oai_rss
-    @feed = Feed.new
-    @feed.default_language = Language.find_by_locale('en')
-    @feed.service_id = MuckRaker::Services::RSS
-    @oai_endpoint = OaiEndpoint.new
-    @oai_endpoint.default_language = @feed.default_language
-    respond_to do |format|
-      format.html { render :template => 'feeds/new_oai_rss', :layout => 'popup' }
-    end
-  end
-  
-  def new_extended
-    respond_to do |format|
-      format.html { render :template => 'feeds/new_extended', :layout => 'popup' }
-    end
-  end
-
-  def create
-
-    Feed.discover_feeds(params[:feed][:uri])
-    
-    @feed = Feed.new(params[:feed])
-    @feed.contributor = current_user # record the user that submitted the feed for auditing purposes
-    @feed.harvested_from_display_uri = @feed.display_uri
-    
-    # setup the feed to be harvested
-    @feed.entries_count = 0
-    @feed.last_requested_at = 4.weeks.ago
-    @feed.last_harvested_at = 4.weeks.ago
-
-    @feed.inform_admin # let an admin know that a global feed was added.
-
-    # associate the parent if present
-    @parent.feeds << @feed if @parent
-    
-    after_create_response(@feed.save)
-  end
-
-  def edit
-    @feed = Feed.find(params[:id])
-    respond_to do |format|
-      format.html { render :template => 'feeds/edit', :layout => 'popup' }
-    end
-  end
-  
-  def update
-    @feed = Feed.find(params[:id])
-    after_update_response(@feed.update_attributes(params[:feed]))
-  end
-
-  def destroy
-    @feed = Feed.find(params[:id])
-    @feed.destroy
-    after_destroy_response
-  end
-  
-  protected
-
-    def get_owner
-      @parent = get_parent
-      unless has_permission_to_add_feed(current_user, @parent)
-        permission_denied
-      end
-    end
-  
-    def has_permission_to_add_feed(user, parent)
-      return false if user.blank?
-      return true if user.admin?
-      return false if parent.blank?
-      user == parent || parent.can_add_feed?(user)
-    end
-    
-    # Handles render and redirect after success or failure of the
-    # create action.  Override to perform a different action
-    # fail_template determines which 'new' is rendered in the event that
-    # the create is not successful.
-    def after_create_response(success)
-      if success
-        flash[:notice] = t('muck.raker.feed_successfully_created')
-        respond_to do |format|
-          format.html { redirect_to feed_path(@feed) }
-          format.pjs { redirect_to feed_path(@feed, :layout => 'popup') }
-          format.json { render :json => @feed.as_json }
-          format.xml  { head :created, :location => feed_url(@feed) }
-        end
-      else
-        fail_template = params[:new_template] || 'feeds/new'
-        respond_to do |format|
-          format.html { render :template => fail_template }
-          format.pjs { render :template => fail_template, :layout => false }
-          format.json { render :json => @feed.as_json }
-          format.xml  { render :xml => @feed.errors.to_xml }
-        end
-      end
-    end
-  
-    # Handles render and redirect after success or failure of the
-    # update action.  Override to perform a different action
-    def after_update_response(success)
-      respond_to do |format|
-        if success
-          flash[:notice] = t('muck.raker.feed_successfully_updated')
-          format.html { redirect_to feed_path(@feed) }
-          format.xml  { head :ok }
-        else
-          format.html { render :template => "feeds/edit" }
-          format.xml  { render :xml => @feed.errors.to_xml }
-        end
-      end
-    end
-    
-    # Handles render and redirect after the delete action.
-    # Override to perform a different action
-    def after_destroy_response
-      respond_to do |format|
-        format.html { redirect_to feeds_path }
-        format.xml  { head :ok }
-      end
-    end
-    
-end