change learning object creation

Gemfile

@@ -33,7 +33,7 @@ gem 'rack-cors', require: 'rack/cors'
 gem 'rmagick'
 
 # Dspace REST API Integration
-gem 'dspace_rest_client'
+gem 'dspace_rest_client', '2.2.8'
 
 # pretty logs
 gem 'rainbow'

app/builders/learning_object/draft_builder.rb

@@ -20,15 +20,12 @@ class LearningObject::DraftBuilder
     @draft
   end
 
-  private
-
   def self.sanitize_params(args={})
-    _args = args.clone
+    new_args = args.clone
     %w(topics language link school_level).each do |arg|
-      _args.delete(arg)
+      new_args.delete(arg)
     end
-    metadata = [{'key' => 'dc.object.url', 'value' => args[:link]}]
-    _args.merge(metadata: metadata)
+    metadata = { 'dc.object.url' => args[:link] }
+    new_args.merge(metadata: metadata)
   end
-
 end

app/builders/learning_object_builder.rb

@@ -27,40 +27,14 @@ class LearningObjectBuilder
     lo.author = lo.get_metadata_values_of('dc.contributor.author').join(', ')
     lo.description = lo.get_metadata_value_of('dc.description')
 
-    lo.state = :published
+    lo.state = LearningObject.states[:published]
 
     lo
   end
 
-  def self.build_form_params(params={}, publisher = nil)
-    _params = params.clone
-    _params.delete :link
-
-    # build tags
-    _params[:tags] = []
-    params[:tags].try(:each) do |t|
-      _params[:tags] << Tag.find(t['id'])
-    end
-
-    #build language
-    _params[:language] = Language.find(params[:language]) if params[:language].to_i > 0
-
-    # set publisher
-    _params[:publisher] = publisher unless publisher.nil?
-    _params
-  end
-
   def self.dspace_metadata_to_hash(metadata)
     hash = Hash.new { |h, k| h[k] = Array.new(&h.default_proc) }
     metadata.each { |m| hash[m.key] << m.value }
     hash
   end
-
-  # def self.sanitize_form_metadata(params={})
-  #  if !params[:link].blank?
-  #    metadata = [{'key' => 'dc.object.url', 'value' => params[:link]}]
-  #    _args.merge(metadata: metadata)
-  #  end
-  #  _args
-  # end
 end

app/controllers/v1/learning_objects/publishes_controller.rb

+class V1::LearningObjects::PublishesController < ApplicationController
+  before_action :set_learning_object
+  before_action :authorize!
+
+  # POST /learning_objects/:id/publish
+  def create
+    return render status: :ok if @learning_object.published?
+
+    publisher = LearningObjectPublisher.new(DspaceService.create_client)
+    publisher.publish @learning_object
+
+    render status: :ok
+  end
+
+  private
+
+  # Use callbacks to share common setup or constraints between actions.
+  def set_learning_object
+    @learning_object = LearningObject.find(params[:id])
+  end
+
+  def authorize!
+    authorize(@learning_object || LearningObject.new, :update?)
+  end
+
+  # Never trust parameters from the scary internet, only allow the white list through.
+  def publish_params
+    params.permit(:id)
+  end
+end

app/controllers/v1/learning_objects_controller.rb

@@ -14,7 +14,7 @@ class V1::LearningObjectsController < ApplicationController
   def index
     learning_objects = paginate LearningObject.includes(:tags, :publisher, :language, :license)
     serializer = params[:obaa].nil? ? LearningObjectSerializer : LearningObjectObaaSerializer
-    render json: learning_objects , each_serializer: serializer
+    render json: learning_objects, each_serializer: serializer
   end
 
   # GET /learning_objects/1
@@ -27,20 +27,23 @@ class V1::LearningObjectsController < ApplicationController
   # POST /learning_objects
   # POST /learning_objects.json
   def create
-    @learning_object = ::LearningObject::DraftBuilder.build current_user, learning_object_params
+    learning_object = LearningObject.new(learning_object_params)
     publisher = LearningObjectPublisher.new(DspaceService.create_client)
 
-    if publisher.create_draft @learning_object
-      render json: @learning_object, status: :created
+    if publisher.create_draft(learning_object, current_user)
+      render json: learning_object, status: :created
     else
-      render json: @learning_object.errors, status: :unprocessable_entity
+      render json: learning_object.errors, status: :unprocessable_entity
     end
   end
 
   # PATCH/PUT /learning_objects/1
   # PATCH/PUT /learning_objects/1.json
   def update
