wagn 1.12.7

data/mods/standard/sets/all/account.rb

@@ -0,0 +1,241 @@
+module ClassMethods
+  def default_accounted_type_id
+    Card::UserID
+  end
+end
+
+def account
+  Account[ id ]
+end
+
+def accountable?
+  Card.toggle( rule(:accountable) ) and
+  fetch( :trait=>:account, :new=>{} ).ok?( :create)
+end
+
+def parties
+  @parties ||= (all_roles << self.id).flatten.reject(&:blank?)
+end
+
+def among? card_with_acct
+  card_with_acct.each do |auth|
+    return true if parties.member? auth
+  end
+  card_with_acct.member? Card::AnyoneID
+end
+
+def read_rules
+  @read_rules ||= begin
+    rule_ids = []
+    unless id==Card::WagnBotID # always_ok, so not needed
+      ( [ Card::AnyoneID ] + parties ).each do |party_id|
+        if rule_ids_for_party = self.class.read_rule_cache[ party_id ]
+          rule_ids += rule_ids_for_party
+        end
+      end
+    end
+    rule_ids
+  end
+end
+
+def all_roles
+  @all_roles ||= 
+    if id == Card::AnonID
+      []
+    else
+      Account.as_bot do
+        role_trait = fetch :trait=>:roles
+        [ Card::AuthID ] + ( role_trait ? role_trait.item_ids : [] )
+      end
+    end
+end
+
+
+format :html do
+  view :invitation_fields do |args|
+    email_params = params[:email] || {}
+    subject = email_params[:subject] || Card.setting('*invite+*subject') || ''
+    message = email_params[:message] || Card.setting('*invite+*message') || ''
+    
+    success = Card.setting "#{ Card[:invite].name }+#{ Card[:thanks].name }"
+    
+    %{
+      #{ hidden_field_tag :success, "REDIRECT: #{success}" if success }
+      #{ fieldset :subject, text_field( :email, :subject, :value=>subject, :size=>60 ) }
+      #{ fieldset :message, text_area( :email, :message, :value=>message, :rows=>10, :cols => 60 ),
+          :help => "We'll create a password and attach it to the email." }
+      <fieldset>
+        <div class="button-area">
+          #{ submit_tag 'Invite' }
+          #{ link_to 'Cancel', previous_location }
+        </div>
+      </fieldset>
+    }    
+  end
+  
+  
+  view :account, :perms=> lambda { |r| r.card.update_account_ok? } do |args|
+
+    locals = {:slot=>self, :card=>card, :account=>card.account }
+    wrap_frame :account, args do
+      card_form :update, '', 'notify-success'=>'account details updated' do |form|
+        %{
+          #{ hidden_field_tag 'success[id]', '_self' }
+          #{ hidden_field_tag 'success[view]', 'account' }
+          #{ render_account_detail }
+          <fieldset><div class="button-area">#{ submit_tag 'Save Changes' }</div></fieldset>
+        }
+      end
+    end
+  end
+
+
+  view :account_detail, :perms=>lambda { |r| r.card.update_account_ok? } do |args|
+    account = args[:account] || card.account
+    
+    %{
+      #{ fieldset :email,
+        text_field( 'card[account_args]', :email, :autocomplete => :off, :value=>account.email ),
+        :editor => 'content'
+      }
+      #{ fieldset :password,
+        password_field( 'card[account_args]', :password ),
+        :help   => (args[:setup] ? nil : 'no change if blank'),
+        :editor => 'content'
+      }
+      #{ fieldset 'confirm password',
+        password_field( 'card[account_args]', :password_confirmation ),
+        :editor => 'content'
+      }
+      #{ 
+        if !args[:setup] && Account.user.id != account.id 
+          fieldset :block, check_box_tag( 'card[account][blocked]', '1', account.blocked? ), :help=>'prevents sign-ins'
+        end
+      }
+    }
+    
+  end
+  
+
+  view :new_account, :perms=> lambda { |r| r.card.accountable? && !r.card.account } do |args|
+    wrap_frame :new_account, args do
+      card_form :update do |form|
+        %{
+          #{ hidden_field_tag 'success[id]', '_self'                       }
+          #{ hidden_field_tag 'success[view]', 'account'                   }
+          #{ fieldset :email, text_field( 'card[account_args]', :email )   }
+          #{ _render_invitation_field                                      }
+        }
+      end
+    end
+  end
+  
+  
+  
+  view :signin, :tags=>:unknown_ok, :perms=>:none do |args|
+    frame_args = args.merge :title=>'Sign In', :show_help=>true, :hide_menu=>true
+    signin_core = wrap_frame :signin, frame_args do
+      form_tag wagn_path('account/signin') do
+        %{
+          #{ fieldset :email, text_field_tag( 'login', params[:login], :id=>'login_field' ) }
+          #{ fieldset :password, password_field_tag( 'password' ) }
+          <fieldset>
+            <div class="button-area">
+              #{ submit_tag 'Sign in' }
+              #{ link_to '...or sign up!', wagn_path('account/signup') if Card.new(:type_id=>Card::AccountRequestID).ok? :create }
+            </div>
+          </fieldset>
+        }
+      end
+    end
+    %{
+      <div id="sign-in">#{signin_core}</div>
+      <div id="forgot-password">#{_render_forgot_password}</div>
+    }
+  end
+
+
+  view :forgot_password, :perms=>:none do |args|
+    frame_args = args.merge :title=>'Forgot Password', :show_help=>true, :hide_menu=>true
+    wrap_frame :forgot_password, frame_args do
+      form_tag wagn_path('account/forgot_password') do
+        %{
+          #{ fieldset :email, text_field_tag( 'email', params[:email] ) }
+          <fieldset><div class="button-area">#{ submit_tag 'Reset my password' }</div></fieldset>
+        }
+      end
+    end
+  end
+end
+
+
+event :set_stamper, :before=>:approve do
+  self.updater_id = Account.current_id
+  self.creator_id = self.updater_id if new_card?
+end
+
+event :create_account, :after=>:store, :on=>:save do
+  if @account_args && !account && Card.toggle( rule :accountable )
+    
+    # note - following must be done here because subcard handling happens later (after mods loaded)
+    # and account card must be created before user entry
+    # when all are cards, neither the as_bot nor the special treatment should be necessary.
+    account_card = Account.as_bot do
+      Card.create! :name=>"#{ name }+#{ Card[:account].name }"
+    end 
+    
+    @account_args[:status] = 'pending' unless accountable?
+    @account_args.reverse_merge! :card_id => self.id, :status => 'active', :account_id => account_card.id
+
+    user = User.new @account_args
+    handle_user_save user
+    @newly_activated_account = user if user.active?
+  end
+end
+
+event :update_account, :after=>:store, :on=>:update do
+  if @account_args && account && update_account_ok?
+    @account_args[:blocked] = account_args[:blocked] == '1'
+    if Account.as_id == id and account_args[:blocked]
+      raise Wagn::Oops, "can't block own account"
+    end
+    user = account
+    user.attributes = @account_args
+    handle_user_save user
+  end
+end
+
+def handle_user_save user
+  unless user.save
+    user.errors.each do |key,err|
+      errors.add key,err
+    end
+    raise ActiveRecord::Rollback
+  end
+end
+
+
+activation_ready = proc do |c|
+  Wagn::Env.params[:activate] and c.accountable? and c.account
+end
+
+event :activate_account, :after=>:store, :on=>:update, :when=>activation_ready do
+  account.update_attributes :status=>'active'
+  @newly_activated_account = account
+end
+
+
+event :notify_accounted, :after=>:extend do
+  if @newly_activated_account && @newly_activated_account.active?
+    email_args = Wagn::Env.params[:email] || {}
+    email_args[:message] ||= Card.setting('*signup+*message') || "Thanks for signing up to #{Card.setting('*title')}!"
+    email_args[:subject] ||= Card.setting('*signup+*subject') || "Account info for #{Card.setting('*title')}!"
+    @newly_activated_account.send_account_info email_args
+  end
+end
+
+event :block_deleted_user, :after=>:store, :on=>:delete do
+  if account = Account[ self.id ]
+    account.update_attributes :status=>'blocked'
+  end
+end

