lentil 0.0.1.pre

data/lib/lentil/admin/images.rb

@@ -0,0 +1,209 @@
+if defined?(ActiveAdmin)
+  ActiveAdmin.register Lentil::Image do
+    actions :index, :show
+
+    config.batch_actions = false
+    config.per_page = 10
+
+    filter :state, :as => :select, :collection => proc { Lentil::Image::States }
+    filter :user_user_name, :as => :string, :label => "Username"
+    filter :user_full_name, :as => :string, :label => "Full Name"
+    filter :staff_like, :as => :select
+    filter :do_not_request_donation, :as => :select
+    filter :win_pct
+    filter :popular_score, :label => "Score"
+    filter :description
+    filter :updated_at
+    filter :url, :label => "Service URL"
+    filter :id
+
+    action_item :only => :show do
+      link_to('Update Image', update_image_admin_lentil_image_path(lentil_image))
+    end
+    action_item { link_to "Moderate New", moderate_admin_lentil_images_path }
+    action_item { link_to "Moderate Skipped", moderate_skipped_admin_lentil_images_path }
+    action_item { link_to "Moderate Flagged", moderate_flagged_admin_lentil_images_path }
+    action_item { link_to "Flagging History", flagging_history_admin_lentil_images_path }
+    action_item { link_to "Add Instagram Image", manual_input_admin_lentil_images_path }
+
+    index do
+      column "Image" do |image|
+        link_to(image_tag(image.image_url, :class => "moderation_thumbnail"), admin_lentil_image_path(image))
+      end
+      column :id
+      column :description
+      column "User", :user do |i|
+        names = []
+        names << i.user.user_name
+        names << i.user.full_name
+        names.join("\n")
+      end
+      column "All Tags" do |image|
+        image.tags.map{|tag| tag.name}.join(' | ')
+      end
+      column "Likes", :like_votes_count
+      column :staff_like
+      column "Battles", :battles_count, :sortable => false
+      column :win_pct, :sortable => :win_pct do |image|
+        if image.win_pct
+          number_to_percentage(image.win_pct, :precision => 0)
+        else
+          "No Battles Fought"
+        end
+      end
+      column "Score", :popular_score
+      column :state do |image|
+        image.state_name
+      end
+    end
+
+    show :title => :id do |image|
+      attributes_table do
+        row :id
+        row :description
+        row :user
+        row :moderator do |image|
+          unless image.moderator_id.nil?
+            image.moderator.email
+          else
+            "Image has not been moderated."
+          end
+        end
+        row :created_at
+        row :updated_at
+        row :like_votes_count
+        row :url
+        row "All Tags" do |image|
+          unless image.tags.empty?
+            image.tags.map{|tag| tag.name}.join(' | ')
+          else
+            "Image has not been tagged."
+          end
+        end
+        row :staff_like
+        row :do_not_request_donation
+        row :state do
+          image.state_name
+        end
+        row :image do
+          link_to(image_tag(image.image_url), admin_lentil_image_path(image))
+        end
+      end
+      active_admin_comments
+    end
+
+    controller do
+      def update_images(images, images_params, second_moderation)
+        images.each do |image|
+          image_params = images_params[image.id.to_s]
+
+          incoming_tag_ids = image_params['tag_ids'].reject(&:empty?)
+          existing_tag_ids = []
+          service_tag_ids = []
+
+          image.taggings.each do |tagging|
+            existing_tag_ids << tagging[:tag_id]
+            if tagging[:staff_tag] == false
+              service_tag_ids << tagging[:tag_id]
+            end
+          end
+
+          new_tag_ids = incoming_tag_ids - existing_tag_ids
+          tag_ids_to_keep = incoming_tag_ids - new_tag_ids + service_tag_ids
+
+          new_taggings = []
+          new_tag_ids.each do |id|
+            new_taggings << image.taggings.build(:tag_id => id, :staff_tag => true)
+          end
+
+          taggings_to_keep = image.taggings.where(:tag_id => tag_ids_to_keep)
+          taggings = new_taggings + taggings_to_keep
+
+          image.update_attributes!(:state => image_params['state'], :taggings => taggings, :staff_like => image_params['staff_like'],
+            :moderator => current_admin_user, :moderated_at => DateTime.now, :second_moderation => second_moderation, :do_not_request_donation => image_params['do_not_request_donation'])
+        end
+      end
+    end
+
+    member_action :update_image do
+      id = params['id']
+      @second_moderation = false
+      @images = Lentil::Image.where(id: id)
+      render "admin/lentil_images/moderate"
+    end
+
+    collection_action :moderate do
+      @second_moderation = false
+      @images = Lentil::Image.where(state: Lentil::Image::States[:pending], moderator_id: nil).paginate(:page => params[:page], :per_page => 10)
+    end
+
+    collection_action :moderate_skipped do
+      @second_moderation = false
+      @images = Lentil::Image.where(state: Lentil::Image::States[:pending]).where("moderator_id IS NOT NULL").paginate(:page => params[:page], :per_page => 10)
+      render "/admin/lentil_images/moderate"
+    end
+
+    collection_action :moderate_flagged do
+      @second_moderation = true
+      @images = Lentil::Image.joins(:flags).group("lentil_images.id").having("count(lentil_flags.id) > 0").where(:second_moderation => false).paginate(:page => params[:page], :per_page => 10)
+      render "/admin/lentil_images/moderate"
+    end
+
+    collection_action :do_moderation, :method => :post do
+      images = Lentil::Image.find(params[:image].keys)
+      images_params = params[:image]
+      second_moderation = params[:moderation]['second_moderation']
+
+      begin
+        update_images(images, images_params, second_moderation)
+      rescue => e
+        message = "Error moderating images: " + e.to_s
+        redirect_to :back, :flash => {:error => message}
+      else
+        number_of_images = params['image'].size
+        plural = 'image'.pluralize(number_of_images)
+        message = number_of_images.to_s + " " + plural + " moderated."
+        redirect_to :back, notice: message
+      end
+    end
+
+    collection_action :flagging_history do
+      @images = Lentil::Image.joins(:flags).group("lentil_images.id").having("count(lentil_flags.id) > 0").paginate(:page => params[:page], :per_page => 10)
+    end
+
+    collection_action :manual_input do
+      @tags = Lentil::Tag.all
+    end
+
+    collection_action :do_manual_input, :method => :post do
+      urls = params[:manual_input][:urls].lines.to_a.map(&:chomp).reject {|url| url.length < 1}
+      total_urls = urls.size
+      image_counter = 0
+      errors = []
+
+      urls.each do |raw_url|
+        url = URI.parse(raw_url) rescue next
+        unless url.kind_of?(URI::HTTP) || url.kind_of?(URI::HTTPS)
+          errors << "#{raw_url}: Unable to validate URL"
+          next
+        end
+
+        harvester = Lentil::InstagramHarvester.new
+        begin
+          image = harvester.save_image_from_url(url.to_s)
+        rescue Exception => e
+          errors << "#{raw_url}: #{e.message}"
+          next
+        end
+
+        image_counter += image.length
+
+        if image.length < 1
+          errors << "#{raw_url}: Unknown error (possible duplicate)"
+        end
+      end
+
+      redirect_to :back, notice: "#{image_counter} #{'URL'.pluralize(image_counter)} added (out of #{total_urls})", alert: errors.join('<br>').html_safe
+    end
+  end
+end

