card 0.0.1 → 1.15.pre

data/mod/05_standard/set/right/account.rb

@@ -0,0 +1,180 @@
+
+include All::Permissions::Accounts
+
+card_accessor :email
+card_accessor :password
+card_accessor :salt
+card_accessor :status
+card_accessor :token
+
+def active?   ; status=='active'  end
+def blocked?  ; status=='blocked' end
+def built_in? ; status=='system'  end
+def pending?  ; status=='pending' end
+
+
+def authenticate_by_token val
+  tcard = token_card                               or return :token_not_found
+  token == val                                     or return :incorrect_token
+  tcard.updated_at > Card.config.token_expiry.ago  or return :token_expired  # > means "after"
+  left and left.accountable?                       or return :illegal_account  #(overkill?)
+  Auth.as_bot { tcard.delete! }
+  left.id
+end
+
+
+format do
+  view :verify_url do |args|
+    card_url "update/#{card.cardname.left_name.url_key}?token=#{card.token}"
+  end
+
+  view :verify_days do |args|
+    ( Card.config.token_expiry / 1.day ).to_s
+  end
+
+  view :reset_password_url do |args|
+    card_url "update/#{card.cardname.url_key}?reset_token=#{card.token_card.refresh(true).content}"
+  end
+
+  view :reset_password_days do |args|
+    ( Card.config.token_expiry / 1.day ).to_s
+  end
+end
+
+
+format :html do
+
+  view :raw do |args|
+    content = []
+    content << "{{+#{Card[:email   ].name}|titled;title:email}}"    unless args[:no_email]
+    content << "{{+#{Card[:password].name}|titled;title:password}}" unless args[:no_password]
+    content * ' '
+  end
+
+  view :edit do |args|
+    args[:structure] = true
+    super args
+  end
+end
+
+
+event :validate_accountability, :on=>:create, :before=>:approve do
+  unless left and left.accountable?
+    errors.add :content, "not allowed on this card"
+  end
+end
+
+event :require_email, :on=>:create, :after=>:approve do
+  unless subcards["+#{Card[:email].name}"] 
+    errors.add :email, 'required'
+  end
+end
+
+
+event :set_default_salt, :on=>:create, :before=>:process_subcards do
+  salt = Digest::SHA1.hexdigest "--#{Time.now.to_s}--"
+  Env[:salt] = salt # HACK!!! need viable mechanism to get this to password
+  subcards["+#{Card[:salt].name}"] ||= {:content => salt }
+end
+
+event :set_default_status, :on=>:create, :before=>:process_subcards do
+  default_status = ( Auth.needs_setup? ? 'active' : 'pending' )
+  subcards["+#{Card[:status].name}"] = { :content => default_status }
+end
+
+def confirm_ok?
+  Card.new( :type_id=>Card.default_accounted_type_id ).ok? :create
+end
+
+event :generate_confirmation_token, :on=>:create, :before=>:process_subcards, :when=>proc{ |c| c.confirm_ok? } do
+  subcards["+#{Card[:token].name}"] = {:content => generate_token }
+end
+
+event :reset_password, :on=>:update, :before=>:approve, :when=>proc{ |c| c.has_reset_token? } do  
+  case ( result = authenticate_by_token @env_token )
+  when Integer
+    Auth.signin result
+    Env.params[:success] = edit_password_success_args
+    abort :success
+  when :token_expired
+    send_reset_password_token
+    Env.params[:success] = {
+      :id => '_self',
+      :view => 'message',
+      :message => "Sorry, this token has expired. Please check your email for a new password reset link."
+    }
+    abort :success
+  else
+    abort :failure, "error resetting password: #{result}" # bad token or account
+  end
+end
+
+def edit_password_success_args
+  { 
+    :id=>left.name,
+    :view=>:related,
+    :related=>{ :name=>"+#{Card[:account].name}", :view=>'edit' }
+  }
+end
+
+def has_reset_token?
+  @env_token = Env.params[:reset_token]
+end
+
+event :reset_token do
+  Auth.as_bot do
+    token_card.update_attributes! :content => generate_token
+  end
+end
+  
+
+event :send_welcome_email do
+  if ((welcome = Card['welcome email']) && welcome.type_code == :email_template)
+    welcome.deliver(:context=>left, :to=>self.email)
+  end
+end
+
+event :send_account_verification_email, :on=>:create, :after=>:extend, :when=>proc{ |c| c.token.present? } do
+  Card[:verification_email].deliver( :context => self, :to => self.email )
+end
+
+event :send_reset_password_token do
+  Auth.as_bot do
+    token_card.update_attributes! :content => generate_token
+  end
+  Card[:password_reset_email].deliver( :context => self, :to => self.email )
+end
+
+def ok_to_read
+  is_own_account? ? true : super
+end
+
+
+def changes_visible? act
+  act.relevant_actions_for(act.card).each do |action|
+    return true if action.card.ok? :read
+  end
+  return false
+end
+
+def send_change_notice act, followed_set, follow_option
+  if changes_visible?(act) 
+    Auth.as(left.id) do
+      Card[:follower_notification_email].deliver(
+        :context       => act.card,
+        :to            => email,
+        :follower      => left.name, 
+        :followed_set  => followed_set,
+        :follow_option => follow_option
+      )
+    end
+  end
+end
+
+
+format :email do  
+  view :mail do |args|
+    args[:to] ||= card.email
+    super args
+  end
+end

