module Operations

# File lib/operations.rb, line 61
def allowed_int_roles_for(scope)
  allowed_named_roles_for(scope)
      .map{|named_scope| user_role_int_from(named_scope)}
end

# File lib/operations.rb, line 48
def allowed_named_roles_for(scope)
  current_value = user_role_value_from(scope)
  user_roles
      .select{|role| role[:name] == :all ||
          !role[:value].nil? && role[:value] <= current_value}
      .map{|role| role[:name]}
end

# File lib/operations.rb, line 66
def allowed_value_roles_for(scope)
  allowed_named_roles_for(scope)
      .map{|named_scope| user_role_value_from(named_scope)}
end

# File lib/operations.rb, line 43
def allowing(scope)
  return nil if scope.blank?
  operations_list.select{|operation| operation > scope}
end

# File lib/operations.rb, line 72
def allows?(user, name)
  operation = from_string(name)
  return false if operation.nil?
  operation.users.map{|u| u.id}.include?(user.id)
end

# File lib/operations.rb, line 38
def from_string(name)
  operations_list.select{|operation| operation.name.to_s == name.to_s}[0]
end

# File lib/operations.rb, line 56
def from_user_type(scope)
  value = allowed_named_roles_for(scope.to_sym)
  scopes = value.reject{|role| role.nil?}
end

# File lib/operations.rb, line 33
def from_uuid(uuid)
  operations_list.select{|operation| operation.uuid == uuid}[0]
end

# File lib/operations.rb, line 22
def named_user_roles(all: false)
  roles = Operations::Config.user_roles
  roles = roles.reject{|role| role[:db_value].nil?} unless all
  roles.map{|role| role[:name]}
end

# File lib/operations.rb, line 114
def operations_for(scope)
  scopes = scopes_as(scope)
  list = operations_list
  if %w{all nobody}.include?(scope.to_s)
    list.select{|op| op == scope}.uniq
  else
    list.select{|op| op >= scope}.uniq
  end
end

# File lib/operations.rb, line 14
def operations_list
  Operations::Config.get_operations_list
end

# File lib/operations.rb, line 28
def operations_list_by_uuid
  operations_list.map{|op| {operation: op, uuid: op.uuid}}
end

# File lib/operations.rb, line 105
def scopes_as(scope)
  value = user_role_value_from(scope)
  return [] if value.nil?
  return [scope] if %w{all nobody}.include?(scope.to_s)
  user_roles
      .select{|role| role[:value] && role[:value] >= value}
      .map{|role| role[:name]}
end

# File lib/operations.rb, line 134
def user_role_int_from(role_name)
  result = user_roles.select{|role| role[:name] == role_name}[0]
  return nil if result.nil?
  result[:db_value]
end

# File lib/operations.rb, line 146
def user_role_name_from(role_int)
  result = user_roles.select{|role| role[:db_value] == role_int}[0]
  return nil if result.nil?
  result[:name]
end

# File lib/operations.rb, line 140
def user_role_value_from(role_name)
  result = user_roles.select{|role| role[:name] == role_name}[0]
  return nil if result.nil?
  result[:value]
end

# File lib/operations.rb, line 18
def user_roles
  Operations::Config.user_roles
end

# File lib/operations.rb, line 84
def user_roles_from(role_name, select_only: false)
  value = user_role_value_from(role_name)
  return [] if value.nil?
  compare =-> (role, value) do
    select_only ? role[:value] == value : role[:value] <= value
  end
  user_roles
      .select{|role| role[:value] && compare.call(role, value)}
      .map{|role| role[:db_value]}
      .reject{|res| res.nil?}
end

# File lib/operations.rb, line 79
def user_roles_names
  user_roles.map{|ur| ur[:name]}
end

# File lib/operations.rb, line 97
def user_roles_until(role_name)
  value = user_role_value_from(role_name)
  return [] if value.nil?
  user_roles
      .select{|role| role[:value] && role[:value] > value}
      .map{|role| role[:db_value]}
end

# File lib/operations.rb, line 125
def users_acting_as(role_name, select_only: false)
  User.where(role: user_roles_from(role_name, select_only: select_only))
end

# File lib/operations.rb, line 130
def users_denied_from(role_name)
  User.where(role: user_roles_until(role_name))
end