card 0.0.1 → 1.15.pre

data/mod/05_email/lib/card/follow_option.rb

@@ -0,0 +1,90 @@
+# -*- encoding : utf-8 -*-
+
+
+class Card
+  module FollowOption
+    mattr_reader :test, :follower_candidate_ids
+    @@test, @@follower_candidate_ids = {}, {}
+    
+    @@options = { :all=>[], :main=>[], :restrictive=>[] }
+    
+    def self.included(host_class)     
+       host_class.extend ClassMethods
+    end
+    
+    def self.codenames type=:all
+      @@options[type]
+    end
+    
+    def self.cards
+       codenames.map { |codename| Card[codename] }
+    end
+    
+    def self.restrictive_options
+      self.codenames :restrictive
+    end
+    
+    def self.main_options
+      self.codenames :main
+    end
+    
+    def restrictive_option?
+      Card::FollowOption.restrictive_options.include? codename
+    end
+
+    def description set_card
+      set_card.follow_label
+    end
+
+    module ClassMethods
+      
+      # args:
+      # :position => <Fixnum> (starting at 1, default: add to end)
+      def restrictive_follow_opts args
+        add_option args, :restrictive
+      end
+      
+      # args:
+      # :position => <Fixnum> (starting at 1, default: add to end)
+      def follow_opts args
+        add_option args, :main
+      end
+      
+      def follow_test opts={}, &block
+        Card::FollowOption.test[ get_codename(opts) ] = block
+      end
+      
+      def follower_candidate_ids opts={}, &block
+        Card::FollowOption.follower_candidate_ids[ get_codename(opts) ] = block
+      end
+            
+      private
+      
+      def insert_option pos, item, type
+        if Card::FollowOption.codenames(type)[pos]  
+          Card::FollowOption.codenames(type).insert(pos, item)
+        else  
+          # If pos > codenames.size in a previous insert then we have a bunch of preceding nils in the array.
+          # Hence, we have to overwrite a nil value if we encounter one and can't use insert.
+          Card::FollowOption.codenames(type)[pos] = item
+        end
+      end
+      
+      def add_option opts, type, &block
+        codename = get_codename opts
+        if opts[:position]
+          insert_option opts[:position]-1, codename, type
+        else
+          Card::FollowOption.codenames(type) << codename
+        end
+        Card::FollowOption.codenames(:all) << codename
+      end
+      
+      def get_codename opts
+        opts[:codename] || self.name.match(/::(\w+)$/)[1].underscore.to_sym
+      end
+      
+      
+    end   
+  end
+end

data/mod/05_email/set/all/email_html.rb

@@ -0,0 +1,5 @@
+format :email_html do
+  view :missing        do |args| '' end
+  view :closed_missing do |args| '' end
+end
+

data/mod/05_email/set/all/email_text.rb

@@ -0,0 +1,5 @@
+
+format :email_text do    
+  view :missing        do |args| '' end
+  view :closed_missing do |args| '' end
+end

data/mod/05_email/set/all/follow.rb

