wagn 1.12.7

data/app/controllers/account_controller.rb

@@ -0,0 +1,67 @@
+# -*- encoding : utf-8 -*-
+class AccountController < WagnController
+
+  def signin
+    @card = Card.new
+    if params[:login]
+      password_authentication params[:login], params[:password]
+    else
+      show :signin
+    end
+  end
+
+  def signout
+    self.current_account_id = nil
+    flash[:notice] = "Successfully signed out"
+    redirect_to Card.path_setting('/')  # previous_location here can cause infinite loop.  ##  Really?  Shouldn't.  -efm
+  end
+
+  def forgot_password
+    @card = Card.new
+    if request.post? and email = params[:email]
+      @account = Account[ email.downcase ]
+      case
+      when @account.nil?
+        flash[:notice] = "Unrecognized email."
+        show :signin, 404
+      when !@account.active?
+        flash[:notice] = "That account is not active."
+        show :signin, 403
+      else
+        @account.send_account_info(
+          :subject => "Password Reset",
+          :message => "You have been given a new temporary password. Please update your password once you've signed in."
+        )
+        flash[:notice] = "Check your email for your new temporary password"
+        redirect_to previous_location
+      end
+    else
+      show :forgot_password 
+    end
+  end
+
+  protected
+
+  def password_authentication(login, password)
+    if self.current_account_id = Account.authenticate( params[:login], params[:password] )
+      flash[:notice] = "Successfully signed in"
+      #warn Rails.logger.info("to prev #{previous_location}")
+      redirect_to previous_location
+    else
+      usr=Account[ params[:login].strip.downcase ]
+      failed_login(
+        case
+        when usr.nil?     ; "Unrecognized email."
+        when usr.blocked? ; "Sorry, that account is blocked."
+        else              ; "Wrong password"
+        end
+      )
+    end
+  end
+
+  def failed_login(message)
+    flash[:notice] = "Oops: #{message}"
+    show :signin, 403
+  end
+
+end

data/app/controllers/admin_controller.rb

@@ -0,0 +1,130 @@
+# -*- encoding : utf-8 -*-
+class AdminController < CardController
+  before_filter :admin_only, :except=>:setup
+  
+  def setup
+    raise Wagn::Oops, "Already setup" unless Account.no_logins?
+    Wagn::Env[:recaptcha_on] = false
+    if request.post?
+      Account.as_bot do
+        @card = Card.create params[:card]
+        set_default_request_recipient
+
+        if @card.errors.empty?
+          roles_card = card.fetch :trait=>:roles, :new=>{}
+          roles_card.content = "[[#{Card[Card::AdminID].name}]]"
+          roles_card.save
+          self.current_account_id = @card.id
+          Card.cache.delete 'no_logins'
+          flash[:notice] = "You're good to go!"
+          redirect_to Card.path_setting('/')
+        else
+          show :setup
+        end
+      end
+    else
+      @card = Card.new( params[:card] || {} ) #should prolly skip default
+      show :setup
+    end
+  end
+
+  def clear_cache
+    Wagn::Cache.reset_global
+    render_text 'Cache cleared'
+  end
+
+  def memory
+    oldmem = session[:memory]
+    session[:memory] = total = profile_memory
+    
+    render_text %{      
+      <p>Total: #{total} </p>
+      #{
+        if oldmem
+          %{ <p>Diff: #{total - oldmem}</p> }
+        end
+      }
+    }
+  end
+
+  #DEPRECATED.  migrated away old links?
+  def tasks
+    render_text %{
+      <h1>Global Permissions - REMOVED</h1>
+      <p>&nbsp;</p>
+      <p>After moving so much configuration power into cards, the old, weaker global system is no longer needed.</p>
+      <p>&nbsp;</p>
+      <p>Account permissions are now controlled through +*account cards and role permissions through +*role cards.</p>
+    }
+  end
+  
+  def repair_references
+    Card::Reference.repair_all
+    stats 'References Repaired'
+  end
+
+
+  def stats msg
+    render_text %{
+      <h2>#{msg}</h2>
+      <p>cards: #{Card.where(:trash=>false).count}</p>
+      <p>trashed cards: #{Card.where(:trash=>true).count}</p>
+      <p>revisions: #{Card::Revision.count}</p>
+      <p>references: #{Card::Reference.count}</p>
+    }
+  end
+
+  def empty_trash
+    Card.empty_trash
+    stats 'Trash Emptied'
+  end
+  
+  def delete_old_revisions
+    Card::Revision.delete_old
+    stats 'Old Revisions Deleted'
+  end
+
+  def delete_old_sessions
+    if params[:months] and params[:months].to_i > 0
+      sql = 'DELETE FROM sessions WHERE updated_at < DATE_SUB(NOW(), INTERVAL %s MONTH);' % params[:months]
+      ActiveRecord::Base.connection.execute(sql)
+      render_text 'deleted'
+    else
+      render_text %{
+        <form>Delete session records last updated more than <input name="months"/> months ago</form>
+      }
+    end
+  end
+
+  private
+
+  def get_current_memory_usage
+    `ps -o rss= -p #{Process.pid}`.to_i
+  end
+  
+  def profile_memory(&block)
+    before = get_current_memory_usage
+    file, line, _ = caller[0].split(':')
+    if block_given?
+      instance_eval(&block)
+      (get_current_memory_usage - before) / 1024.0
+    else
+      before = 0
+      (get_current_memory_usage - before) / 1024.0
+    end
+  end
+
+  def render_text response
+    render :text =>response
+  end
+  
+  def admin_only
+    raise Wagn::PermissionDenied unless Account.always_ok?
+  end
+
+  def set_default_request_recipient
+    to_card = Card.fetch '*request+*to', :new=>{}
+    to_card.content=params[:card][:account_args][:email]
+    to_card.save
+  end
+end