data/mod/05_standard/set/right/email.rb

@@ -0,0 +1,52 @@
+#event :
+include All::Permissions::Accounts
+
+view :raw do |args|
+  case
+  when card.real?          ; card.content
+  when card.left.account   ; card.left.account.email #this supports legacy behavior (should be moved to User+*email+*type plus right)
+  else ''
+  end
+end
+
+view :core, :raw
+
+event :validate_email, :after=>:approve, :on=>:save do
+  if content.present? && content !~ /^([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})$/i
+    errors.add :content, 'must be valid address'
+  end
+end
+
+event :validate_unique_email, :after=>:validate_email, :on=>:save do
+  if content.present?
+    Auth.as_bot do
+      wql = { :right_id=>Card::EmailID, :eq=>content }
+      wql[:not] = { :id => id } if id
+      if Card.search( wql ).first
+        errors.add :content, 'must be unique'
+      end
+    end
+  end
+end
+
+event :downcase_email, :before=>:approve, :on=>:save do
+  if content and content != content.downcase
+    self.content = content.downcase
+  end
+end
+
+def email_required?
+  !built_in?
+end
+
+def ok_to_read
+  if is_own_account? or Auth.always_ok?
+    true
+  else
+    deny_because "viewing email is restricted to administrators and account holders"
+  end
+end
+
+def is_own_account?
+  cardname.parts[0].to_name.key == Auth.as_card.cardname.key
+end

data/mod/05_standard/set/right/password.rb

@@ -0,0 +1,39 @@
+
+include All::Permissions::Accounts
+
+view :editor do |args|
+  card.content = ''
+  autocomplete = (@parent && @parent.card.name=='*signin+*account') ? 'on' : 'off' #hack
+  password_field :content, :class=>'card-content', :autocomplete=>autocomplete
+end
+
+view :raw do |args|
+  '<em>encrypted</em>'
+end
+
+event :encrypt_password, :on=>:save, :after=>:process_subcards do
+  salt = (left && left.salt)
+  unless salt.present? or salt = Card::Env[:salt] # hack - fix with better ORM handling
+    #errors.add :password, 'need a valid salt'
+    # turns out we have a lot of existing account without a salt.  not sure when that broke??
+  end
+  if db_content_changed?
+    unless Card::Env[:no_password_encryptions] # hack for import - fix with api for ignoring events
+      self.content = Auth.encrypt content, salt
+    end
+  end
+end
+
+event :validate_password, :on=>:save, :before=>:approve do
+  unless content.length > 3
+    errors.add :password, 'must be at least 4 characters'
+  end
+end
+
+event :validate_password_present, :on=>:update, :before=>:approve do
+  abort :success if content.blank?
+end
+
+def ok_to_read
+  is_own_account? ? true : super
+end

