wagn 1.12.7

data/app/mailers/mailer.rb

@@ -0,0 +1,108 @@
+# -*- encoding : utf-8 -*-
+require 'open-uri'
+
+class Mailer < ActionMailer::Base
+  @@defaults = Wagn.config.email_defaults || {}
+  @@defaults.symbolize_keys!
+  @@defaults[:return_path] ||= @@defaults[:from] if @@defaults[:from]
+  @@defaults[:charset] ||= 'utf-8'
+  default @@defaults
+
+  include Wagn::Location
+
+
+  def account_info cd_with_acct, args
+    @email, subject, @message, @password = [:to, :subject, :message, :password].map do |k|
+      args[k] or raise "Missing email parameter: #{k}"
+    end
+
+    @pw_url   = wagn_url "#{cd_with_acct.cardname.url_key}?view=account"
+    @login_url= wagn_url "account/signin"
+
+    #FIXME - might want different "from" settings for different contexts?
+    invite_from = Card.setting( '*invite+*from' ) || begin
+      from_card_id = Account.current_id
+      from_card_id = Card::WagnBotID if [ Card::AnonID, cd_with_acct.id ].member? from_card_id
+      from_card = Card[from_card_id]
+      "#{from_card.name} <#{from_card.account.email}>"
+    end
+    
+    mail_from( { :to=>@email, :subject=>subject }, invite_from )
+  end
+
+  def signup_alert invite_request
+    @site = Card.setting :title
+    @card = invite_request
+    @email= invite_request.account.email
+    @name = invite_request.name
+    @content = invite_request.content
+    @request_url  = wagn_url invite_request
+    @requests_url = wagn_url Card['Account Request']
+
+    args = {
+      :to           => Card.setting('*request+*to'),
+      :subject      => "#{invite_request.name} signed up for #{@site}",
+      :content_type => 'text/html',
+    }
+    mail_from args, Card.setting('*request+*from') || "#{@name} <#{@email}>"
+  end
+
+
+  def change_notice cd_with_acct, card, action, watched, subedits=[], updated_card=nil
+    cd_with_acct = Card[cd_with_acct] unless Card===cd_with_acct
+    email = cd_with_acct.account.email
+    #warn "change_notice( #{cd_with_acct}, #{email}, #{card.inspect}, #{action.inspect}, #{watched.inspect} Uc:#{updated_card.inspect}...)"
+
+    updated_card ||= card
+    @card = card
+    @updater = updated_card.updater.name
+    @action = action
+    @subedits = subedits
+    @card_url = wagn_url card
+    @change_url  = wagn_url "card/changes/#{card.cardname.url_key}"
+    @unwatch_url = wagn_url "card/watch/#{watched.to_name.url_key}?toggle=off"
+    @udpater_url = wagn_url card.updater
+    @watched = (watched == card.cardname ? "#{watched}" : "#{watched} cards")
+
+    args = {
+      :to           => email,
+      :subject      => "[#{Card.setting :title} notice] #{@updater} #{action} \"#{card.name}\"" ,
+      :content_type => 'text/html',
+    }
+    mail_from args, Card[Card::WagnBotID].account.email
+  end
+
+  def flexmail config
+    @message = config.delete(:message)
+
+    if attachment_list = config.delete(:attach) and !attachment_list.empty?
+      attachment_list.each_with_index do |cardname, i|
+        if c = Card[ cardname ] and c.respond_to?(:attach)
+          attachments["attachment-#{i + 1}.#{c.attach_extension}"] = File.read( c.attach.path )
+        end
+      end
+    end
+
+    mail_from config, config[:from]
+  end
+
+  private
+
+  def mail_from args, from
+    #puts "unprocessed mail args: #{args}"
+    unless ENV['WAGN_MIGRATION']
+      from_name, from_email = (from =~ /(.*)\<(.*)>/) ? [$1.strip, $2] : [nil, from]
+      if default_from=@@defaults[:from]
+        args[:from] = !from_email ? default_from : "#{from_name || from_email} <#{default_from}>"
+        args[:reply_to] ||= from
+      else
+        args[:from] = from
+      end
+      #puts "mail args: #{args}"
+      mail args
+    end
+  end
+
+
+end
+

data/app/models/account.rb