data/lib/lentil/admin/tags.rb

@@ -0,0 +1,18 @@
+if defined?(ActiveAdmin)
+  ActiveAdmin.register Lentil::Tag do
+    actions :index, :create, :new
+
+    config.batch_actions = false
+    config.sort_order = "name_asc"
+
+    filter :name
+
+    index :download_links => false do
+      column :id
+      column :name
+      column "Tagsets" do |tag|
+        tag.tagsets.sort_by(&:title).map{ |t| t.title}.join(' | ')
+      end
+    end
+  end
+end

data/lib/lentil/admin/tagsets.rb

@@ -0,0 +1,51 @@
+if defined?(ActiveAdmin)
+  ActiveAdmin.register Lentil::Tagset do
+
+    config.batch_actions = false
+    config.sort_order = "title_asc"
+
+    filter :title
+    filter :description
+
+    scope :all
+    scope :harvesting, :default => true do |tagsets|
+      tagsets.where(:harvest => TRUE)
+    end
+    scope :not_harvesting do |tagsets|
+      tagsets.where(:harvest => FALSE)
+    end
+
+    index :download_links => false do
+      column :id
+      column :title
+      column :description
+      column :tags do |tagset|
+        tagset.tags.sort_by(&:name).map{|t| t.name}.join(' | ')
+      end
+      column :harvest
+      default_actions
+    end
+
+    show do |tagset|
+      attributes_table do
+        row :id
+        row :title
+        row :description
+        row :tags do |tagset|
+          tagset.tags.sort_by(&:name).map{|t| t.name}.join(' | ')
+        end
+        row :harvest
+      end
+    end
+
+    form do |f|
+      f.inputs do
+        f.input :title
+        f.input :description
+        f.input :tags, :input_html => {:class => [:"chzn-select"]}, :collection => Lentil::Tag.all.sort_by(&:name)
+        f.input :harvest
+      end
+      f.actions
+    end
+  end
+end