data/app/controllers/card_controller.rb

@@ -0,0 +1,163 @@
+# -*- encoding : utf-8 -*-
+class CardController < WagnController
+
+  before_filter :load_id, :only => [ :read ]
+  before_filter :load_card
+  before_filter :refresh_card, :only=> [ :create, :update, :delete, :rollback ]
+  
+  #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  
+  #  CORE METHODS
+  
+  def create
+    handle { card.save }
+  end
+
+  def read
+    save_location # should be an event!
+    show
+  end
+
+  def update
+    card.new_card? ? create : handle { card.update_attributes params[:card] }
+  end
+
+  def delete
+    discard_locations_for card #should be an event
+    params[:success] ||= 'REDIRECT: *previous'
+    handle { card.delete }
+  end
+
+  #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+  ## the following methods need to be merged into #update
+
+  def save_draft
+    if card.save_draft params[:card][:content]
+      render :nothing=>true
+    else
+      render_errors
+    end
+  end
+
+  def rollback
+    revision = card.revisions[params[:rev].to_i - 1]
+    card.update_attributes! :content=>revision.content
+    card.attachment_link revision.id
+    show
+  end
+
+
+  def watch
+    watchers = card.fetch :trait=>:watchers, :new=>{}
+    watchers = watchers.refresh
+    myname = Account.current.name
+    watchers.send((params[:toggle]=='on' ? :add_item : :drop_item), myname)
+    watchers.save!
+    ajax? ? show(:watch) : read
+  end
+
+
+
+
+  private
+  
+  def handle
+    yield ? success : render_errors
+  end
+  
+  #-------( FILTERS )
+
+  def refresh_card
+    @card =  card.refresh
+  end
+
+  def load_id    
+    params[:id] = case
+      when params[:id]
+        params[:id]
+      when Account.no_logins?
+        return wagn_redirect( 'admin/setup' )
+      when params[:card] && params[:card][:name]
+        params[:card][:name]
+      when Card::Format.tagged( params[:view], :unknown_ok )
+        ''
+      else  
+        Card.setting(:home) || 'Home'
+      end
+  rescue ArgumentError # less than perfect way to handle encoding issues.
+    raise Wagn::BadAddress
+  end
+  
+
+  def load_card
+    @card = case params[:id]
+      when '*previous'
+        return wagn_redirect( previous_location )
+      when /^\~(\d+)$/
+        Card.fetch( $1.to_i ) or raise Wagn::NotFound 
+      when /^\:(\w+)$/
+        Card.fetch $1.to_sym
+      else
+        opts = params[:card]
+        opts = opts ? opts.clone : {} #clone so that original params remain unaltered.  need deeper clone?
+        opts[:type] ||= params[:type] # for /new/:type shortcut.  we should fix and deprecate this.
+        name = params[:id] || opts[:name]
+        
+        if params[:action] == 'create'
+          # FIXME we currently need a "new" card to catch duplicates (otherwise #save will just act like a normal update)
+          # I think we may need to create a "#create" instance method that handles this checking.
+          # that would let us get rid of this...
+          opts[:name] ||= name
+          Card.new opts
+        else
+          Card.fetch name, :new=>opts
+        end
+      end
+    @card.selected_revision_id = params[:rev].to_i if params[:rev]
+
+    Wagn::Env[:main_name] = params[:main] || (card && card.name) || ''
+    render_errors if card.errors.any?
+    true
+  end
+
+
+
+  #------- REDIRECTION 
+
+  def success
+    redirect, new_params = !ajax?, {}
+
+    target = case params[:success]
+      when Hash
+        new_params = params[:success]
+        redirect ||= !!(new_params.delete :redirect)
+        new_params.delete :id
+      when /^REDIRECT:\s*(.+)/
+        redirect=true
+        $1
+      when nil  ;  '_self'
+      else      ;   params[:success]
+      end
+        
+    target = case target
+      when '*previous'     ;  previous_location #could do as *previous
+      when '_self  '       ;  card #could do as _self
+      when /^(http|\/)/    ;  target
+      when /^TEXT:\s*(.+)/ ;  $1
+      else                 ;  Card.fetch target.to_name.to_absolute(card.cardname), :new=>{}
+      end
+
+    case
+    when redirect
+      target = page_path target.cardname, new_params if Card === target
+      wagn_redirect target
+    when String===target
+      render :text => target
+    else
+      @card = target
+      self.params = self.params.merge new_params #need tests.  insure we get slot, main...
+      show
+    end
+  end
+
+end
+