@@ -0,0 +1,196 @@
+# -*- encoding : utf-8 -*-
+require_dependency 'user'
+
+class Account
+  @@as_card = @@as_id = @@current_id = @@current = @@user = nil
+
+  #after_save :reset_instance_cache
+
+  class << self
+    def admin()          self[ Card::WagnBotID    ]   end
+    def as_user()        self[ Account.as_id      ]   end
+    def user()           self[ Account.current_id ]   end
+
+    def cache()          Wagn::Cache[Account]         end
+
+    def create_ok?
+      base  = Card.new :name=>'dummy*', :type_id=>Card.default_accounted_type_id
+      trait = Card.new :name=>"dummy*+#{Card[:account].name}"
+      base.ok?(:create) && trait.ok?(:create)
+    end
+
+    # Authenticates a user by their login name and unencrypted password.  Returns the user or nil.
+    def authenticate(email, password)
+      u = User.find_by_email(email.strip.downcase)
+      u && u.authenticated?(password.strip) ? u.card_id : nil
+    end
+
+    # Encrypts some data with the salt.
+    def encrypt(password, salt)
+      Digest::SHA1.hexdigest("#{salt}--#{password}--")
+    end
+
+    # Account caching
+    def [] mark
+      if mark
+        cache_key = Integer === mark ? "~#{mark}" : mark
+        cached_val = cache.read cache_key
+        case cached_val
+        when :missing; nil
+        when nil
+          val = if Integer === mark
+            User.find_by_card_id mark
+          else
+            User.find_by_email mark
+          end
+          cache.write cache_key, ( val || :missing )
+          val
+        else
+          cached_val
+        end
+      end
+    end
+    
+#----------
+    def current_id
+      @@current_id ||= Card::AnonID
+    end
+
+    def current
+      if @@current && @@current.id == current_id
+        @@current
+      else
+        @@current = Card[current_id]
+      end
+    end
+
+    def user
+      if @@user && @@user.card_id == current_id
+        @@user
+      else
+        @@user = Account[ current_id ]
+      end
+    end
+
+    def current_id= card_id
+      @@user = @@current = @@as_id = @@as_card = nil
+      @@current_id = card_id
+    end
+
+    def get_user_id user
+      case user
+      when NilClass;   nil
+      when User    ;   user.card_id
+      when Card    ;   user.id
+      when Integer ;   user
+      else
+        user = user.to_s
+        Card::Codename[user] or (cd=Card[user] and cd.id)
+      end
+    end
+
+    def as given_user
+      tmp_id, tmp_card = @@as_id, @@as_card
+      @@as_id, @@as_card = get_user_id( given_user ), nil  # we could go ahead and set as_card if given a card...
+
+      @@current_id = @@as_id if @@current_id.nil?
+
+      if block_given?
+        value = yield
+        @@as_id, @@as_card = tmp_id, tmp_card
+        return value
+      else
+        #fail "BLOCK REQUIRED with Card#as"
+      end
+    end
+
+    def as_bot &block
+      as Card::WagnBotID, &block
+    end
+
+    def among? authzed
+      as_card.among? authzed
+    end
+
+    def as_id
+      @@as_id || current_id
+    end
+
+    def as_card
+      if @@as_card and @@as_card.id == as_id
+        @@as_card
+      else
+        @@as_card = Card[as_id]
+      end
+    end
+
+    def logged_in?
+      current_id != Card::AnonID
+    end
+
+    def no_logins?()
+      c = Card.cache
+      !c.read('no_logins').nil? ? c.read('no_logins') : c.write('no_logins', (User.count < 3))
+    end
+
+    def always_ok?
+      #warn Rails.logger.warn("aok? #{as_id}, #{as_id&&Card[as_id].id}")
+      return false unless usr_id = as_id
+      return true if usr_id == Card::WagnBotID #cannot disable
+
+      always = Card.cache.read('ALWAYS') || {}
+      #warn(Rails.logger.warn "Account.always_ok? #{usr_id}")
+      if always[usr_id].nil?
+        always = always.dup if always.frozen?
+        always[usr_id] = !!Card[usr_id].all_roles.detect{|r|r==Card::AdminID}
+        #warn(Rails.logger.warn "update always hash #{always[usr_id]}, #{always.inspect}")
+        Card.cache.write 'ALWAYS', always
+      end
+      #warn Rails.logger.warn("aok? #{usr_id}, #{always[usr_id]}")
+      always[usr_id]
+    end
+    # PERMISSIONS
+
+
+  protected
+    # FIXME stick this in session? cache it somehow??
+    def ok_hash
+      usr_id = Account.as_id
+      ok_hash = Card.cache.read('OK') || {}
+      #warn(Rails.logger.warn "ok_hash #{usr_id}")
+      if ok_hash[usr_id].nil?
+        ok_hash = ok_hash.dup if ok_hash.frozen?
+        ok_hash[usr_id] = begin
+            Card[usr_id].all_roles.inject({:role_ids => {}}) do |ok,role_id|
+              ok[:role_ids][role_id] = true
+              ok
+            end
+          end || false
+        #warn(Rails.logger.warn "update ok_hash(#{usr_id}) #{ok_hash.inspect}")
+        Card.cache.write 'OK', ok_hash
+      end
+      r=ok_hash[usr_id]
+      #warn "ok_h #{r}, #{usr_id}, #{ok_hash.inspect}";
+    end
+
+  public
+
+    NON_CREATEABLE_TYPES = %w{ account_request setting set }
+
+    def createable_types
+      type_names = Account.as_bot do
+        Card.search :type=>Card::CardtypeID, :return=>:name, :not => { :codename => ['in'] + NON_CREATEABLE_TYPES }
+      end
+      type_names.reject do |name|
+        !Card.new( :type=>name ).ok? :create
+      end.sort
+    end
+
+    def reset_cache_item card_id, email=nil
+      cache.write "~#{card_id}", nil
+      cache.write email, nil if email
+    end
+
+  end
+
+end