data/mods/standard/sets/all/admin.rb

@@ -0,0 +1,53 @@
+view :setup, :tags=>:unknown_ok do |args|
+  account = User.new( ( params[:card] && params[:card][:account_args] ) || {} )
+  frame_args = {
+    :title=>'Welcome, Wagneer!',
+    :show_help=>true,
+    :hide_menu=>true, 
+    :help_text=>'To get started, set up an account.'
+  }
+    
+  wrap_frame :setup, frame_args do
+    form_for :card do |f|
+      @form = f
+      %{
+        #{ _render_name_editor :help=>'usually first and last name' }
+        #{ hidden_field_tag 'card[type_id]', Card.default_accounted_type_id }
+        #{ _render_account_detail :account=>account, :setup=>true }
+        <fieldset><div class="button-area">#{ submit_tag 'Create' }</div></fieldset>
+        #{ render_error }
+      }
+    end
+  end
+end
+
+view :show_cache do |args|
+  wrap_frame :show_cache, args do 
+    key = card.key
+    cache_card = Card.fetch(key)
+    db_card = Card.find_by_key(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, :current_revision_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

data/mods/standard/sets/all/all_css.rb

@@ -0,0 +1,39 @@
+# -*- encoding : utf-8 -*-
+    
+format :css do
+
+  def get_inclusion_defaults
+    { :view => :content }
+  end
+
+  view :show do |args|
+    view = args[:view] || :content
+    render view
+  end
+  
+  view :content do |args|
+    major_comment( %{ Style Card: "#{ card.name }" } ) +
+   _render_core( args )
+  end
+  
+  view :missing do |args|
+    major_comment "MISSING Style Card: #{card.name}"
+  end
+  
+  view :import do |args|
+    %{\n@import url("#{ _render_url :item=>:import }");\n}
+  end
+  
+  view :url, :perms=>:none do |args|
+    page_path card.name, :format=>:css, :item=>args[:item]
+#    wagn_url _render_linkname
+  end
+
+  def major_comment comment, char='-'
+    edge = %{/* #{ char * ( comment.length+4 ) } */}
+    main = %{/* #{ char } #{ comment } #{ char } */}
+    "#{edge}\n#{main}\n#{edge}\n\n"
+  end
+
+
+end

data/mods/standard/sets/all/all_csv.rb

@@ -0,0 +1,53 @@
+# -*- encoding : utf-8 -*-
+require 'csv'
+
+format :csv  do
+  def get_inclusion_defaults
+    { :view => :core }
+  end
+  
+  def default_item_view 
+    @depth == 0 ? :csv_row : :name
+  end
+
+  
+  view :csv_row do |args|
+    array = _render_raw.scan( /\{\{[^\}]*\}\}/ ).map do |inc|
+      process_content( inc ).strip
+    end
+    
+    CSV.generate_line(array).strip
+    #strip is because search already joins with newlines
+  end
+
+  view :missing do |args|
+    ''
+  end
+
+  view :csv_title_row do |args|
+    #NOTE: assumes all cards have the same structure!
+    begin
+      card1 = search_vars[:results].first  
+    
+      parsed_content = Card::Content.new card1.content, self
+      unless String === parsed_content.__getobj__
+        titles = parsed_content.map do |chunk|
+          next if chunk.class != Card::Chunk::Include
+          opts = chunk.options
+          if ['name','link'].member? opts[:view]
+            opts[:view]
+          else
+            opts[:inc_name].to_name.tag
+          end
+        end.compact.map {|title| title.to_s.upcase }
+        CSV.generate_line titles
+        
+      else
+        ''
+      end
+    rescue
+      ''
+    end
+  end
+
+end