-    if LearningObject.update(learning_object_params)
+    if @learning_object.update(learning_object_params)
+      publisher = LearningObjectPublisher.new(DspaceService.create_client)
+      publisher.update_dspace(@learning_object)
+
       render json: @learning_object, status: :ok
     else
       render json: @learning_object.errors, status: :unprocessable_entity
@@ -50,7 +53,7 @@ class V1::LearningObjectsController < ApplicationController
   # DELETE /learning_objects/1
   # DELETE /learning_objects/1.json
   def destroy
-    LearningObject.destroy @learning_object
+    LearningObject.destroy(@learning_object)
     render status: :ok
   end
 
@@ -68,12 +71,11 @@ class V1::LearningObjectsController < ApplicationController
 
   # Never trust parameters from the scary internet, only allow the white list through.
   def learning_object_params
-    params[:learning_object].permit(:author, :name, :object_type_id, :description, :school_level, :language_id, :link, tags: [:name])
+    params[:learning_object].permit(:author, :name, :object_type_id, :description, :license_id, :software, :language_id, :link, tags: [:name])
   end
 
   def authorize!
     @learning_object ||= LearningObject.new
     authorize @learning_object
   end
-
 end

app/models/learning_object.rb

@@ -56,10 +56,10 @@ class LearningObject < ApplicationRecord
   belongs_to :object_type
   belongs_to :attachment, class_name: 'LearningObject::Attachment'
 
-  validates_presence_of :name, :publisher, :object_type, :language, :author
-  validates :id_dspace, presence: true, uniqueness: true, unless: :draft?
+  validates_presence_of :name, :publisher, :object_type, :language, :author, unless: :draft?
+  validates :id_dspace, presence: true, uniqueness: true
 
-  default_scope { includes(:object_type, :attachment, :attachments).order(score: :desc) }
+  default_scope { includes(:object_type, :attachment, :attachments) }
   scope :missing_thumbnail, ->() { where(thumbnail_file_name: nil) }
 
   searchkick language: 'brazilian', match: :word_start, searchable: [:name, :description, :author, :object_type], callbacks: :async
@@ -68,18 +68,18 @@ class LearningObject < ApplicationRecord
 
   scope :search_import, -> { includes(:tags) }
   def search_data
-    source = (!publisher.nil? && publisher.is_a?(Institution)) ? publisher.name : nil
+    source = !publisher.nil? && publisher.is_a?(Institution) ? publisher.name : nil
     type = object_type.try(:name)
     {
-        name: name,
-        description: description,
-        author: author,
-        object_type: type,
-        score: score,
-        published_at: published_at,
-        tags: tags.map(&:name),
-        source: source,
-        state: LearningObject.states[state]
+      name: name,
+      description: description,
+      author: author,
+      object_type: type,
+      score: score,
+      published_at: published_at,
+      tags: tags.map(&:name),
+      source: source,
+      state: LearningObject.states[state]
     }
   end
 
@@ -115,16 +115,6 @@ class LearningObject < ApplicationRecord
     default_attachment.retrieve_cache_link
   end
 
-  def url_reference
-    get_metadata_value_of 'dc.object.url'
-  end
-
-  ## checks if learning object link to an url.
-  # returns boolean
-  def has_url_reference?
-    !url_reference.blank?
-  end
-
   ## score methods
   def normalized_collected
     max = CollectionItem.where(collectionable_type: 'LearningObject').group(:collectionable_id).order('count_all DESC').count
@@ -138,5 +128,4 @@ class LearningObject < ApplicationRecord
   def user_category
     publisher.try('user_category')
   end
-
 end

app/models/learning_object/draft.rb

-# == Schema Information
-#
-# Table name: learning_objects
-#
-#  id                     :integer          not null, primary key
-#  id_dspace              :integer
-#  name                   :string
-#  author                 :string
-#  description            :text
-#  published_at           :datetime
-#  score                  :float            default("0.0")
-#  school_level           :integer
-#  metadata               :jsonb            default("{}")
-#  keywords               :text
-#  publisher_id           :integer
-#  publisher_type         :string
-#  language_id            :integer
-#  object_type_id         :integer
-#  created_at             :datetime         not null
-#  updated_at             :datetime         not null
-#  views_count            :integer          default("0")
-#  downloads_count        :integer          default("0")
-#  likes_count            :integer          default("0")
-#  shares_count           :integer          default("0")
-#  state                  :string           default("published")
-#  thumbnail_file_name    :string
-#  thumbnail_content_type :string
-#  thumbnail_file_size    :integer
-#  thumbnail_updated_at   :datetime
-#  attachment_id          :integer
-#
-
-class LearningObject::Draft < LearningObject
-
-  ##overwrites initialize method to force @state value as draft
-  def initialize(attributes = nil, options = {})
-    super(attributes, options)
-    @state = 'draft'
-  end
-
-end