data/app/models/card.rb

@@ -0,0 +1,42 @@
+# -*- encoding : utf-8 -*-
+
+class Card < ActiveRecord::Base
+  require_dependency 'card/query'
+  require_dependency 'card/constant'
+  require_dependency 'card/set'
+  require_dependency 'card/format'
+
+  extend Card::Set
+  extend Card::Constant
+  extend Wagn::Loader
+
+  require_dependency 'card/exceptions'
+  include Card::Exceptions
+
+  has_many :revisions, :order => :id
+  has_many :references_from, :class_name => :Reference, :foreign_key => :referee_id
+  has_many :references_to,   :class_name => :Reference, :foreign_key => :referer_id
+
+  cache_attributes 'name', 'type_id' #Review - still worth it in Rails 3?
+
+  cattr_accessor :set_patterns, :error_codes
+  @@set_patterns, @@error_codes = [], {}
+
+  attr_writer :selected_revision_id #writer because read method is in mod (and does not override upon load)
+  attr_accessor :action,
+    :cards, :supercard,                          # rename to subcards?
+    :comment, :comment_author, :account_args,    # obviated soon
+    :update_referencers                          # wrong mechanism for this
+
+
+  define_callbacks :approve, :store, :extend
+  
+  before_validation :approve
+  around_save :store
+  after_save :extend
+
+  load_mods
+
+  tracks :content # we can phase this out and just use "dirty" handling once current content is stored in the cards table
+
+end

data/app/models/card/reference.rb

@@ -0,0 +1,71 @@
+# -*- encoding : utf-8 -*-
+class Card::Reference < ActiveRecord::Base
+  def referencer
+    Card[referer_id]
+  end
+
+  def referencee
+    Card[referee_id]
+  end
+
+  class << self
+    
+    def delete_all_from card
+      delete_all :referer_id => card.id
+    end
+    
+    def delete_all_to card
+      where( :referee_id => card.id ).update_all :present=>0, :referee_id => nil
+    end
+    
+    def update_existing_key card, name=nil
+      key = (name || card.name).to_name.key
+      where( :referee_key => key ).update_all :present => 1, :referee_id => card.id
+    end
+
+    def update_on_rename card, newname, update_referers=false
+      if update_referers
+        # not currentlt needed because references are deleted and re-created in the process of adding new revision
+        #where( :referee_id=>card.id ).update_all :referee_key => newname.to_name.key
+      else
+        delete_all_to card
+      end
+      #Rails.logger.warn "update on rename #{card.inspect}, #{newname}, #{update_referers}"
+      update_existing_key card, newname
+    end
+
+    def update_on_delete card
+      delete_all_from card
+      delete_all_to card
+    end
+    
+    def repair_missing_referees
+      where( Card.where( :id=>arel_table[:referee_id]).exists.not ).update_all :referee_id=>nil
+    end
+    
+    def repair_all
+      connection.execute 'truncate card_references'
+      Card.update_all :references_expired => 1
+
+      expired_cards_remain = true
+      batchsize, count_updated = 100, 0
+
+      while expired_cards_remain
+        batch = Card.find_all_by_references_expired(1, :order=>"name ASC", :limit=>batchsize)
+        if batch.empty?
+          expired_cards_remain = false
+        else
+          Rails.logger.debug "Updating references for '#{batch.first.name}' to '#{batch.last.name}' ... "; $stdout.flush        
+          batch.each do |card|
+            count_updated += 1
+            card.update_references
+          end
+          Rails.logger.info "batch done.  \t\t#{count_updated} total updated"
+        end
+      end
+      
+    end
+    
+  end
+
+end

data/app/models/card/revision.rb

@@ -0,0 +1,45 @@
+# -*- encoding : utf-8 -*-
+class Card::Revision < ActiveRecord::Base
+  before_save :set_stamper
+
+  class << self
+    def cache
+      Wagn::Cache[Card::Revision]
+    end
+    
+    def delete_old
+      where( Card.where( :current_revision_id=>arel_table[:id] ).exists.not ).delete_all
+    end
+    
+    def delete_cardless
+      where( Card.where( :id=>arel_table[:card_id] ).exists.not ).delete_all
+    end
+  end
+
+  def set_stamper
+    self.creator_id = Account.current_id
+  end
+
+  def creator
+    Card[ creator_id ]
+  end
+
+  def card
+    Card[ card_id ]
+  end
+
+  def title #ENGLISH
+    current_id = card.current_revision_id
+    if id == current_id
+      'Current Revision'
+    elsif id > current_id
+      'AutoSave'
+    else
+      card.revisions.each_with_index do |rev, index|
+        return "Revision ##{index + 1}" if rev.id == id
+      end
+      '[Revisions Missing]'
+    end
+  end
+
+end