card 0.0.1 → 1.15.pre

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

@@ -0,0 +1,27 @@
+def send_action_mails args  
+  setting = "on_#{args[:on]}".to_sym    
+  email_templates_for( setting ) do |mailcard|
+    mailcard.deliver( context: self )
+  end
+end
+
+def email_templates_for setting
+  
+  if email_templates = @email_template_cache ||
+      ( event_card = self.rule_card(setting) and event_card.extended_item_cards )
+    email_templates.each do |mailcard|
+      yield(mailcard)
+    end
+  end
+end
+
+[:create, :update, :delete].each do |action|
+  event "observer_#{action}".to_sym, :after=>:extend, :on=>action do 
+    self.send_action_mails :on=>action
+  end
+end
+
+event :cache_delete_email_templates, :after=>:approve, :on=>:delete do 
+  event_card = self.rule_card(:on_delete)
+  @email_template_cache = event_card && event_card.extended_item_cards
+end

data/mod/05_email/set/right/bcc.rb

@@ -0,0 +1,45 @@
+
+def process_email_addresses context_card, format_args, args
+  format(format_args).render_email_addresses(args.merge(:context=>context_card))
+end
+
+
+format do
+  def chunk_list  #turn off autodetection of uri's 
+    :references
+  end
+end
+
+
+format :html do
+  view :pointer_items do |args|    
+    card.item_names(:context=>:raw).map do |iname|
+      wrap_item iname, args
+    end.join ', '
+  end
+end
+
+format :email_text do
+  view :email_addresses do |args|
+    context = args[:context] || self
+    card.item_names(:context=>context.cardname).map do |item_name|
+      # note that context is processed twice here because pointers absolutize item_names by default
+      # while other types can return relative names.  That's poor default behavior and should be fixed!
+      item_name = item_name.to_name.to_absolute(context).to_s
+      if item_name.match /.+\@.+\..+/ 
+        item_name
+      elsif item_card = Card.fetch( item_name )
+        if item_card.account
+          item_card.account.email
+        else
+          item_card.contextual_content(context,:format=>:email_text).split( /[,\n]/ )
+        end
+      end          
+    end.flatten.compact.join(', ')
+  end
+end
+
+
+
+# _user, info@mail.com, Ethan, Pointer -> ..., _left+email, my email address -> info@mail.com
+

data/mod/05_email/set/right/cc.rb

@@ -0,0 +1,3 @@
+include Bcc
+format(:email_text) { include Bcc::EmailTextFormat }
+format(:html)       { include Bcc::HtmlFormat }

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

@@ -0,0 +1,9 @@
+include All::Permissions::Follow
+
+def options 
+  Card::FollowOption.cards.compact
+end
+
+def options_card
+  Card.new :name=>'follow_options_card', :type_code=>:pointer, :content=>options.map {|oc| "[[#{oc.title}]]" }.join("\n")
+end

data/mod/05_email/set/right/follow_fields.rb

@@ -0,0 +1,3 @@
+event :follow_fields_changed, :before=>:extend do
+  Card.follow_caches_expired
+end

data/mod/05_email/set/right/followers.rb

@@ -0,0 +1,30 @@
+# -*- encoding : utf-8 -*-
+
+include Card::Set::Type::Pointer
+
+def raw_content
+  if left
+    items = if (left.type_id == SetID) || (left.type_id == CardtypeID)
+              left.default_follow_set_card.all_user_ids_with_rule_for(:follow).map do |user_id|
+                if left.followed_by?(user_id) && (user = Card.find(user_id))
+                  user.name 
+                else 
+                  nil
+                end
+              end.compact
+            else
+              left.follower_names
+            end
+    items.map {|item| "[[#{item}]]"}.join "\n"
+  else
+    ''
+  end
+end
+
+def virtual?; true end
+
+format() do 
+  include Card::Set::Type::Pointer::Format     
+end
+
+format(:html)  { include Card::Set::Type::Pointer::HtmlFormat }

data/mod/05_email/set/right/following.rb