app/serializers/learning_object_serializer.rb

@@ -19,7 +19,7 @@ class LearningObjectSerializer < ActiveModel::Serializer
     object.object_type.try(:name)
   end
 
-  attributes :id, :name, :description, :author, :thumbnail, :publisher, :object_type, :language, :default_attachment_id, :default_location, :default_mime_type, :score, :review_ratings_average, :license, :likes_count, :shares_count, :created_at, :updated_at
+  attributes :id, :name, :description, :author, :thumbnail, :publisher, :object_type, :language, :default_attachment_id, :default_location, :default_mime_type, :score, :state, :review_ratings_average, :license, :likes_count, :shares_count, :created_at, :updated_at
 
   has_many :tags
   has_many :attachments

app/services/learning_object_publisher.rb

-# require 'dspace'
+require 'dspace'
 
 class LearningObjectPublisher
-
   def initialize(dspace_client)
     @dspace = dspace_client
   end
 
   # create a learning object with draft status
-  # if draft#type is 'external link', then the draft is published.
-  def create_draft(draft)
-    if draft.valid?
-      item = create_dspace_item draft
-      # save on postgres
-      draft.id_dspace = item.id
-      draft.save
-
-      publish draft if draft.has_url_reference?
-      return draft
-    end
-    false
+  def create_draft(draft, publisher)
+    item = create_dspace_item(draft)
+    # save on postgres
+    draft.id_dspace = item.id
+    draft.publisher = publisher
+    draft.save
+
+    update_dspace(draft)
+
+    draft
   end
 
   # post *media_path* to *learning_object* on dspace
@@ -29,28 +26,45 @@ class LearningObjectPublisher
   ## publish *learning_object*
   # this method will create thumbnails, change state to published and will save it.
   def publish(learning_object)
-    if learning_object.draft?
-      learning_object.published!
-      ThumbnailGenerateWorker.perform_async learning_object.id, learning_object.url_reference if learning_object.has_url_reference?
-    end
+    return true if learning_object.published?
+
+    learning_object.state = LearningObject.states[:published]
+    ThumbnailGenerateWorker.perform_async learning_object.id, learning_object.link if learning_object.link?
     learning_object.save
   end
 
+  def update_dspace(object)
+    item = @dspace.items.find(id: object.id_dspace)
+    dspace_metadata_mapper(object).each do |key, value|
+      next if value.blank?
+      value = [value] if value.is_a? String
+      value.each do |v|
+        item.add_metadata(key, v, object.language.code) unless v.blank?
+      end
+    end
+  end
+
   private
 
   def create_dspace_item(draft)
-    item = @dspace.collections.create_item(build_dspace_item(draft), id: DspaceService::TEST_COLLECTION)
-
-    # update dspace metadata
-    metadata = ::Dspace::Metadata.new('key' => 'dc.title', 'value' => draft.name, 'language' => draft.language.name)
-    url_ref = ::Dspace::Metadata.new('key' => 'dc.object.url', 'value' => draft.url_reference, 'language' => draft.language.name)
-    @dspace.items.add_metadata(metadata, id: item.id)
-    @dspace.items.add_metadata(url_ref, id: item.id) if draft.has_url_reference?
-    item
+    @dspace.collections.create_item(build_dspace_item(draft), id: DspaceService::TEST_COLLECTION)
   end
 
   def build_dspace_item(draft)
     ::Dspace::Item.new('name' => draft.name)
   end
 
+  def dspace_metadata_mapper(object)
+    {
+      'dc.title' => object.name,
+      'dc.object.url' => object.link,
+      'dc.contributor.author' => object.author,
+      'dc.description' => object.description,
+      'dc.language' => object.language.code,
+      'dc.type' => object.object_type.name,
+      'dc.rights.license' => object.license.try(:name),
+      # 'dc.subject.category' => object.subjects,
+      'dc.date.submitted' => object.created_at.to_s
+    }
+  end
 end

config/routes.rb

@@ -88,6 +88,7 @@ Rails.application.routes.draw do
       member do
         resource :chunk, module: 'learning_objects', only: [:create, :show]
         resource :upload, module: 'learning_objects', only: :create
+        resource :publish, module: 'learning_objects', only: :create
       end
     end
 

db/migrate/20161026163027_change_learning_object.rb

+class ChangeLearningObject < ActiveRecord::Migration[5.0]
+  def change
+    add_column :learning_objects, :link, :string
+    add_column :learning_objects, :software, :string
+
+    remove_column :learning_objects, :keywords
+    remove_column :learning_objects, :school_level
+
+    drop_table :learning_objects_topics
+  end
+end