vkhater-social_stream-base 0.11.2

data/app/models/audience.rb

@@ -0,0 +1,9 @@
+# Every {Activity} is shared with one or more {audiences Audience}.
+#
+# Each {Audience} is equivalent to a {Relation}, which defines the {actors Actor}
+# that are assigned to that relation and the {permissions Permission} granted to
+# that {Audience}
+class Audience < ActiveRecord::Base
+  belongs_to :activity
+  belongs_to :relation
+end

data/app/models/authentication.rb

@@ -0,0 +1,3 @@
+class Authentication < ActiveRecord::Base
+  belongs_to :user
+end

data/app/models/comment.rb

@@ -0,0 +1,10 @@
+class Comment < ActiveRecord::Base
+  include SocialStream::Models::Object
+
+  validates_presence_of :text
+
+  def _activity_parent_id=(id)
+    self._relation_ids = Activity.find(id).relation_ids
+    @_activity_parent_id = id
+  end
+end

data/app/models/contact.rb

@@ -0,0 +1,209 @@
+# A {Contact} is an ordered pair of {Actor Actors},
+# and therefore two {SocialStream::Models::Subject Subjects}.
+#
+# {Contact Contacts} are created at convenience (in the case of {Actor#suggestions suggestions},
+# for instance), and they do not mean that there is a real link between those two
+# {SocialStream::Models::Subject Subjects}. Link existance is stored as {Tie Ties}.
+#
+# = {Contact Contacts} and {Activity activities}
+#
+# WARNING: This will be change soon to direct references to author, owner and user_author,
+# in the same way as {ActivityObject}
+#
+# Each {Activity} is attached to a {Contact}. When _Alice_ post in _Bob_'s wall,
+# the {Activity} is attached to the {Contact} from _Alice_ to _Bob_
+#
+# * The sender of the {Contact} is the author of the {Activity}.
+#   It is the user that uploads a resource to the website or the social entity that
+#   originates the {Activity} (for example: add as contact).
+#
+# * The receiver {Actor} of the {Contact} is the receiver of the {Activity}.
+#   The {Activity} will appear in the wall of the receiver, depending on the permissions
+#
+class Contact < ActiveRecord::Base
+  # Send a message when this contact is created or updated
+  attr_accessor :message
+
+  belongs_to :inverse,
+             :class_name => "Contact"
+
+  belongs_to :sender,
+             :class_name => "Actor"
+  belongs_to :receiver,
+             :class_name => "Actor"
+
+  has_many :ties,
+           :dependent => :destroy
+  has_many :relations,
+           :through => :ties
+
+  has_many :activities,
+           :dependent => :destroy
+
+  scope :sent_by, lambda { |a|
+    where(:sender_id => Actor.normalize_id(a))
+  }
+
+  scope :received_by, lambda { |a|
+    where(:receiver_id => Actor.normalize_id(a))
+  }
+
+  scope :sent_or_received_by, lambda { |a|
+    where(arel_table[:sender_id].eq(Actor.normalize_id(a)).
+          or(arel_table[:receiver_id].eq(Actor.normalize_id(a))))
+  }
+
+  scope :recent, order("contacts.created_at DESC")
+
+  scope :active, where(arel_table[:ties_count].gt(0))
+
+  scope :positive, lambda {
+    select("DISTINCT contacts.*").
+      joins(:relations).
+      merge(Relation.where(:type => Relation.positive_names))
+  }
+
+  scope :not_reflexive, where(arel_table[:sender_id].not_eq(arel_table[:receiver_id]))
+
+  scope :pending, active.
+                  not_reflexive.
+                  joins("LEFT JOIN contacts AS inverse_contacts ON inverse_contacts.id = contacts.inverse_id").
+                  where(arel_table[:inverse_id].eq(nil).or(arel_table.alias("inverse_contacts")[:ties_count].eq(0)))
+
+  scope :related_by_param, lambda { |p|
+    if p.present?
+      joins(:ties).merge(Tie.where(:relation_id => p))
+    end
+  }
+
+  validates_presence_of :sender_id, :receiver_id
+  validates_presence_of :relation_ids, :on => :update
+  validates_uniqueness_of :sender_id, :scope => :receiver_id
+  validates_uniqueness_of :receiver_id, :scope => :sender_id
+
+  after_create :set_inverse
+  after_save :send_message
+
+  def sender_subject
+    sender.subject
+  end
+
+  def receiver_subject
+    receiver.subject
+  end
+
+  # Does this {Contact} have the same sender and receiver?
+  def reflexive?
+    sender_id == receiver_id
+  end
+
+  # Find or create the inverse {Contact}
+  def inverse!
+    inverse ||
+      receiver.contact_to!(sender)
+  end
+
+  # Has this {Contact} any {Tie}?
+  def established?
+    ties_count > 0
+  end
+
+  # The {Contact} in the other way is established
+  def replied?
+    inverse_id.present? &&
+      inverse.ties_count > 0
+  end
+
+  def positive_replied?
+    inverse_id.present? &&
+      self.class.positive.where(:id => inverse.id).any?
+  end
+
+  # The {ActivityVerb} corresponding to this {Contact}. If this contact is pending,
+  # the other one was establised already, so this is going to "make-friend".
+  # If it is not pending, the contact in the other way was not established, so this
+  # is following
+  def verb
+    replied? ? "make-friend" : "follow"
+  end
+
+  # has_many collection=objects method does not trigger destroy callbacks,
+  # so follower_count will not be updated
+  #
+  # We need to update that status here
+  def relation_ids=(ids)
+    remove_follower(ids)
+    association(:relations).ids_writer(ids)
+  end
+
+  # Is this {Contact} +new+ or +edit+ for {SocialStream::Models::Subject subject} ?
+  #
+  # action is +new+ when, despite of being created, it has not {Tie ties} or it has a {Tie} with a
+  # {Relation::Reject reject relation}. 
+  #
+  # The contact's action is +edit+ when it has any {Tie} with a {Relation::Custom custom relation} or
+  # a {Relation::Public public relation}
+  #
+  def action
+    if ties_count > 0 && relations.where(:type => Relation.positive_names).any?
+      'edit'
+    else
+      replied? ? 'reply' : 'new'
+    end
+  end
+
+  def status
+    case action
+    when 'edit'
+      ties.includes(:relation).map(&:relation_name).join(", ")
+    else
+      I18n.t("contact.#{ action }.link")
+    end
+  end
+
+  private
+
+  def remove_follower(ids)
+    # There was no follower
+    return if relation_ids.blank?
+
+    ids = ids.map(&:to_i)
+
+    return if ids.sort == relation_ids.sort
+
+    following = Relation.
+                  where(:id => relation_ids).
+                  joins(:permissions).
+                  merge(Permission.follow).
+                  any?
+
+    if following
+      will_follow = Relation.
+                      where(:id => ids).
+                      joins(:permissions).
+                      merge(Permission.follow).
+                      any?
+
+      if !will_follow
+        receiver.decrement!(:follower_count)
+      end
+    end
+  end
+
+  # Send a message to the contact receiver
+  def send_message
+    return if message.blank?
+
+    sender.send_message(receiver, message, I18n.t("activity.verb.#{ verb }.#{ receiver.subject_type }.message", :name => sender.name))
+  end
+
+  def set_inverse
+    
+    inverse = self.class.sent_by(receiver_id).received_by(sender_id).first
+
+    return if inverse.blank?
+
+    update_attribute :inverse_id, inverse.id
+    inverse.update_attribute :inverse_id, id
+  end
+end