@@ -0,0 +1,52 @@
+
+def virtual?; true end
+
+
+format :html do
+
+   view :core do |args|
+     if card.left and Auth.signed_in?
+       render_rule_editor args
+     else
+       followers_card = Card.fetch("#{card.cardname.left}+#{Card[:followers].name}") 
+       nest followers_card, :view=>:titled, :item=>:link
+     end
+   end
+   
+   view :status do |args|
+     if rcard = current_follow_rule_card
+       rcard.item_cards.map do |item|
+         %{<div class="alert alert-success" role="alert">
+           <strong>#{rcard.rule_set.follow_label}</strong>: #{item.title}
+          </div>}
+       end.join
+     else
+       "No following preference"
+     end
+   end
+   
+   view :closed_content do |args|
+     ''
+   end
+   
+=begin
+   view :editor do |args|
+     hidden_field( :content, :class=>'card-content', 'no-autosave'=>true) +
+        (args.delete(:select_list) ? raw(render_rule_editor(args)) : super(args) )
+   end
+=end
+   
+   view :rule_editor do |args|
+     preference_name = "#{card.left.default_follow_set_card.name}+#{Auth.current.name}+#{Card[:follow].name}"
+     rule_context = Card.fetch preference_name, :new=>{:type_id=>PointerID}
+     wrap_with :div, :class=>'edit-rule' do
+       subformat(current_follow_rule_card || rule_context).render_edit_rule :rule_context=>rule_context, 
+         :success=>{ :view=>'status', :id=>card.name }
+     end
+   end
+   
+   def current_follow_rule_card
+     card.left.rule_card :follow, :user=>Auth.current
+   end
+     
+end

data/mod/05_email/set/right/from.rb

@@ -0,0 +1,3 @@
+include Bcc
+format(:email_text) { include Bcc::EmailTextFormat }
+format(:html)       { include Bcc::HtmlFormat }

data/mod/05_email/set/right/html_message.rb

@@ -0,0 +1,3 @@
+def clean_html?
+  false
+end

data/mod/05_email/set/right/to.rb

@@ -0,0 +1,3 @@
+include Bcc
+format(:email_text) { include Bcc::EmailTextFormat }
+format(:html)       { include Bcc::HtmlFormat }

data/mod/05_email/set/self/always.rb

@@ -0,0 +1,14 @@
+include Card::FollowOption
+
+self.follow_opts :position=>2
+
+self.follow_test { |follower_id, accounted_ids| true }
+
+def title
+  'Following'
+end
+
+def label
+  'follow'
+end
+

data/mod/05_email/set/self/created.rb

@@ -0,0 +1,21 @@
+include Card::FollowOption
+
+self.restrictive_follow_opts :position=>1
+
+self.follower_candidate_ids do |card|
+  [ card.creator_id ]
+end
+
+
+def title
+  'Following content you created'
+end
+
+def label
+  "follow if I created"
+end
+
+def description set_card
+  "#{set_card.follow_label} I created"
+end
+

data/mod/05_email/set/self/edited.rb

@@ -0,0 +1,24 @@
+include Card::FollowOption
+
+self.restrictive_follow_opts :position=>2
+
+self.follower_candidate_ids do |card|
+  # FIXME? - could optimize by not using cards table...
+  Card.search :editor_of=>card.name, :return=>:id
+end
+
+
+def title 
+  'Following content you edited'
+end
+
+def label
+  "follow if I edited"
+end
+  
+def description set_card
+  "#{set_card.follow_label} I edited"
+end
+
+
+

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

@@ -0,0 +1,2 @@
+extend Card::Setting
+setting_opts :group=>:communication, :position=>7, :rule_type_editable => false, :user_specific=>true

data/mod/05_email/set/self/follow_defaults.rb

@@ -0,0 +1,66 @@
+event :update_follow_rules, :after=>:store, :on=>:save, :when=> proc { |c| c.update_all_users } do
+  defaults = item_names.map do |item|
+    if ((set_card = Card.fetch item.to_name.left) && set_card.type_code == :set) 
+      option_card = Card.fetch(item.to_name.right) || Card[item.to_name.right.to_sym]
+      option = if option_card.follow_option?
+                 option_card.name
+               else
+                 '*always'
+               end
+      [set_card, option]
+    elsif ((set_card = Card.fetch sug) && set_card.type_code == :set) 
+      [set_card, '*always']
+    end
+  end.compact
+  Auth.as_bot do
+    Card.search(:type=>'user').each do |user|
+      defaults.each do |set_card, option|
+        if (follow_rule = Card.fetch(set_card.follow_rule_name(user.name), :new=>{}))
+         follow_rule.drop_item "*never"
+         follow_rule.drop_item "*always"
+         follow_rule.add_item option
+         follow_rule.save!
+        end
+      end
+    end
+  end
+  Card.follow_caches_expired
+end
+
+format :html do
+  view :edit, :perms=>:update, :tags=>:unknown_ok do |args|
+    frame_and_form :update, args do
+      [
+        _optional_render( :content_fieldsets, args ),
+        _optional_render( :confirm_update_all, args ),
+        _optional_render( :button_fieldset,   args )
+      ]
+    end
+  end
+  
+  
+  view :confirm_update_all do |args|
+    wrap args do
+      alert 'info'do
+        %{
+          <h1>Are you sure you want to change the default follow rules?</h1>
+          <p>You may choose to update all existing users. This may take a while. </p>
+        }
+      end
+    end
+  end
+  
+  def default_edit_args args
+    args[:hidden] ||= {}
+    args[:hidden].reverse_merge!(
+      :success  => '_self',
+      :card     => { :update_all_users => false }
+    )
+    args[:buttons] = %{
+      #{ button_tag 'Submit and update all users', :disable_with=>'Updating', :class=>'follow-updater' }
+      #{ button_tag 'Submit', :class=>'follow'         }
+      #{ button_tag 'Cancel', :class=>'slotter', :type=>'button', :href=>path(:view=>:edit, :id=>card.id)}
+    }
+    
+  end
+end

