learning_objects_controller.rb

require 'uri'

class V1::LearningObjectsController < ApplicationController
  include ::SociableController
  include ::DownloadableController
  include ::TaggableController
  include ::Paginator
  include ::DeletedObjectsController
  include ::HighlightsController
  include ::SubjectableController
  include ::StageableController

  before_action :authenticate_user!, only: [:create, :update, :destroy, :tagging, :untagging]
  before_action :set_learning_object, only: [:show, :update, :destroy, :subjecting, :unsubjecting, :add_stages, :remove_stages]
  before_action :set_new_learning_object, only: :index
  before_action :authorize!, except: [:create, :tagging, :untagging, :download, :magnetlink]
  before_action :set_paper_trail_whodunnit, except: [:index, :show]

  def index
    learning_objects = paginate LearningObject.includes(:tags, :publisher, :language, :license, :subjects, :educational_stages, :reviews)
    serializer = params[:obaa].nil? ? LearningObjectSerializer : LearningObjectObaaSerializer
    http_cache_forever do
      render json: learning_objects, each_serializer: serializer
    end
  end

  # GET /learning_objects/1
  # GET /learning_objects/1.json
  def show
    serializer = params[:obaa].nil? ? LearningObjectSerializer : LearningObjectObaaSerializer
    render json: @learning_object, serializer: serializer
  end

  # POST /learning_objects
  # POST /learning_objects.json
  def create
    learning_object = LearningObject.new(learning_object_params)
    authorize learning_object
    publisher = LearningObjectPublisher.new(DspaceService.create_client)

    if publisher.create_draft(learning_object, current_user)
      learning_object_associations(learning_object)
      render json: learning_object, status: :created
    else
      render json: learning_object.errors, status: :unprocessable_entity
    end
  end

  # PATCH/PUT /learning_objects/1
  # PATCH/PUT /learning_objects/1.json
  def update
     if !learning_object_params[:object_type_id].blank? && learning_object_params[:object_type_id] != @learning_object.object_type_id && learning_object_params[:link].blank?
      change_object_type_id = true
    end
    if @learning_object.update(learning_object_params)
      learning_object_associations(@learning_object, change_object_type_id)
      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
    end
  end

  # DELETE /learning_objects/1
  # DELETE /learning_objects/1.json
  def destroy
    @learning_object.destroy
    render status: :ok
  end

  # GET /v1/learning_objects/magnetlink/:magnetlink
  def magnetlink
    render json: LearningObject.where(magnetlink: params[:magnetlink])
  end


  private

  def deleted_resource; LearningObject; end
  def highlights_resource; LearningObject; end
  def sociable; set_learning_object; end
  def downloadable; set_learning_object; end
  def taggable; set_learning_object; end
  def subjectable; set_learning_object; end
  def stageable; set_learning_object; end

  # Use callbacks to share common setup or constraints between actions.
  def set_learning_object
    #check if user is admin to show destroyed object
    if current_user.try(:is_admin?)
      @learning_object ||= LearningObject.unscoped.find(params[:id])
    else
      @learning_object ||= LearningObject.find(params[:id])
    end
  end

  def set_new_learning_object
    @learning_object ||= LearningObject.new
  end

  # Never trust parameters from the scary internet, only allow the white list through.
  def learning_object_params
    return nil if params[:learning_object].nil?
    params[:learning_object].permit(:author, :name, :curator, :object_type_id, :description, :license_id, :thumbnail, :software, :language_id, :link,  :magnetlink)
  end

  def extra_params
    return {} if params[:learning_object].nil?
    params[:learning_object].permit(subjects: [], educational_stages: [], tags: [:name])
  end

  def learning_object_associations(learning_object, change_object_type_id=false)
    if extra_params[:tags] == []
      current_user.untag(learning_object, with: @learning_object.tags.map { |t| t['name'] })
    elsif !extra_params[:tags].nil?
      current_user.tag(learning_object, with: extra_params[:tags].map { |t| t['name'] })
    end
    learning_object.add_subjects(ids: extra_params[:subjects]) unless extra_params[:subjects].nil?
    learning_object.add_educational_stages(ids: extra_params[:educational_stages]) unless extra_params[:educational_stages].nil?

    if change_object_type_id
      learning_object.link = nil
    end
  end

  def authorize!
    authorize @learning_object
  end
end