project.rb

# frozen_string_literal: true

# == Schema Information
#
# Table name: projects
#
#  id                      :integer          not null, primary key
#  allow_audio_upload      :boolean          default(FALSE)
#  allow_original_download :string
#  deleted_at              :datetime
#  description             :text
#  image_content_type      :string
#  image_file_name         :string
#  image_file_size         :bigint
#  image_updated_at        :datetime
#  license                 :text
#  name                    :string           not null
#  notes                   :text
#  urn                     :string
#  created_at              :datetime
#  updated_at              :datetime
#  creator_id              :integer          not null
#  deleter_id              :integer
#  updater_id              :integer
#
# Indexes
#
#  index_projects_on_creator_id  (creator_id)
#  index_projects_on_deleter_id  (deleter_id)
#  index_projects_on_updater_id  (updater_id)
#  projects_name_uidx            (name) UNIQUE
#
# Foreign Keys
#
#  projects_creator_id_fk  (creator_id => users.id)
#  projects_deleter_id_fk  (deleter_id => users.id)
#  projects_updater_id_fk  (updater_id => users.id)
#
class Project < ApplicationRecord
  extend Enumerize

  # relationships
  belongs_to :creator, class_name: 'User', foreign_key: :creator_id, inverse_of: :created_projects
  belongs_to :updater, class_name: 'User', foreign_key: :updater_id, inverse_of: :updated_projects, optional: true
  belongs_to :deleter, class_name: 'User', foreign_key: :deleter_id, inverse_of: :deleted_projects, optional: true

  has_many :permissions, inverse_of: :project
  # remove joins clause in next major rails version. See https://github.com/rails/rails/pull/39390/files
  has_many :readers, lambda {
                       joins(:permissions).where({ permissions: { level: 'reader' } }).distinct
                     }, through: :permissions, source: :user
  has_many :writers, lambda {
                       joins(:permissions).where({ permissions: { level: 'writer' } }).distinct
                     }, through: :permissions, source: :user
  has_many :owners, lambda {
                      joins(:permissions).where({ permissions: { level: 'owner' } }).distinct
                    }, through: :permissions, source: :user
  has_and_belongs_to_many :sites, -> { distinct }
  has_many :regions, inverse_of: :project
  has_many :harvests, inverse_of: :project
  has_and_belongs_to_many :saved_searches, inverse_of: :projects
  has_many :analysis_jobs, through: :saved_searches

  accepts_nested_attributes_for :permissions

  # plugins
  has_attached_file :image,
    styles: { span4: '300x300#', span3: '220x220#', span2: '140x140#', span1: '60x60#', spanhalf: '30x30#' },
    default_url: '/images/project/project_:style.png'

  # add deleted_at and deleter_id
  acts_as_paranoid
  validates_as_paranoid

  # association validations
  #validates_associated :creator

  # attribute validations
  validates :name, presence: true, uniqueness: { case_sensitive: false }
  #validates :urn, uniqueness: {case_sensitive: false}, allow_blank: true, allow_nil: true
  validates_format_of :urn, with: %r{\Aurn:[a-z0-9][a-z0-9-]{0,31}:[a-z0-9()+,\-.:=@;$_!*'%/?#]+\z},
    message: 'urn %<value>s is not valid, must be in format urn:<name>:<path>', allow_blank: true, allow_nil: true
  validates_attachment_content_type :image, content_type: %r{\Aimage/(jpg|jpeg|pjpeg|png|x-png|gif)\z},
    message: 'file type %<value>s is not allowed (only jpeg/png/gif images)'

  validates :license, length: { minimum: 1 }, allow_nil: true

  # ensure allow original download is a permission level.
  # Do not add predicates to Project ( #reader?, #writer?, #owner? do not make sense when attached directly to Project).
  enumerize :allow_original_download, in: Permission::AVAILABLE_LEVELS, default: nil, predicates: false

  # make sure the project has a permission entry for the creator after it is created
  after_create :create_owner_permission

  renders_markdown_for :description

  # Define filter api settings
  def self.filter_settings
    {
      valid_fields: [:id, :name, :description, :creator_id,
                     :created_at,
                     :updater_id,
                     :updated_at,
                     :deleter_id,
                     :deleted_at,
                     :license],
      render_fields: [:id, :name, :description, :creator_id,
                      :created_at,
                      :updater_id,
                      :updated_at,
                      :deleter_id,
                      :deleted_at,
                      :notes,
                      :allow_original_download,
                      :allow_audio_upload,
                      :license],
      text_fields: [:name, :description],
      custom_fields: lambda { |item, user|
                       # do a query for the attributes that may not be in the projection
                       # instance or id can be nil
                       fresh_project = item.nil? || item.id.nil? ? nil : Project.find(item.id)

                       project_hash = {}
                       project_hash[:site_ids] = fresh_project.nil? ? nil : fresh_project.sites.pluck(:id).flatten
                       project_hash[:region_ids] = fresh_project.nil? ? nil : fresh_project.regions.pluck(:id).flatten
                       project_hash[:owner_ids] = fresh_project.nil? ? nil : fresh_project.owners.pluck(:id).flatten
                       project_hash[:image_urls] = Api::Image.image_urls(fresh_project.image)
                       project_hash.merge!(item.render_markdown_for_api_for(:description))

                       # access level for the current user - useful for showing users what their current permission level is
                       project_hash[:access_level] = Project.access_level(item, user)
                       [item, project_hash]
                     },
      new_spec_fields: lambda { |_user|
                         {
                           name: nil,
                           description: nil,
                           allow_original_download: nil,
                           notes: nil
                         }
                       },
      controller: :projects,
      action: :filter,
      defaults: {
        order_by: :name,
        direction: :asc
      },
      capabilities: {
        update_allow_audio_upload:
        {
          can_item: ->(item) { Current.ability.can?(:allow_audio_upload, item) },
          details: nil
        },
        create_harvest: {
          can_item: ->(item) { Current.ability.can?(:create, Harvest.new(project: item)) && item&.allow_audio_upload },
          details: lambda { |can, item, _klass|
                     unless can
                       if item&.allow_audio_upload
                         'You do not have permission to upload audio. You must be an owner of this project.'
                       else
                         'This project does not allow uploading audio. Contact the site administrator to request permission to upload audio.'
                       end
                     end
                   }
        }
      },
      valid_associations: [
        {
          join: Permission,
          on: Permission.arel_table[:project_id].eq(Project.arel_table[:id]),
          available: true
        },
        {
          join: Arel::Table.new(:projects_sites),
          on: Project.arel_table[:id].eq(Arel::Table.new(:projects_sites)[:project_id]),
          available: false,
          associations: [
            {
              join: Site,
              on: Arel::Table.new(:projects_sites)[:site_id].eq(Site.arel_table[:id]),
              available: true
            }
          ]

        },
        {
          join: Arel::Table.new(:projects_saved_searches),
          on: Project.arel_table[:id].eq(Arel::Table.new(:projects_saved_searches)[:project_id]),
          available: false,
          associations: [
            {
              join: SavedSearch,
              on: Arel::Table.new(:projects_saved_searches)[:saved_search_id].eq(SavedSearch.arel_table[:id]),
              available: true
            }
          ]

        }
      ]
    }
  end

  def self.schema
    {
      type: 'object',
      additionalProperties: false,
      properties: {
        id: Api::Schema.id,
        name: { type: 'string' },
        **Api::Schema.rendered_markdown(:description),
        #notes: { type: 'object' }, # TODO: https://github.com/QutEcoacoustics/baw-server/issues/467
        notes: { type: 'string' },
        **Api::Schema.all_user_stamps,
        site_ids: Api::Schema.ids(read_only: true),
        region_ids: Api::Schema.ids(read_only: true),
        owner_ids: Api::Schema.ids(read_only: true),
        image_urls: Api::Schema.image_urls,
        access_level: Api::Schema.permission_levels,
        allow_original_download: Api::Schema.permission_levels,
        allow_audio_upload: { type: 'boolean' },
        license: { type: ['string', 'null'] }
      },
      required: [
        :id,
        :name,
        :description,
        :description_html,
        :description_html_tagline,
        :notes,
        :creator_id,
        :created_at,
        :updater_id,
        :updated_at,
        :deleter_id,
        :deleted_at,
        :owner_ids,
        :site_ids,
        :region_ids,
        :image_urls,
        :allow_original_download,
        :license
      ]
    }.freeze
  end

  def self.access_level(project, user)
    levels = Access::Core.user_levels(user, project)
    Access::Core.highest(levels)
  end

  private

  def create_owner_permission
    the_user = creator
    the_admin = User.where(roles_mask: 1).first!
    Permission.find_or_create_by(
      level: 'owner',
      user: the_user,
      project: self,
      creator: the_admin,
      allow_logged_in: false,
      allow_anonymous: false
    )
  end
end