data/mods/standard/sets/all/attach.rb

@@ -0,0 +1,143 @@
+# -*- encoding : utf-8 -*-
+
+def attach_array(rev_id=nil)
+  c=if rev_id || self.new_card? || selected_revision_id==current_revision_id
+      self.content
+    else      
+      Card::Revision.find_by_id(selected_revision_id).content
+    end
+  !c || c =~ /^\s*<img / ?  ['','',''] : c.split(/\n/)
+end
+
+def attach_array_set i, v
+  rev_id = ( cr = current_revision and cr.id )
+  c = attach_array rev_id
+  c = c[0..2] # make sure there is no mod set for uploaded files
+  
+  if c[i] != v
+    c[i] = v
+    self.content = c*"\n"
+  end
+end
+def attach_file_name()    attach_array[0] end
+def attach_content_type() attach_array[1] end
+def attach_file_size()    attach_array[2] end
+def attach_mod()         attach_array[3] end
+
+def attach_extension()    attach.send( :interpolate, ':extension' )  end
+
+def attach_file_name=(v)
+  return if !v # does this happen?
+  attach_array_set 0, v
+  attach_array_set 1, MIME::Types.type_for(v).first.to_s
+  # was having issues with browsers getting mime types wrong,
+  # eg application/octet-stream for pdfs in Firefox (both versions 4 and 10)
+  # this solution means we just do a lookup based on the extension.
+  # perhaps not ideal, but at least consistent.  Not sure browsers do much more.
+end
+def attach_file_size=(v) attach_array_set(2, v) if v end
+
+STYLES = %w{ icon small medium large original }
+
+
+def attachment_format(ext)
+  return nil unless ext.present? && attach
+  return nil unless original_ext = attach_extension
+  return original_ext if ['file', original_ext].member? ext
+  exts = MIME::Types[attach.content_type]
+  return nil unless exts
+  return ext if exts.find {|mt| mt.extensions.member? ext }
+  return exts[0].extensions[0]
+rescue Exception => e
+  Rails.logger.info "attachment_format issue: #{e.message}"
+  nil
+end
+
+# FIXME: test extension matches content type
+
+
+
+def attachment_link(rev_id) # create filesystem links to previous revision
+  if styles = case type_code
+        when 'File'; ['']
+        when 'Image'; STYLES
+      end
+    save_rev_id = selected_revision_id
+    links = {}
+
+    self.selected_revision_id = rev_id
+    styles.each { |style|  links[style] = attach.path(style)          }
+
+    self.selected_revision_id = current_revision_id
+    styles.each { |style|  File.link links[style], attach.path(style) }
+
+    self.selected_revision_id = save_rev_id
+  end
+end
+
+def before_post_attach
+  Rails.logger.info "bpa called for #{name}"
+  at=self.attach
+  at.instance_write :file_name, at.original_filename
+
+  Card::ImageID == (type_id || Card.fetch_id( @type_args[:type] ) )
+  # returning true enables thumnail creation
+end
+
+
+def self.included(base)
+  base.class_eval do
+    has_attached_file :attach, :preserve_files=>true,
+      :default_url => "missing",
+      :url => ":file_path/:basename-:size:revision_id.:extension",
+      :path => ":local/:card_id/:size:revision_id.:extension",
+      :styles => { :icon   => '16x16#', :small  => '75x75',
+                 :medium => '200x200>', :large  => '500x500>' }
+
+    before_post_process :before_post_attach
+
+    validates_each :attach do |rec, attr, value|
+      if [Card::FileID, Card::ImageID].member? rec.type_id
+        max_size = (max = Card['*upload max']) ? max.content.to_i : 5
+        if value.size.to_i > max_size.megabytes
+          rec.errors.add :file_size, "File cannot be larger than #{max_size} megabytes"
+        end
+      end
+    end
+  end
+end
+
+
+
+module Paperclip::Interpolations
+  
+  extend Wagn::Location
+
+  def local at, style_name
+    if mod = at.instance.attach_mod
+      # generalize this to work with any mod (needs design)
+      "#{Wagn.gem_root}/mods/#{mod}/files"
+    else
+      Wagn.paths['files'].existent.first
+    end
+  end
+      
+  def file_path at, style_name
+    wagn_path Wagn.config.files_web_path
+  end
+
+  def card_id at, style_name
+    at.instance.id
+  end
+
+  def basename at, style_name
+    at.instance.name.to_name.url_key
+  end
+
+  def size(at, style_name)
+    at.instance.type_id==Card::FileID || style_name.blank? ? '' : "#{style_name}-"
+  end
+
+  def revision_id(at, style_name) at.instance.selected_revision_id end
+end
+