pulibrary / pdc_describe / 4e4e59fc-9df4-4838-9fd4-6c7ea33cdb7c

class Group < ApplicationRecord

  resourcify

  has_many :group_options, dependent: :destroy, class_name: "GroupOption"

  has_many :group_messaging_options, -> { where(option_type: GroupOption::EMAIL_MESSAGES) }, class_name: "GroupOption", dependent: :destroy

  has_many :users_with_options, through: :group_options, source: :user

  has_many :users_with_messaging, through: :group_messaging_options, source: :user

  validate do |group|

    if group.title.blank?

      group.errors.add :base, "Title cannot be empty"

    end

  end

  def default_admins_list

    return [] if code.blank?

    key = code.downcase.to_sym

    Rails.configuration.group_defaults.dig(key, :admin) || []

  end

  def default_submitters_list

    key = code.downcase.to_sym

    Rails.configuration.group_defaults.dig(key, :submit) || []

  end

  def super_administrators

    User.with_role(:super_admin)

  end

  def datasets

    Work.where(group_id: id)

  end

  def submitters

    User.with_role(:submitter, self)

  end

  def enable_messages_for(user:, subcommunity: nil)

    raise(ArgumentError, "User #{user.uid} is not an administrator or submitter for this group #{title}") unless user.can_admin?(self) || user.can_submit?(self)

    group = GroupOption.find_or_initialize_by(option_type: GroupOption::EMAIL_MESSAGES, user:, group: self, subcommunity:)

    group.enabled = true

    group.save

  end

  def disable_messages_for(user:, subcommunity: nil)

    raise(ArgumentError, "User #{user.uid} is not an administrator or submitter for this group #{title}") unless user.can_admin?(self) || user.can_submit?(self)

    group = GroupOption.find_or_initialize_by(option_type: GroupOption::EMAIL_MESSAGES, user:, group: self, subcommunity:)

    group.enabled = false

    group.save

  end

  def messages_enabled_for?(user:, subcommunity: nil)

    group_option = group_messaging_options.find_by(user:, group: self, subcommunity:)

    group_option ||= GroupOption.new(enabled: true)

    group_option.enabled

  end

  def self.create_defaults

    return if where(code: "RD").count > 0

    Rails.logger.info "Creating default Groups"

    create(title: "Princeton Research Data Service (PRDS)", code: "RD")

    create(title: "Princeton Plasma Physics Lab (PPPL)", code: "PPPL")

  end

  def self.default

    create_defaults

    research_data

  end

  def self.default_for_department(department_number)

    if department_number.present? && department_number >= "31000" && department_number <= "31027"

      plasma_laboratory

    else

      default

    end

  end

  def self.research_data

    create_defaults

    where(code: "RD").first

  end

  def self.plasma_laboratory

    create_defaults

    where(code: "PPPL").first

  end

  def administrators

    User.with_role(:group_admin, self)

  end

  def add_administrator(current_user, admin_user)

    if current_user.has_role?(:super_admin) || current_user.has_role?(:group_admin, self)

      if admin_user.has_role? :group_admin, self

        errors.add(:admin, "User has already been added")

      else

        errors.delete(:admin)

        admin_user.add_role :group_admin, self

      end

    else

      errors.add(:admin, "Unauthorized")

    end

  end

  def add_submitter(current_user, additional_user)

    if current_user.has_role?(:super_admin) || current_user.has_role?(:group_admin, self)

      return if (self == additional_user.default_group) && additional_user.just_created

      if additional_user.has_role? :submitter, self

        errors.add(:submitter, "User has already been added")

      else

        errors.delete(:submitter)

        additional_user.add_role :submitter, self

      end

    else

      errors.add(:submitter, "Unauthorized")

    end

  end

  def delete_permission(current_user, removed_user, role)

    if current_user.has_role?(:super_admin) || current_user.has_role?(:group_admin, self)

      if removed_user.nil?

        errors.add(:delete_permission, "User was not found")

      elsif removed_user == current_user

        errors.add(:delete_permission, "Cannot remove yourself from a group. Contact a super-admin for help.")

      else

        errors.delete(:delete_permission)

        removed_user.remove_role role, self

      end

    else

      errors.add(:delete_permission, "Unauthorized")

    end

  end

  def communities

    if code == "PPPL"

      ["Princeton Plasma Physics Laboratory"]

    else

      ["Princeton Neuroscience Institute", "Geosciences", "Mechanical and Aerospace Engineering",

       "Astrophysical Sciences", "Civil and Environmental Engineering", "Chemical and Biological Engineering",

       "Digital Humanities", "Music and Arts", "Princeton School of Public and International Affairs",

       "Chemistry", "Lewis Seigler Genomics", "Architecture", "Ecology and Evolutionary Biology", "Economics"].sort

    end

  end

  def subcommunities

    values = []

    if code == "PPPL"

      values << "Spherical Torus"

      values << "Advanced Projects"

      values << "ITER and Tokamaks"

      values << "Theory"

      values << "NSTX-U"

      values << "NSTX"

      values << "Discovery Plasma Science"

      values << "Theory and Computation"

      values << "Stellarators"

      values << "PPPL Collaborations"

      values << "MAST-U"

      values << "Other Projects"

      values << "System Studies"

      values << "Applied Materials and Sustainability Sciences"

      values << "Computational Science"

      values << "DIII-D"

      values << "Tokamak Experimental Sciences"

    end

    values.sort

  end

  def publisher

    if code == "PPPL"

      "Princeton Plasma Physics Laboratory, Princeton University"

    else

      "Princeton University"

    end

  end

  def default_community

    return communities.first if code == "PPPL"

  end

  def default_user(uid)

    user = User.find_by(uid:)

    return user if user.present?

    begin

      user = User.new(uid:, default_group_id: id)

      user.save!

      user

    rescue ActiveRecord::RecordNotUnique => unique_error

      Rails.logger.error("Failed to created a new user for #{self}: #{unique_error}")

      user = User.new(uid:)

      user.default_group_id = id

      user.save!

      user

    end

  end

end