data/lib/lentil/admin/user.rb

@@ -0,0 +1,20 @@
+if defined?(ActiveAdmin)
+  ActiveAdmin.register Lentil::User do
+    actions :index
+    config.batch_actions = false
+
+    filter :service
+    filter :user_name
+    filter :full_name
+    filter :bio
+
+    index do
+      column :id
+      column :user_name
+      column :full_name
+      column :service
+      column :images_count
+      column :bio, :sortable => false
+    end
+  end
+end

data/lib/lentil/admin/view_helpers.rb

@@ -0,0 +1,11 @@
+module ActiveAdmin::ViewHelpers
+  def action?(action)
+    params[:action] == action
+  end
+
+  def link_to_large_admin_image(image)
+    link_to admin_lentil_image_path(image, :anchor => "show_view_big_image"), :target => "_blank" do
+      image_tag image.image_url, :class => "moderation_thumbnail"
+    end
+  end
+end

data/lib/lentil/engine.rb

@@ -0,0 +1,22 @@
+module Lentil
+  class Engine < ::Rails::Engine
+    isolate_namespace Lentil
+
+    initializer :lentil do
+      # FIXME: why?
+      ActiveAdmin.application.load_paths += [File.expand_path(File.join(Lentil::Engine.root, 'lib/lentil/admin'))]
+
+      config_file = File.join(Rails.root, "/config/lentil_config.yml")
+      if File.exist?(config_file)
+        APP_CONFIG = YAML.load_file(config_file)[Rails.env]
+      end
+    end
+
+    # FIXME: Why is this necessary in order to have access to helpers from within the engine itself?
+    config.to_prepare do
+      ApplicationController.helper(Lentil::ApplicationHelper)
+      ApplicationController.helper(Lentil::ImagesHelper)
+      ApplicationController.helper(Lentil::ThisorthatHelper)
+    end
+  end
+end

data/lib/lentil/instagram_harvester.rb