@@ -0,0 +1,256 @@
+card_accessor :followers
+
+FOLLOWER_IDS_CACHE_KEY = 'FOLLOWER_IDS'
+
+event :cache_expired_because_of_new_set, :before=>:store, :on=>:create, :when=>proc { |c| c.type_id == Card::SetID } do
+  Card.follow_caches_expired
+end
+
+event :cache_expired_because_of_type_change, :before=>:store, :changed=>:type_id do  #FIXME expire (also?) after save
+  Card.follow_caches_expired
+end
+
+event :cache_expired_because_of_name_change, :before=>:store, :changed=>:name do
+  Card.follow_caches_expired
+end
+
+event :cache_expired_because_of_new_user_rule, :before=>:extend, :when=>proc { |c| c.follow_rule_card? }  do
+  Card.follow_caches_expired
+end
+
+format do
+    
+  def follow_link_hash args
+    toggle = args[:toggle] || ( card.followed? ? :off : :on )
+    hash = { :class => "follow-toggle-#{toggle}" }
+
+    case toggle
+    when :off
+      hash[:content] = '*never'
+      hash[:title]   = "stop sending emails about changes to #{card.follow_label}"
+      hash[:verb]    = 'unfollow'
+    when :on
+      hash[:content] = '*always'
+      hash[:title]   = "send emails about changes to #{card.follow_label}"
+      hash[:verb]    = 'follow'
+    end
+    hash
+      
+  end
+  
+  
+end
+
+
+format :json do
+  view :follow_status do |args|
+    follow_link_hash args
+  end
+end
+
+format :html do
+ 
+  view :follow_link, :tags=>:unknown_ok, :perms=>:none do |args|
+    hash = follow_link_hash args
+    text = %[<span class="follow-verb">#{hash[:verb]}</span> #{args[:label]}]
+    opts = {
+      :title           => hash[:title],
+      :class           => "follow-toggle #{hash[:class]}",
+      'data-follow'    => JSON(hash),
+      'data-rule_name' => card.default_follow_set_card.follow_rule_name( Auth.current.name ).to_name.url_key,
+      'data-card_key'  => card.key
+    }
+    link_to text, '', opts
+  end
+  
+  def default_follow_link_args args
+    args[:toggle] ||=  card.followed? ? :off : :on
+    args[:label]  ||=  card.follow_label
+  end
+  
+end
+
+
+def follow_label
+  name
+end
+
+def followers
+  follower_ids.map do |id|
+    Card.fetch(id)
+  end
+end
+
+def follower_names
+  followers.map(&:name)
+end
+
+
+def follow_rule_card?
+  is_user_rule? && rule_setting_name == '*follow'
+end
+
+def follow_option?
+  codename && FollowOption.codenames.include?(codename.to_sym) 
+end
+
+# used for the follow menu
+# overwritten in type/set.rb and type/cardtype.rb
+# for sets and cardtypes it doesn't check whether the users is following the card itself
+# instead it checks whether he is following the complete set
+def followed_by? user_id
+  with_follower_candidate_ids do
+    if follow_rule_applies? user_id
+      return true
+    end
+    if left_card = left and left_card.followed_field?(self) && left_card.followed_by?(user_id)
+      return true
+    end
+    return false
+  end
+end
+
+def followed?
+  followed_by? Auth.current_id 
+end
+
+
+def follow_rule_applies? follower_id
+  follow_rule = rule :follow, :user_id=>follower_id
+  if follow_rule.present?
+    follow_rule.split("\n").each do |value|
+           
+      value_code = value.to_name.code
+      accounted_ids = ( 
+        @follower_candidate_ids[ value_code ] ||=
+          if block = FollowOption.follower_candidate_ids[ value_code ]
+            block.call self
+          else
+            []
+          end
+      )
+              
+      applicable = 
+        if test = FollowOption.test[ value_code ]
+          test.call follower_id, accounted_ids
+        else
+          accounted_ids.include? follower_id
+        end
+      
+      return value.gsub( /[\[\]]/, '' ) if applicable
+    end
+  end 
+  return false
+end
+
+
+def with_follower_candidate_ids
+  @follower_candidate_ids = {}
+  yield
+  @follower_candidate_ids = nil
+end
+
+
+# the set card to be followed if you want to follow changes of card
+def default_follow_set_card
+  Card.fetch("#{name}+*self")
+end
+
+
+# returns true if according to the follow_field_rule followers of self also 
+# follow changes of field_card
+def followed_field? field_card
+  (follow_field_rule = rule_card(:follow_fields)) || follow_field_rule.item_names.find do |item|
+     item.to_name.key == field_card.key ||  (item.to_name.key == Card[:includes].key && included_card_ids.include?(field_card.id) )
+  end
+end
+
+def follower_ids
+  @follower_ids = read_follower_ids_cache || begin
+    result = direct_follower_ids
+    left_card = left
+    while left_card
+      if left_card.followed_field? self
+        result += left_card.direct_follower_ids
+      end
+      left_card = left_card.left
+    end
+    write_follower_ids_cache result
+    result
+  end
+end
+
+
+def direct_followers
+  direct_follower_ids.map do |id|
+    Card.fetch(id)
+  end
+end
+
+# all ids of users that follow this card because of a follow rule that applies to this card
+# doesn't include users that follow this card because they are following parent cards or other cards that include this card
+def direct_follower_ids args={}
+  result = ::Set.new
+  with_follower_candidate_ids do
+    set_names.each do |set_name| 
+      set_card = Card.fetch(set_name)
+      set_card.all_user_ids_with_rule_for(:follow).each do |user_id|
+        if (!result.include? user_id) and self.follow_rule_applies?(user_id)
+          result << user_id
+        end
+      end
+    end
+  end
+  result
+end
+
+def all_direct_follower_ids_with_reason
+  with_follower_candidate_ids do  
+    visited = ::Set.new
+    set_names.each do |set_name| 
+      set_card = Card.fetch(set_name)
+      set_card.all_user_ids_with_rule_for(:follow).each do |user_id|
+        if (!visited.include?(user_id)) && (follow_option = self.follow_rule_applies?(user_id))
+          visited << user_id
+          yield(user_id, :set_card=>set_card, :option=>follow_option)
+        end
+      end
+    end
+  end
+end
+
+
+
+#~~~~~ cache methods
+
+def write_follower_ids_cache user_ids
+  hash = Card.follower_ids_cache
+  hash[id] = user_ids
+  Card.write_follower_ids_cache hash
+end
+
+def read_follower_ids_cache
+  Card.follower_ids_cache[id]
+end
+
+module ClassMethods
+
+  def follow_caches_expired
+    Card.clear_follower_ids_cache
+    Card.clear_user_rule_cache
+  end
+
+  def follower_ids_cache
+    Card.cache.read(FOLLOWER_IDS_CACHE_KEY) || {}
+  end
+  
+  def write_follower_ids_cache hash
+    Card.cache.write FOLLOWER_IDS_CACHE_KEY, hash
+  end
+
+  def clear_follower_ids_cache
+    Card.cache.write FOLLOWER_IDS_CACHE_KEY, nil
+  end
+
+end
+

data/mod/05_email/set/all/notify.rb

@@ -0,0 +1,223 @@
+
+class FollowerStash  
+  def initialize card=nil
+    @followed_affected_cards = Hash.new { |h,v| h[v]=[] } 
+    @visited = ::Set.new
+    add_affected_card(card) if card
+  end
+    
+  def add_affected_card card
+    Auth.as_bot do
+      if !@visited.include? card.key
+        @visited.add card.key
+        card.all_direct_follower_ids_with_reason do |user_id, reason|
+          notify Card.fetch(user_id), :of=>reason
+        end
+        if card.left and !@visited.include?(card.left.name) and follow_field_rule = card.left.rule_card(:follow_fields)
+          
+          follow_field_rule.item_names(:context=>card.left.cardname).each do |item|  
+            if @visited.include? item.to_name.key
+              add_affected_card card.left
+              break
+            elsif item.to_name.key == Card[:includes].key
+              includee_set = Card.search(:included_by=>card.left.name).map(&:key)
+              if !@visited.intersection(includee_set).empty?
+                add_affected_card card.left
+                break
+              end
+            end
+          end
+          
+        end 
+    
+      end
+
+    end
+  end
+  
+  def followers
+    @followed_affected_cards.keys
+  end
+  
+  def each_follower_with_reason  # "follower" is a card object, "followed" a card name
+    @followed_affected_cards.each do |user, reasons|
+      yield(user,reasons.first)
+    end
+  end
+  
+  private
+  
+  def notify follower, because
+    @followed_affected_cards[follower] << because[:of]
+  end
+  
+end
+
+def act_card
+  @supercard || self
+end
+
+event :stash_followers, :after=>:approve, :on=>:delete do
+  act_card.follower_stash ||=  FollowerStash.new
+  act_card.follower_stash.add_affected_card self
+end
+
+event :notify_followers, :after=>:extend, :when=>proc{ |c|
+    !c.supercard and c.current_act and Card::Auth.current_id != WagnBotID 
+  }  do
+    
+  begin
+    @current_act.reload
+    @follower_stash ||= FollowerStash.new
+    @current_act.actions.each do |a|
+      @follower_stash.add_affected_card a.card if a.card
+    end
+    @follower_stash.each_follower_with_reason do |follower, reason|
+      if follower.account and follower != @current_act.actor
+        follower.account.send_change_notice @current_act, reason[:set_card].name, reason[:option]
+      end
+    end
+  rescue =>e  #this error handling should apply to all extend callback exceptions
+    Rails.logger.info "\nController exception: #{e.message}"
+    Card::Error.current = e
+    notable_exception_raised
+  end
+end
+  
+format do  
+  view :list_of_changes, :denial=>:blank do |args|
+    action = get_action(args)
+    
+    relevant_fields = case action.action_type
+      when :create then [:cardtype, :content]
+      when :update then [:name, :cardtype, :content]
+      when :delete then [:content]
+      end
+    
+    relevant_fields.map do |type| 
+      edit_info_for(type, action)
+    end.compact.join
+  end
+  
+  
+  view :subedits, :perms=>:none do |args|
+    subedits = get_act(args).relevant_actions_for(card).map do |action| 
+        if action.card_id != card.id 
+          action.card.format(:format=>@format).render_subedit_notice(:action=>action)
+        end
+      end.compact.join
+      
+    if subedits.present?
+      wrap_subedits subedits
+    else
+      ''
+    end
+  end
+    
+  view :subedit_notice, :denial=>:blank do |args|
+    action = get_action(args)
+    name_before_action = (action.new_values[:name] && action.old_values[:name]) || card.name
+    
+    wrap_subedit_item %{#{name_before_action} #{action.action_type}d
+#{ render_list_of_changes(args) }}
+  end
+  
+  view :followed, :perms=>:none, :closed=>true do |args|
+    if args[:followed_set] && (set_card = Card.fetch(args[:followed_set])) && 
+         args[:follow_option] && (option_card = Card.fetch(args[:follow_option]))
+       option_card.description set_card
+    else
+      'followed card'
+    end
+  end
+
+  view :follower, :perms=>:none, :closed=>true do |args|
+    args[:follower] || 'follower'
+  end
+  
+  view :unfollow_url, :perms=>:none, :closed=>true do |args|
+    if args[:followed_set] && (set_card = Card.fetch(args[:followed_set])) && args[:follow_option] && args[:follower]
+     rule_name = set_card.follow_rule_name args[:follower]    
+     target_name = "#{args[:follower]}+#{Card[:follow].name}"
+     update_path = page_path target_name, :path_opts=>{:action=>:update}, :card=>{:subcards=>{rule_name=>Card[:never].name}}
+     card_url update_path # absolutize path
+    end
+  end
+  
+  def edit_info_for field, action
+    return nil unless action.new_values[field]
+    
+    item_title = case action.action_type
+    when :update then 'new '
+    when :delete then 'deleted '
+    else ''
+    end
+    item_title +=  "#{field}: "
+
+    item_value = if action.action_type == :delete
+      action.old_values[field]
+    else
+      action.new_values[field]
+    end
+    
+     wrap_list_item "#{item_title}#{item_value}"
+  end
+  
+  def get_act args
+    @notification_act ||= args[:act] || (args[:act_id] and Act.find(args[:act_id])) || card.acts.last
+  end
+  
+  def get_action args
+    args[:action] || (args[:action_id] and Action.fetch(args[:action_id])) || card.last_action
+  end
+  
+  
+  def wrap_subedits subedits
+    "\nThis update included the following changes:#{wrap_list subedits}"
+  end
+     
+  def wrap_list list
+    "\n#{list}\n"
+  end
+  
+  def wrap_list_item item
+    "   #{item}\n"
+  end
+  
+  def wrap_subedit_item text
+    "\n#{text}\n"
+  end
+end
+
+
+format :email_text do 
+  view :last_action, :perms=>:none do |args|
+    act = get_act(args)
+    action_on_card =  act.action_on(act.card_id) || act.actions.first
+    "#{action_on_card.action_type}d"
+  end
+end
+
+format :email_html do  
+  view :last_action, :perms=>:none do |args|
+    act = get_act(args)
+    action_on_card =  act.action_on(act.card_id) || act.actions.first
+    "#{action_on_card.action_type}d"
+  end
+  
+  def wrap_list list
+    "<ul>#{list}</ul>\n"
+  end
+
+  def wrap_list_item item
+    "<li>#{item}</li>\n"
+  end
+  
+  def wrap_subedit_item text
+    "<li>#{text}</li>\n"
+  end
+end
+
+
+
+