data/mod/05_standard/set/right/salt.rb

@@ -0,0 +1,5 @@
+include All::Permissions::Accounts
+
+view :raw do |args|
+  "Private data"
+end

data/mod/05_standard/set/right/stats.rb

@@ -0,0 +1,35 @@
+
+view :core do |args|
+  if subject = card.left
+  
+    frame args do
+      cache_card = Card.fetch(subject.key)
+      db_card    = Card.find_by_key(subject.key)
+    
+      table = if cache_card && db_card
+        %{<table class="show-cache">
+            <tr><th>Field</th><th>Cache Val</th><th>Database Val</th></tr>
+            #{
+              [ :name, :updated_at, :updater_id, :content ].map do |field|
+                %{<tr>#{ [ field, cache_card.send(field), db_card.send(field) ].map() { |cell| "<td>#{cell}</td>"}.join }</tr>}
+              end.join
+            }
+          </table>
+        }
+      end
+  
+      %{
+        <h1>Cache/DB Comparison</h1>
+        #{ table }
+      
+        <h1>Cached Card Inspect</h1>
+        #{ h cache_card.inspect }
+
+        <h1>Database Card Inspect</h1>
+        #{ h db_card.inspect }
+       }
+    end
+    
+  end
+end
+

data/mod/05_standard/set/right/status.rb

@@ -0,0 +1,9 @@
+include All::Permissions::Accounts
+
+def ok_to_update
+  if is_own_account? && !Auth.always_ok?
+    deny_because you_cant('change the status of your own account')
+  else
+    super
+  end 
+end

data/mod/05_standard/set/right/token.rb

@@ -0,0 +1,5 @@
+include All::Permissions::Accounts
+
+view :raw do |args|
+  "Private data"
+end

data/mod/05_standard/set/right/when_created.rb

@@ -0,0 +1,5 @@
+view :raw do |args|
+  card.left.new_card? ? '' : card.left.created_at.strftime('%A, %B %d, %Y %I:%M %p %Z')
+end
+
+view :core, :raw

data/mod/05_standard/set/right/when_last_edited.rb

@@ -0,0 +1,5 @@
+view :raw do |args|
+  card.left.new_card? ? '' : card.left.updated_at.strftime('%A, %B %d, %Y %I:%M %p %Z')
+end
+
+view :core, :raw

data/mod/05_standard/set/rstar/rules.rb