@@ -0,0 +1,249 @@
+# FIXME: can these be moved to main library file?
+require 'instagram'
+require 'date'
+require 'oembed'
+
+class DuplicateImageError < StandardError
+end
+
+module Lentil
+  # A collection of methods for querying the Instagram API and importing metadata.
+  class InstagramHarvester
+
+    #
+    # Configure the Instagram class in preparation requests.
+    #
+    # @options opts [String] :client_id (Lentil::Engine::APP_CONFIG["instagram_client_id"]) The Instagram client ID
+    # @options opts [String] :client_secret (Lentil::Engine::APP_CONFIG["instagram_client_secret"]) The Instagram client secret
+    # @options opts [String] :access_token (nil) The optional Instagram client ID
+    def configure_connection(opts = {})
+      opts['client_id'] ||= Lentil::Engine::APP_CONFIG["instagram_client_id"]
+      opts['client_secret'] ||= Lentil::Engine::APP_CONFIG["instagram_client_secret"]
+      opts['access_token'] ||= nil
+
+      Instagram.configure do |config|
+        config.client_id = opts['client_id']
+        config.client_secret = opts['client_secret']
+
+        if (opts['access_token'])
+          config.access_token = opts['access_token']
+        end
+      end
+    end
+
+
+    #
+    # Configure the Instagram class in preparation for leaving comments
+    #
+    # @param  access_token = nil [String] Instagram access token for the writing account
+    def configure_comment_connection(access_token = nil)
+      access_token ||= Lentil::Engine::APP_CONFIG["instagram_access_token"] || nil
+      raise "instagram_access_token must be defined as a parameter or in the application config" unless access_token
+      configure_connection({'access_token' => access_token})
+    end
+
+    # Queries the Instagram API for recent images with a given tag.
+    #
+    # @param [String] tag The tag to query by
+    #
+    # @return [Hashie::Mash] The data returned by Instagram API
+    def fetch_recent_images_by_tag(tag = nil)
+      configure_connection
+      tag ||= Lentil::Engine::APP_CONFIG["default_image_search_tag"]
+      Instagram.tag_recent_media(tag, :count=>100)
+    end
+
+
+    # Queries the Instagram API for the image metadata associated with a given ID.
+    #
+    # @param [String] image_id Instagram image ID
+    #
+    # @return [Hashie::Mash] data returned by Instagram API
+    def fetch_image_by_id(image_id)
+      configure_connection
+      Instagram.media_item(image_id)
+    end
+
+
+    # Retrieves an image OEmbed metadata from the public URL using the Instagram OEmbed service
+    #
+    # @param  url [String] The public Instagram image URL
+    #
+    # @return [String] the Instagram image OEmbed data
+    def retrieve_oembed_data_from_url(url)
+      OEmbed::Providers::Instagram.get(url)
+    end
+
+    # Retrieves image metadata via the public URL and imports it
+    #
+    # @param  url [String] The public Instagram image URL
+    #
+    # @return [Array] new image objects
+    def save_image_from_url(url)
+      save_instagram_load(fetch_image_by_id(retrieve_oembed_data_from_url(url).fields["media_id"]))
+    end
+
+
+    # Produce processed image metadata from Instagram metadata.
+    # This metadata is accepted by the save_image method.
+    #
+    # @param [Hashie::Mash] instagram_metadata The single image metadata returned by Instagram API
+    #
+    # @return [Hash] processed image metadata
+    def extract_image_data(instagram_metadata)
+      {
+        url: instagram_metadata.link,
+        external_id: instagram_metadata.id,
+        large_url: instagram_metadata.images.standard_resolution.url,
+        name: instagram_metadata.caption && instagram_metadata.caption.text,
+        tags: instagram_metadata.tags,
+        user: instagram_metadata.user,
+        original_datetime: Time.at(instagram_metadata.created_time.to_i).to_datetime,
+        original_metadata: instagram_metadata
+      }
+    end
+
+
+    # Takes return from Instagram API gem and adds image,
+    # users, and tags to the database.
+    #
+    # @raise [DuplicateImageError] This method does not accept duplicate external image IDs
+    #
+    # @param [Hash] image_data processed Instagram image metadata
+    #
+    # @return [Image] new Image object
+    def save_image(image_data)
+
+      instagram_service = Lentil::Service.where(:name => "Instagram").first
+
+      user_record = instagram_service.users.where(:user_name => image_data[:user][:username]).
+        first_or_create!({:full_name => image_data[:user][:full_name], :bio => image_data[:user][:bio]})
+
+      raise DuplicateImageError, "Duplicate image identifier" unless user_record.
+        images.where(:external_identifier => image_data[:external_id]).first.nil?
+
+      # TODO: Reject duplicates
+      image_record = user_record.images.build({
+        :external_identifier => image_data[:external_id],
+        :description => image_data[:name],
+        :url => image_data[:url],
+        :long_url => image_data[:large_url],
+        :original_datetime => image_data[:original_datetime]
+      })
+
+      # This is a temporary fix for a bug in the Hashie to_hash method.
+      # It's fixed in master and should be in the next release (>1.2.0).
+      image_record.original_metadata = JSON.parse(image_data[:original_metadata].to_json)
+
+      # Default to "All Rights Reserved" until we find out more about licenses
+      # FIXME: Set the default license in the app config
+      unless image_record.licenses.size > 0
+        image_record.licenses << Lentil::License.where(:short_name => "ARR").first
+      end
+
+      image_data[:tags].each {|tag| image_record.tags << Lentil::Tag.where(:name => tag).first_or_create}
+
+      user_record.save!
+      image_record.save!
+      image_record
+    end
+
+    # Takes return from Instagram API gem and adds all new images,
+    # users, and tags to the database.
+    #
+    # @param [Hashie::Mash] instagram_load The content returned by the Instagram gem
+    # @param [Boolean] raise_dupes Whether to raise exceptions for duplicate images
+    #
+    # @raise [DuplicateImageError] If there are duplicate images and raise_dupes is true
+    #
+    # @return [Array] New image objects
+    def save_instagram_load(instagram_load, raise_dupes=false)
+      # Handle collections of images and individual images
+      images = instagram_load
+      
+      if !images.kind_of?(Array)
+        images = [images]
+      end
+
+      images.collect {|image|
+        begin
+          save_image(extract_image_data(image))
+        rescue DuplicateImageError => e
+          raise e if raise_dupes
+          next
+        end
+      }.compact
+    end
+
+
+    #
+    # Call save_instagram_load, but raise exceptions for duplicates.
+    #
+    # @param [Hashie::Mash] instagram_load The content returned by the Instagram gem
+    #
+    # @raise [DuplicateImageError] If there are duplicate images
+    #
+    # @return [Array] New image objects
+    def save_instagram_load!(instagram_load)
+      save_instagram_load(instagram_load, true)
+    end
+
+    #
+    # Retrieve the binary image data for a given Image object
+    #
+    # @param [Image] image An Image model object from the Instagram service
+    #
+    # @raise [Exception] If there are request problems
+    #
+    # @return [String] Binary image data
+    def harvest_image_data(image)
+      response = Typhoeus.get(image.image_url, followlocation: true)
+
+      if response.success?
+        raise "Invalid content type: " + response.headers['Content-Type'] unless (response.headers['Content-Type'] == 'image/jpeg')
+      elsif response.timed_out?
+        raise "Request timed out"
+      elsif response.code == 0
+        raise "Could not get an HTTP response"
+      else
+        raise "HTTP request failed: " + response.code.to_s
+      end
+
+      response.body
+    end
+
+    #
+    # Test if an image is still avaiable
+    #
+    # @param [Image] image An Image model object from the Instagram service
+    #
+    # @raise [Exception] If there are request problems
+    #
+    # @return [Boolean] Whether the image request was successful
+    def test_remote_image(image)
+      response = Typhoeus.head(image.image_url, followlocation: true)
+
+      if response.success?
+        true
+      elsif response.timed_out? || (response.code == 0)
+        nil
+      else
+        false
+      end
+    end
+
+    #
+    # Leave a comment containing the donor agreement on an Instagram image
+    #
+    # @param  image [type] An Image model object from the Instagram service
+    #
+    # @raise [Exception] If a comment submission fails
+    # @authenticated true
+    #
+    # @return [Hashie::Mash] Instagram response
+    def leave_image_comment(image, comment)
+      configure_comment_connection
+      Instagram.client.create_media_comment(image.external_identifier, comment)
+    end
+  end
+end