data/app/models/group.rb

@@ -0,0 +1,51 @@
+class Group < ActiveRecord::Base
+  include SocialStream::Models::Subject
+
+  attr_accessor :_participants
+
+  delegate :description, :description=, :to => :profile!
+
+  after_create :create_ties
+
+  def profile!
+    actor!.profile || actor!.build_profile
+  end
+
+  def followers
+    contact_subjects(:subject_type => :user, :direction => :received)
+  end
+  
+  def recent_groups
+    contact_subjects(:type => :group, :direction => :sent) do |q|
+      q.select("contacts.created_at").
+        merge(Contact.recent)
+    end
+  end
+
+  private
+
+  # Creates ties from founder to the group, based on _relation_ids,
+  # and ties from the group to founder and participants.
+  def create_ties
+    create_ties_from_founder
+    create_ties_to_participants
+  end
+
+  # Creates the ties from the founder to the group
+  def create_ties_from_founder
+    author.sent_contacts.create! :receiver_id  => actor_id,
+                                 :relation_ids => _relation_ids
+
+    if represented_author?
+      # TODO: create tie with future representation relation
+    end
+  end
+  
+  # Creates the ties from the group to the participants
+  def create_ties_to_participants
+    ([ author_id, user_author_id ].uniq | Array.wrap(@_participants)).uniq.each do |a|
+      sent_contacts.create! :receiver_id => a,
+                            :relation_ids => Array(relation_customs.sort.first.id)
+    end
+  end
+end

data/app/models/like.rb

@@ -0,0 +1,49 @@
+# Convenience class for managing like activities
+class Like
+  attr_reader :object
+
+  class << self
+    # Find the children activity of activity_id liked by subject
+    def find(subject, object)
+      like = new(object.liked_by(subject).first)
+      # Cache object to make it available before it is destroyed
+      like.object
+      like
+    end
+
+    # Like #find but raises error if not found
+    def find!(subject, object)
+      find(subject, object) ||
+        raise(ActiveRecord::RecordNotFound)
+    end
+
+    def build(subject, object)
+       new object.new_like(subject)
+    end
+  end
+
+  # Initialize a new like activity
+  def initialize(activity)
+    @like = activity
+  end
+
+  def save
+    @like.save
+  end
+  
+  # The object that is liked. It can be an activity
+  def object
+    @object ||=
+      if @like.is_root?
+        obj = @like.direct_object
+        obj = obj.subject if obj.is_a?(Actor)
+        obj
+      else
+        @like.parent
+      end
+  end
+  
+  def destroy
+    @like.destroy
+  end
+end

data/app/models/permission.rb