data/mod/05_email/set/self/never.rb

@@ -0,0 +1,15 @@
+include Card::FollowOption
+
+self.follow_opts :position=>3
+
+self.follow_test { |follower_id, accounted_ids| false }
+
+
+def title
+  'Ignoring'
+end
+
+def label
+  'ignore'
+end
+

data/mod/05_email/set/type/email_template.rb

@@ -0,0 +1,113 @@
+
+def clean_html?
+  false
+end
+
+def deliver args={}
+  begin
+    mail = format.render_mail(args)
+    mail.deliver
+  rescue Net::SMTPError => exception
+    errors.add :exception, exception.message 
+  end
+end
+
+def process_email_field field, config, args
+  config[field] = 
+    if args[field] 
+      args[field]
+    elsif field_card = fetch(:trait=>field)
+      # configuration can be anything visible to configurer
+      user = ( args[:follower] and Card.fetch(args[:follower]) ) || field_card.updater
+      Auth.as( user ) do
+        yield(field_card)
+      end
+    else 
+      ''
+    end
+end
+
+def process_message_field field, config, args, format, special_args=nil
+  process_email_field( field, config, args ) do |field_card|
+    content_args = args.clone
+    content_args.merge! special_args if special_args
+    field_card.contextual_content args[:context], { :format=>format }, content_args
+  end
+end
+
+def email_config args={}
+  config = {}
+  args[:context] ||= self
+  
+  [:to, :from, :cc, :bcc].each do |field_name|
+    process_email_field( field_name, config, args ) do |field_card|
+      field_card.process_email_addresses args[:context], {:format=>'email_text'}, args
+    end
+  end
+  process_email_field( :attach, config, args ) do |field_card|
+    field_card.extended_item_contents args[:context]
+  end
+  process_message_field :subject,      config, args, 'email_text', :content_opts=>{ :chunk_list=>:inclusion_only }
+  process_message_field :text_message, config, args, 'email_text'
+  process_message_field :html_message, config, args, 'email_html'
+  config[:html_message] = Card::Mailer.layout config[:html_message] if config[:html_message].present? 
+                          
+  
+  from_name, from_email = (config[:from] =~ /(.*)\<(.*)>/) ? [$1.strip, $2] : [nil, config[:from]]
+
+  if default_from=Card::Mailer.default[:from]
+    config[:from] = from_email ? %["#{from_name || from_email}" <#{default_from}>] : default_from
+    config[:reply_to] ||= config[:from]
+  elsif config[:from].blank? 
+    config[:from] = Card[Card::WagnBotID].account.email
+  end
+  config.select {|k,v| v.present? }
+end
+
+
+format do     
+  view :mail, :perms=>:none do |args|
+    args = card.email_config(args)
+    text_message = args.delete(:text_message)
+    html_message = args.delete(:html_message)
+    attachment_list = args.delete(:attach)
+    alternative = (text_message.present? && html_message.present?)
+    mail = Card::Mailer.new_mail(args) do
+      if alternative 
+        if attachment_list and !attachment_list.empty?
+          content_type 'multipart/mixed'
+          part :content_type => 'multipart/alternative' do |copy|
+            copy.part :content_type => 'text/plain' do |plain|
+              plain.body = text_message
+            end
+            copy.part :content_type => 'text/html' do |html|
+              html.body = html_message
+            end
+          end    
+        else
+          text_part { body text_message }
+          html_part do
+            content_type 'text/html; charset=UTF-8'
+            body html_message
+          end
+        end
+      elsif html_message.present?
+        content_type 'text/html; charset=UTF-8'
+        body html_message
+      else
+        content_type 'text/plain; charset=UTF-8'
+        text_part { body text_message }
+      end
+      
+      if attachment_list
+        attachment_list.each_with_index do |cardname, i|
+          if c = Card[ cardname ] and c.respond_to?(:attach)
+            add_file :filename => "attachment-#{i + 1}.#{c.attach_extension}", :content => File.read( c.attach.path )
+          end
+        end
+      end    
+    end   #TODO add error handling
+    mail
+  end
+  
+end