Class: Relation

Inherits:
ActiveRecord::Base
  • Object
show all
Defined in:
app/models/relation.rb

Overview

A relation defines a type of tie. Relations are affective (friendship, liking, respect), formal or biological (authority, kinship), transfer of material resources (transactions, lending and borrowing), messages or conversations, physical connection and affiliation to same organizations.

Strength hierarchies

Relations are arranged in strength hierarchies, denoting that some ties between two actors are stronger than others. For example, a “friend” relation is stronger than an “acquaintance” relation.

When a strong tie is established, ties with weaker relations are establised as well

Permissions

Subjects assign permissions to relations. This way, when establishing ties, they are granting permissions to their contacts.

See the documentation of Permission for more details on permission definition.

Activities and relations

Each Activity can be attached to one or more relations. The Relation sets up the mode in which the Activity is shared. It sets the Audience that has access to it, and the Permissions that rule that access.

Direct Known Subclasses

Custom, Public

Defined Under Namespace

Classes: Custom, CustomsController, Public

Class Method Summary collapse

Instance Method Summary collapse

Class Method Details

.allow(subject, action, object, options = {}) ⇒ Object

All the relations that allow subject to perform action

Options:

in:: Limit possible relations to a set
public_relations:: include also {Relation::Public} whose activities can always be read



81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
 
# File 'app/models/relation.rb', line 81

def allow(subject, action, object, options = {})
  q = 
    select("DISTINCT relations.*").
    joins(:contacts).
    joins(:permissions)

  conds =
    Permission.arel_table[:action].eq(action).and(Permission.arel_table[:object].eq(object))

  # Relation::Public permissions cannot be customized yet
  if action == 'read' && object == 'activity' && (options[:public].nil? || options[:public])
    conds = conds.or(Relation.arel_table[:type].eq('Relation::Public'))
  end

  # Add in condition
  if ! options[:in].nil?
    conds = conds.and(Relation.arel_table[:id].in(Relation.normalize_id(Array(options[:in]))))
  end

  # subject conditions
  conds = conds.and(Contact.arel_table[:receiver_id].eq(Actor.normalize_id(subject)))

  q.where(conds)
end

.allow?(*args) ⇒ Boolean

Returns:

  • (Boolean) 


106
107
108
 
# File 'app/models/relation.rb', line 106

def allow?(*args)
  allow(*args).to_a.any?
end

.normalize(r, options = {}) ⇒ Object

Get relation from object, if possible

Options
sender

The sender of the tie



46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
 
# File 'app/models/relation.rb', line 46

def normalize(r, options = {})
  case r
  when Relation
    r
  when String
    if options[:sender]
      options[:sender].relation_custom(r)
    else
      raise "Must provide a sender when looking up relations from name: #{ options[:sender] }"
    end
  when Integer
    Relation.find r
  when Array
    r.map{ |e| Relation.normalize(e, options) }
  else
    raise "Unable to normalize relation #{ r.class }: #{ r.inspect }"
  end
end

.normalize_id(r, options = {}) ⇒ Object 



65
66
67
68
69
70
71
72
73
74
 
# File 'app/models/relation.rb', line 65

def normalize_id(r, options = {})
  case r
  when Integer
    r
  when Array
    r.map{ |e| Relation.normalize_id(e, options) }
  else
    normalize(r, options).id
  end
end

Instance Method Details

#mode ⇒ Object

Relation class scoped in the same mode that this relation



112
113
114
 
# File 'app/models/relation.rb', line 112

def mode
  Relation.mode(sender_type, receiver_type)
end