data/app/controllers/stub_card_controller.rb

@@ -0,0 +1,9 @@
+# -*- encoding : utf-8 -*-
+class StubCardController < CardController
+  def url_options
+    default_url_options
+  end
+
+  def params()  {} end
+  def session() {} end
+end

data/app/controllers/wagn_controller.rb

@@ -0,0 +1,123 @@
+# -*- encoding : utf-8 -*-
+class WagnController < ActionController::Base
+
+  include Wagn::AuthenticatedSystem
+  include Wagn::Location
+  include Recaptcha::Verify
+
+  before_filter :per_request_setup, :except=>[:fast_404]
+  layout nil
+
+  attr_reader :card
+
+  def fast_404
+    message = "<h1>404 Page Not Found</h1>"
+    render :text=>message, :layout=>false, :status=>404
+  end
+
+  protected
+  def per_request_setup
+#    ActiveSupport::Notifications.instrument 'wagn.per_request_setup', :message=>"" do
+    request.format = :html if !params[:format] #is this used??
+    Wagn::Cache.renew
+    Account.current_id = self.current_account_id || Card::AnonID
+    Wagn::Env.reset :controller=>self
+
+    Card::Format.ajax_call = ajax?             # move to Wagn::Env?
+  end
+
+  def ajax?
+    request.xhr? || params[:simulate_xhr]
+  end
+
+  def html?
+    [nil, 'html'].member?(params[:format])
+  end
+
+  # ----------( rendering methods ) -------------
+
+  def wagn_redirect url
+    url = wagn_url url #make sure we have absolute url
+    if ajax?
+      # lets client reset window location (not just receive redirected response)
+      # formerly used 303 response, but that gave IE the fits
+      render :json => {:redirect=> url}
+    else
+      redirect_to url
+    end
+  end
+
+
+  def render_errors
+    #fixme - should prioritize certain error classes
+    code = nil
+    card.errors.each do |key, msg|
+      break if code = Card.error_codes[ key ]
+    end
+    view, status = code || [ :errors, 422]
+    show view, status
+  end
+  
+
+
+  def show view = nil, status = 200
+    format = request.parameters[:format]
+    format = :file if params[:explicit_file] or !FORMATS.split('|').member? format #unknown format
+
+    opts = ( params[:slot] || {} ).deep_symbolize_keys
+    opts[:view] = view || params[:view]      
+
+    formatter = Card::Format.new card, :controller=>self, :format=>format, :inclusion_opts=>opts[:items]
+    result = formatter.render_show opts
+    status = formatter.error_status || status
+    
+    if format==:file && status==200
+      send_file *result
+    elsif status == 302
+      wagn_redirect result
+    else
+      args = { :text=>result, :status=>status }
+      args[:content_type] = 'text/text' if format == :file
+      render args
+    end
+  end
+  
+
+
+  rescue_from Exception do |exception|
+    Rails.logger.info "exception = #{exception.class}: #{exception.message}"
+    
+    @card ||= Card.new
+    
+    view = case exception
+      ## arguably the view and status should be defined in the error class;
+      ## some are redundantly defined in view
+      when Wagn::PermissionDenied, Card::PermissionDenied
+        :denial
+      when Wagn::NotFound, ActiveRecord::RecordNotFound, ActionController::MissingFile
+        :not_found
+      when Wagn::BadAddress
+        :bad_address
+      when Wagn::Oops
+        card.errors.add :exception, exception.message 
+        # Wagn:Oops error messages are visible to end users and are generally not treated as bugs.
+        # Probably want to rename accordingly.
+        :errors
+      else #the following indicate a code problem and therefore require full logging
+        Rails.logger.info exception.backtrace*"\n"
+        notify_airbrake exception if Airbrake.configuration.api_key
+
+        if ActiveRecord::RecordInvalid === exception
+          :errors
+        elsif ENV['WAGN_MIGRATION'] or Rails.logger.level == 0 # could also just check non-production mode...
+          raise exception
+        else
+          :server_error
+        end
+      end
+
+    show view
+  end
+end
+
+