@@ -0,0 +1,407 @@
+
+format :html do
+
+  view :closed_rule, :tags=>:unknown_ok do |args|
+    return 'not a rule' if !card.is_rule? #these are helpful for handling non-rule rstar cards until we have real rule sets
+      
+    rule_card = find_current_rule_card
+
+    rule_content = !rule_card ? '' : begin
+      subformat(rule_card)._render_closed_content :set_context=>card.cardname.trunk_name
+    end
+
+    cells = [
+      ["rule-setting",
+        link_to( card.cardname.tag.sub(/^\*/,''), path(:view=>:open_rule),
+          :class => 'edit-rule-link slotter', :remote => true, :rel=>'nofollow' )
+      ],
+      ["rule-content",
+        %{<div class="rule-content-container">
+           <span class="closed-content content">#{rule_content}</span>
+         </div> } ],
+      ["rule-set", (rule_card ? rule_card.trunk.label : '') ],
+    ]
+
+    extra_css_class = rule_card && !rule_card.new_card? ? 'known-rule' : 'missing-rule'
+
+    %{<tr class="card-slot closed-rule">} +
+    cells.map do |css_class, content|
+      %{<td class="rule-cell #{css_class} #{extra_css_class}">#{content}</td>}
+    end.join("\n") +
+    '</tr>'
+  end
+
+  
+  view :open_rule, :tags=>:unknown_ok do |args|
+    return 'not a rule' if !card.is_rule?
+    current_rule = args[:current_rule]  
+    setting_name = args[:setting_name]
+    
+    edit_mode = !params[:success] && card.ok?( ( card.new_card? ? :create : :update ) )
+    #~~~~~~ handle reloading due to type change
+    if params[:type_reload] && card_args=params[:card]
+      if card_args[:name] && card_args[:name].to_name.key != current_rule.key
+        current_rule = Card.new card_args
+      else
+        current_rule = current_rule.refresh
+        current_rule.assign_attributes card_args
+        current_rule.include_set_modules
+      end
+      edit_mode = true
+    end
+    
+    opts = {
+      :rule_context => card,   # determines the set options and the success view
+      :set_context  => card.rule_set_name,
+    }
+    rule_view = edit_mode ? :edit_rule : :show_rule
+
+    %{     
+      <tr class="card-slot open-rule #{rule_view.to_s.sub '_', '-'}">
+        <td class="rule-cell" colspan="3">
+          <div class="rule-setting">
+            #{ view_link setting_name.sub(/^\*/,''), :closed_rule, :class=>'close-rule-link slotter' }
+            #{ card_link setting_name, :text=>"all #{setting_name} rules", :class=>'setting-link', :target=>'wagn_setting' }
+          </div>
+          
+          <div class="instruction rule-instruction">
+            #{ process_content "{{#{setting_name}+*right+*help}}" }
+          </div>
+          
+          <div class="card-body">
+            #{ subformat( current_rule )._render rule_view, opts }
+          </div>
+        </td>
+      </tr>
+    }
+
+  end
+  
+  def default_open_rule_args args
+    current_rule_card = find_current_rule_card || begin
+      Card.new :name=> "#{Card[:all].name}+#{card.rule_user_setting_name}"
+    end
+    
+    args.reverse_merge! :current_rule => current_rule_card, :setting_name => card.rule_setting_name
+  end
+  
+
+  view :show_rule, :tags=>:unknown_ok do |args|
+    return 'not a rule' if !card.is_rule?
+    
+    if !card.new_card?
+      set = card.rule_set
+      args[:item] ||= :link
+      %{
+        <div class="rule-set">
+          <label>Applies to</label> #{ card_link set.cardname, :text=>set.label }:
+        </div>
+        #{ _render_core args }
+      }
+    else
+      'No Current Rule'
+    end
+  end
+
+  view :edit_rule, :tags=>:unknown_ok do |args|
+    return 'not a rule' if !card.is_rule?
+
+    form_for card, :url=>path(:action=>:update, :no_id=>true), :remote=>true, :html=>
+        {:class=>"card-form card-rule-form slotter" } do |form|
+      @form = form
+      %{
+        #{ hidden_success_fieldset args[:success]}
+        #{ editor args }
+      }
+    end
+  end
+  
+  def default_edit_rule_args args
+    args[:rule_context] ||= card
+    args[:set_context]  ||= card.rule_set_name 
+    args[:set_selected]   = params[:type_reload] ? card.rule_set_name : false
+    args[:set_options], args[:fallback_set] = args[:rule_context].set_options
+    
+    args[:success] ||= {}
+    args[:success].reverse_merge!( {
+      :card => args[:rule_context],
+      :id   => args[:rule_context].cardname.url_key,
+      :view => 'open_rule',
+      :item => 'view_rule'
+    })
+  end
+  
+  
+  # used keys for args:
+  # :success,  :set_selected, :set_options, :rule_context
+  def editor args      
+    wrap_with( :div, :class=>'card-editor' ) do
+      [
+        (type_fieldset( args ) if card.right.rule_type_editable),
+        fieldset( 'rule', content_field( form, args.merge(:skip_rev_id=>true) ), :editor=>'content' ),
+        set_fieldset( args )
+      ]
+    end + edit_buttons( args )
+  end
+
+
+  def type_fieldset args
+    fieldset 'type', type_field(
+      :href         => path(:name=>args[:success][:card].name, :view=>args[:success][:view], :type_reload=>true),
+      :class        => 'type-field rule-type-field live-type-field',
+      'data-remote' => true
+    ), :editor=>'type'
+  end
+  
+  
+  def hidden_success_fieldset args
+    %{
+      #{ hidden_field_tag 'success[id]', args[:id] || args[:card].name }
+      #{ hidden_field_tag 'success[view]', args[:view] }
+      #{ hidden_field_tag 'success[item]', args[:item] }
+    }
+  end
+  
+  def set_fieldset args
+    current_set_key = card.new_card? ? Card[:all].cardname.key : card.rule_set_key   # (should have a constant for this?)
+    tag = args[:rule_context].rule_user_setting_name
+    narrower_rules = []
+    option_list = 
+      wrap_each_with :li do
+        args[:set_options].map do |set_name, state|
+          
+          checked    = ( args[:set_selected] == set_name or current_set_key && args[:set_options].length==1 )
+          is_current = (state == :current)
+          warning = if narrower_rules.present?
+                      plural = narrower_rules.size > 1 ? 's' : ''
+                      "This rule will not have any effect on this card unless you delete the narrower rule#{plural} "+
+                       "for #{narrower_rules.to_sentence}."
+                    end
+          if is_current || state == :overwritten
+             narrower_rules << Card.fetch(set_name).label
+             narrower_rules.last[0] = narrower_rules.last[0].downcase
+          end
+          rule_name  = "#{set_name}+#{tag}"
+          radio_button( :name, rule_name, :checked=>checked, :warning=>warning ) + %{
+              <span class="set-label" #{'current-set-label' if is_current }>
+                #{ card_link set_name, :text=> Card.fetch(set_name).label, :target=>'wagn_set' }
+                #{'<em>(current)</em>' if is_current }
+                #{"<em> #{card_link "#{set_name}+#{card.rule_user_setting_name}", :text=>"(overwritten)"}</em>" if state == :overwritten }
+              </span>
+             }.html_safe
+         end
+
+       end
+    fieldset 'set', "<ul>#{ option_list }</ul>", :editor => 'set'
+  end
+  
+  def edit_buttons  args
+    delete_button = if !card.new_card?
+                      b_args = { :remote=>true, :class=>'rule-delete-button slotter', :type=>'button' }
+                      b_args[:href] = path :action=>:delete, :success=>args[:success]
+                      if (fset = args[:fallback_set]) && (fcard = Card.fetch(fset))
+                        b_args['data-confirm']="Deleting will revert to #{card.rule_setting_name} rule for #{fcard.label }"
+                      end
+                      %{<span class="rule-delete-section">#{ button_tag 'Delete', b_args }</span>}
+                    end
+    cancel_path = path :view=>( card.new_card? ? :closed_rule : :open_rule )
+    wrap_with( :div, :class=>'edit-button-area' ) do
+     [
+       delete_button,
+       button_tag( 'Submit', :class=>'rule-submit-button' ),
+       button_tag( 'Cancel', :class=>'rule-cancel-button slotter', :type=>'button',
+                             :href=>cancel_path, :success=>true ) 
+     ]
+    end
+  end
+  
+=begin
+  view :edit_rule2 do |args|
+    
+    card_form :update do
+      [
+        _optional_render( :type_fieldset,    args ),
+        _optional_render( :content_fieldset, args ),
+        _optional_render( :set_fieldset,     args ),
+        _optional_render( :button_fieldset,  args )
+      ]
+    end
+  end
+=end
+  
+  def default_follow_item_args args
+    args[:condition] ||= Env.params[:condition] || '*always'
+  end
+  
+  view :follow_item, :tags=>:unknown_ok do |args|
+    if card.new_card? || !card.include_item?(args[:condition])
+      button_view = :add_button
+      form_opts = {:add_item=>args[:condition]}
+    else
+      button_view = :delete_button
+      form_opts = {:drop_item=>args[:condition]}
+    end
+
+    text = if (option_card = Card.fetch args[:condition])
+             option_card.description(card.rule_set)
+           else
+             card.rule_set.follow_label
+           end
+    link_target = if card.rule_set.tag.codename == 'self'
+                    card.rule_set_name.left
+                  else
+                    "#{card.rule_set_name}+by name"
+                  end
+    wrap do
+      card_form({:action=>:update, :name=>card.name, :success=>{:view=>:follow_item}}, 
+              :hidden=>{:condition=>args[:condition]}.merge(form_opts)) do
+        output [
+          _optional_render(button_view, args),
+          card_link( link_target, :text=>text)
+        ]
+      end
+    end
+  end
+  
+  view :delete_button do |args|
+    button_tag :type=>:submit, :class=>'btn-xs btn-item-delete btn-primary', 'aria-label'=>'Left Align' do
+      tag :span, :class=>"glyphicon glyphicon-ok", 'aria-hidden'=>"true"
+    end 
+
+  end
+  
+  view :add_button do |args|
+    button_tag :type=>:submit, :class=>'btn-xs btn-item-add', 'aria-label'=>'Left Align' do
+      tag :span, :class=>"glyphicon glyphicon-plus", 'aria-hidden'=>"true"
+    end
+  end
+  
+
+  private
+
+  def find_current_rule_card
+    # self.card is a POTENTIAL rule; it quacks like a rule but may or may not exist.
+    # This generates a prototypical member of the POTENTIAL rule's set
+    # and returns that member's ACTUAL rule for the POTENTIAL rule's setting
+    if card.new_card?
+      if setting = card.right
+        card.set_prototype.rule_card setting.codename, :user=>card.rule_user
+      end
+    else
+      card
+    end 
+  end
+
+end
+
+
+def rule_set_key
+  rule_set_name.key
+end
+
+def rule_set_name
+  if is_user_rule?
+    cardname.trunk_name.trunk_name
+  else
+    cardname.trunk_name
+  end
+end
+
+def rule_set
+  if is_user_rule?
+    self[0..-3]
+  else
+    trunk
+  end
+end
+
+def rule_setting_name
+  cardname.tag
+end
+
+def rule_user_setting_name
+  if is_user_rule?
+    "#{rule_user_name}+#{rule_setting_name}"
+  else
+   rule_setting_name
+  end
+end
+
+def rule_user_name
+  is_user_rule? ? cardname.trunk_name.tag : nil
+end
+
+def rule_user
+  is_user_rule? ? self[-2] : nil
+end
+
+
+#~~~~~~~~~~ determine the set options to which the user can apply the rule.
+def set_options
+
+  first =  new_card? ? 0 : set_prototype.set_names.index{|s| s.to_name.key == rule_set_key} 
+  rule_cnt = 0
+  res = []
+  fallback_set = nil
+  set_prototype.set_names[first..-1].each do |set_name|
+    if Card.exists?("#{set_name}+#{rule_user_setting_name}")
+      rule_cnt += 1
+      res << if rule_cnt == 1 
+               [set_name,:current] 
+             else
+               fallback_set ||= set_name
+               [set_name,:overwritten]
+             end
+    else
+      res << (rule_cnt < 1 ? [set_name,:enabled] : [set_name,:disabled])
+    end
+  end
+  
+  # fallback_set = if first > 0
+  #                 res[0..(first-1)].find do |set_name|
+  #                   Card.exists?("#{set_name}+#{rule_user_setting_name}")
+  #                 end
+  #               end
+  # last = res.index{|s| s.to_name.key == cardname.trunk_name.key} || -1
+  # # note, the -1 can happen with virtual cards because the self set doesn't show up in the set_names.  FIXME!!
+  # [res[first..last], fallback_set]
+  #
+  # The broadest set should always be the currently applied rule
+  # (for anything more general, they must explicitly choose to "DELETE" the current one)
+  # the narrowest rule should be the one attached to the set being viewed.  So, eg, if you're looking at the "*all plus" set, you shouldn't
+  # have the option to create rules based on arbitrary narrower sets, though narrower sets will always apply to whatever prototype we create
+  
+  return res, fallback_set
+end
+
+def set_prototype
+  if is_user_rule?
+    self[0..-3].prototype
+  else
+    trunk.prototype
+  end
+end
+
+
+
+# 
+
+=begin
+
+def repair_set
+  @set_repair_attempted = true
+  if real?
+    reset_patterns
+    template # repair happens in template loading
+    include_set_modules
+  end
+end
+ 
+def method_missing method_id, *args
+  if !@set_repair_attempted and repair_set
+    send method_id, *args
+  else
+    super
+  end
+end
+=end