@@ -0,0 +1,52 @@
+# SocialStream provides a system of permissions based on the {Relation relations}
+# of the social network as roles.
+#
+# = Permissions and Relations
+#
+# Permissions are assigned to {Relation Relations}, and through relations, to {Tie Ties}. 
+# When a sender establishes a {Tie} with a receiver, she is granting to the receiver
+# the permissions assigned to {Relation} of the {Tie} she has just established.
+#
+# For example, when _Alice_ establishes a _friend_ tie to _Bob_, she is granting
+# him the permissions associated with her _friend_ relation. Alice's _friend_ relation may
+# have different permissions from Bob's _friend_ relation.
+#
+# = Permissions description
+#
+# Permissions are composed by *action* and *object*. Action and object
+# are typical in content management systems, e.g. <tt>create activity</tt>,
+# <tt>update tie</tt>, <tt>read post</tt>.
+#
+# == Actions
+#
+# Current available actions are:
+#
+# +create+:: add a new instance of something (activity, tie, post, etc)
+# +read+::   view something
+# +update+::  modify something
+# +destroy+:: delete something
+# +follow+::  subscribe to activity updates from the receiver of the tie
+# +represent+:: give the receiver rights to act as if he were me.
+#
+# == Objectives
+#
+# +activity+:: all the objects in a wall: posts, comments
+#
+# Other objects currently not implemented could be +tie+, +post+, +comment+ or +message+
+#
+#
+class Permission < ActiveRecord::Base
+  has_many :relation_permissions, :dependent => :destroy
+  has_many :relations, :through => :relation_permissions
+
+  %w(represent follow).each do |p|
+    scope p, where(:action => p) # scope :represent, where(:action => 'represent')
+  end
+
+  # An explanation of the permissions. Type can be brief or detailed.
+  # If detailed, description includes more information about the relation
+  def description(type, options = {})
+    I18n.t "permission.description.#{ type }.#{ action }.#{ object || "nil" }",
+           options
+  end
+end

data/app/models/post.rb

@@ -0,0 +1,12 @@
+class Post < ActiveRecord::Base
+  include SocialStream::Models::Object
+
+  validates_presence_of :text
+
+  define_index do
+    indexes text
+
+    has created_at
+  end
+
+end

data/app/models/profile.rb

@@ -0,0 +1,58 @@
+class Profile < ActiveRecord::Base
+  belongs_to :actor
+    
+  accepts_nested_attributes_for :actor
+  
+  validates_presence_of :actor_id
+  
+  validates_format_of :mobile, :phone, :fax,
+                      :allow_nil  => true,
+                      :with       => /(^$)|(((\((\+?)\d+\))?|(\+\d+)?)[ ]*-?(\d+[ ]*\-?[ ]*\d*)+$)/,
+                      :message    => "has a invalid format"
+  
+  validates_format_of :website,
+                      :allow_nil  => true,
+                      :with       => /(^$)|((https?|ftp):\/\/(((([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(%[\da-f]{2})|[!\$&'\(\)\*\+,;=]|:)*@)?(((\d|[1-9]\d|1\d\d|2[0-4]\d|25[0-5])\.(\d|[1-9]\d|1\d\d|2[0-4]\d|25[0-5])\.(\d|[1-9]\d|1\d\d|2[0-4]\d|25[0-5])\.(\d|[1-9]\d|1\d\d|2[0-4]\d|25[0-5]))|((([a-z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(([a-z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])*([a-z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])))\.)+(([a-z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(([a-z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])*([a-z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])))\.?)(:\d*)?)(\/((([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(%[\da-f]{2})|[!\$&'\(\)\*\+,;=]|:|@)+(\/(([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(%[\da-f]{2})|[!\$&'\(\)\*\+,;=]|:|@)*)*)?)?(\?((([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(%[\da-f]{2})|[!\$&'\(\)\*\+,;=]|:|@)|[\uE000-\uF8FF]|\/|\?)*)?(\#((([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(%[\da-f]{2})|[!\$&'\(\)\*\+,;=]|:|@)|\/|\?)*)?$)/ ,
+                      :message    => "has a invalid format"
+  
+  validate :validate_birthday
+  
+  def birthday=(value)
+    
+    puts "He entrado en el metodo birthday con un :" + value.class.to_s 
+          
+    if value.blank?
+      @birthday_formatted_invalid = false    
+      super value
+    else
+      begin
+        #super Date.parse(value)
+        super value
+        @birthday_formatted_invalid = false
+      rescue 
+        @birthday_formatted_invalid = true
+      end
+    end
+
+  end
+  
+  def age
+    return nil if self.birthday.blank? 
+    now = Time.now.utc.to_date
+    now.year - self.birthday.year - (self.birthday.to_date.change(:year => now.year) > now ? 1 : 0)
+  end
+  
+  # The subject of this profile
+  def subject
+    actor.try(:subject)
+  end
+  
+  private
+
+  def validate_birthday
+    errors.add(:birthday, "is invalid. Please, use \"month/day/year\" format and make sure you choose a valid date" ) if (@birthday_formatted_invalid) || (birthday.present? && !birthday.blank? && birthday > Date.today)
+  end
+
+  
+  
+end