fcid 0.0.1

data/lib/fcid/publisher/base.rb

@@ -0,0 +1,398 @@
+# encoding: utf-8
+require 'action_mailer/adv_attr_accessor'
+module Fcid
+  module Publisher #:nodoc:
+    class Base
+      class Controller #:nodoc: we need this let the url helpers to work
+        include ActionController::UrlWriter
+        def self.default_url_options
+          #ActionMailer::Base.default_url_options
+          Fcid::Publisher::Base.default_url_options
+        end
+      end
+
+      include ActionMailer::AdvAttrAccessor
+      cattr_accessor :default_url_options
+      if Object.const_defined?(:ActionController)
+        include ActionController::UrlWriter
+        include ActionController::Layout
+      end
+      include ActionView::Helpers
+
+      # setting for host
+=begin
+    def self.default_url_options
+      {:host=>"uc.powerapple.com",:only_path=>false}
+    end
+=end
+
+      private_class_method :new #:nodoc:
+
+      class_inheritable_accessor :view_paths
+      cattr_accessor :logger
+      self.logger = Rails.logger
+
+      @@raise_delivery_errors = true
+      cattr_accessor :raise_delivery_errors
+
+
+      @@perform_deliveries = true
+      cattr_accessor :perform_deliveries
+
+      @@deliveries = []
+      cattr_accessor :deliveries
+
+      @@default_charset = "utf-8"
+      cattr_accessor :default_charset
+
+
+      cattr_reader :protected_instance_variables
+      @@protected_instance_variables = %w(@body)
+
+      adv_attr_accessor :delivery_method
+
+      # Define the body of the message. This is either a Hash (in which case it
+      # specifies the variables to pass to the template when it is rendered),
+      # or a string, in which case it specifies the actual text of the message.
+      adv_attr_accessor :body
+
+      # Specify the from address for the message.
+      adv_attr_accessor :from
+
+      # The recipient addresses for the message, either as a string (for a single
+      # address) or an array (for multiple addresses).
+      adv_attr_accessor :recipients
+
+      # The date on which the message was sent. If not set (the default), the
+      # header will be set by the delivery agent.
+      adv_attr_accessor :sent_on
+
+      # Specify the subject of the message.
+      adv_attr_accessor :subject
+
+      # Specify the template name to use for current message. This is the "base"
+      # template name, without the extension or directory, and may be used to
+      # have multiple publisher methods share the same template.
+      adv_attr_accessor :template
+
+      # we use this to show an image in activities
+      adv_attr_accessor :activitable
+
+      adv_attr_accessor :feed_type
+
+
+      adv_attr_accessor :body_data
+      adv_attr_accessor :title_data
+
+      adv_attr_accessor :title_template
+      adv_attr_accessor :body_template
+
+      # popup text
+      adv_attr_accessor :popup_text
+
+      # popup url
+      adv_attr_accessor :popup_url
+
+      # for notification
+      adv_attr_accessor :buttons
+
+      # Override the publisher name, which defaults to an inflected version of the
+      # publisher's class name. If you want to use a template in a non-standard
+      # location, you can use this to specify that location.
+      def publisher_name(value = nil)
+        if value
+          self.publisher_name = value
+        else
+          self.class.publisher_name
+        end
+      end
+
+      def publisher_name=(value)
+        self.class.publisher_name = value
+      end
+
+      # The mail object instance referenced by this publisher.
+      attr_reader :feed
+      attr_reader :template_name, :default_template_name, :action_name
+
+      class << self
+        attr_writer :publisher_name
+
+        def publisher_name
+          @publisher_name ||= name.underscore
+        end
+
+        # for ActionView compatibility
+        alias_method :controller_name, :publisher_name
+        alias_method :controller_path, :publisher_name
+
+        def respond_to?(method_symbol, include_private = false) #:nodoc:
+          matches_dynamic_method?(method_symbol) || super
+        end
+
+        def method_missing(method_symbol, *parameters) #:nodoc:
+          match = matches_dynamic_method?(method_symbol)
+          case match[1]
+          when 'create'  then new(match[2], *parameters).feed
+          when 'deliver' then new(match[2], *parameters).deliver!
+          when 'register' then new(match[2], *parameters).register!
+          when 'new'     then nil
+          else super
+          end
+        end
+
+
+
+        def register(name)
+          logger.debug "registering template: #{name}" if logger
+          content = new.send(name + "_template")
+          oneline = story = ""
+          case content
+          when String
+            oneline = content
+          when Array
+            oneline,story = content.first,content.last
+          when Hash
+            oneline = content[:oneline]
+            stroy  = content[:story]
+          end
+          ActivityTemplate.register("#{self.name}.#{name}",oneline,story)
+        end
+
+        def register_all
+          publisher_instance_methods = self.public_instance_methods - UC::Publisher::Base.public_instance_methods
+          publisher_instance_methods.grep(/_action$/).each do |action|
+            register(action)
+          end
+        end
+
+        def deliver(feed)
+          new.deliver!(feed)
+        end
+
+        def template_root
+          self.view_paths && self.view_paths.first
+        end
+
+        def template_root=(root)
+          self.view_paths = ActionView::Base.process_view_paths(root)
+        end
+
+
+
+        private
+        def matches_dynamic_method?(method_name) #:nodoc:
+          method_name = method_name.to_s
+          /(create|deliver|register)_([_a-z]\w*)/.match(method_name) || /^(new)$/.match(method_name)
+        end
+      end
+
+      # Instantiate a new publisher object. If +method_name+ is not +nil+, the publisher
+      # will be initialized according to the named method. If not, the publisher will
+      # remain uninitialized (useful when you only need to invoke the "receive"
+      # method, for instance).
+      def initialize(method_name=nil, *parameters) #:nodoc:
+        @controller = Controller.new
+        create!(method_name, *parameters) if method_name
+      end
+
+      def images(src,url=nil)
+        @images << [src,url]
+      end
+
+
+      def create!(method_name, *parameters) #:nodoc:
+        initialize_defaults(method_name)
+        __send__(method_name, *parameters)
+
+        delivery_method  case method_name
+      when /_action$/,/_feed$/
+        :action
+      when /_notification$/
+        :notification
+      when /_email$/
+        :email
+      when /_activity$/
+        :activity
+      when /_popup$/
+        :popup
+      else
+        raise "unknow delivery method"
+      end if delivery_method.nil?
+
+      # notification will be sent
+      delivery_method :test if Rails.env == "test" && delivery_method != :notification
+
+      # If an explicit, textual body has not been set, we check assumptions.
+      unless String === @body_template
+        template_exists ||= template_root["#{publisher_name}/#{@template}"]
+        @body_template = render_message(@template, @body_data.merge(@body)) if template_exists
+      end
+
+      # build the feed object itself
+      @feed = create_feed
+    end
+
+    def deliver!(feed = @feed)
+      raise "no feed object available for delivery!" unless feed
+      unless logger.nil?
+        logger.info  "Sent feed to #{Array(recipients).join(', ')}"
+        logger.debug "\n#{feed.inspect}"
+      end
+
+      begin
+        m = "perform_delivery_#{delivery_method}"
+        # raise m
+        __send__(m, feed) if perform_deliveries
+      rescue Exception => e  # Net::SMTP errors or sendmail pipe errors
+        raise e if raise_delivery_errors
+      end
+    end
+
+    private
+    # Set up the default values for the various instance variables of this
+    # publisher. Subclasses may override this method to provide different
+    # defaults.
+    def initialize_defaults(method_name)
+      @charset ||= @@default_charset.dup
+      @template ||= method_name
+      @default_template_name = @action_name = @template
+      @template = @template + ".html" if @template # set default extension name
+      @publisher_name ||= self.class.name.underscore
+      @body_template = nil
+      @title_template = nil
+      @body_data ||= {}
+      @body ||= {}
+      @title_data ||= {}
+      @images = []
+    end
+
+    def render_message(method_name, body)
+      render :file => method_name, :body => body
+    end
+
+    def render(opts)
+      body = opts.delete(:body)
+      if opts[:file] && (opts[:file] !~ /\// && !opts[:file].respond_to?(:render))
+        opts[:file] = "#{publisher_name}/#{opts[:file]}"
+      end
+
+      begin
+        old_template, @template = @template, initialize_template_class(body)
+        layout = respond_to?(:pick_layout, true) ? pick_layout(opts) : false
+        @template.render(opts.merge(:layout => layout))
+      ensure
+        @template = old_template
+      end
+    end
+
+    def default_template_format
+      :html
+    end
+
+    def default_template(action)
+
+    end
+=begin
+      def candidate_for_layout?(options)
+        !@template.send(:exempt_from_layout?, default_template_name)
+      end
+=end
+
+    def template_root
+      self.class.template_root
+    end
+
+    def template_root=(root)
+      self.class.template_root = root
+    end
+
+    def template_path
+      "#{template_root}/#{publisher_name}"
+    end
+
+    def initialize_template_class(assigns)
+      ActionView::Base.new(view_paths, assigns, self)
+    end
+
+    def create_feed
+      return self
+      feed             = Feed.new
+      feed.popup_text  = popup_text
+      feed.popup_url   = popup_url
+      feed.user_id     = from
+      feed.feed_type   = feed_type
+      feed.title_data  = title_data
+      feed.body_data   = body_data
+      feed.title_template = title_template
+      feed.body_template = body_template
+      @images.each_with_index do |image,index|
+        feed.send("image_#{index + 1}=",image.first)
+        feed.send("image_#{index + 1}_link=",image.last) if image.last
+      end
+      feed
+    end
+
+
+    # 发送为action
+    def perform_delivery_action(feed)
+      logger.debug "send as action: #{feed.inspect}" if logger
+      logger.debug "from #{from.inspect}" if logger
+      Fcid::Feed.with_session feed.recipients do
+        fcid_feed = Fcid::Feed.new 
+        fcid_feed.title_template = feed.title_template
+        fcid_feed.title_data     = feed.title_data
+        fcid_feed.body_template  = feed.body_template
+        fcid_feed.body_data      = feed.body_data
+        images = feed.instance_variable_get(:@images)
+        images.each_with_index do |image,index|
+          fcid_feed.send(:"picture#{index + 1}_url=",image[0])
+          fcid_feed.send(:"picture#{index + 1}_link=",image[1])
+        end
+        fcid_feed.save
+        fcid_feed
+      end
+    end
+
+    def perform_delivery_email(feed)
+      email = Fcid::Email.new :user_id=>recipients,:body=>body_template,:subject=>subject
+      email.save
+    end
+
+    # 发送为notification
+    def perform_delivery_notification(feed)
+      logger.debug "send as notification: #{feed.inspect}" if logger
+      # replace as real send notfication
+      notification = Notification.new :type=>feed.feed_type
+      notification.user_id = feed.user_id || recipients
+      notification.message = feed.body_template
+      notification.buttons = [buttons].flatten.compact
+      notification.save!
+    end
+
+    def perform_delivery_popup(feed)
+      if feed.popup_text
+        SessionClient.instance.drb.popup(feed.recipients,feed.popup_text,feed.popup_url,:to=>:self)
+      end
+    end
+
+
+    def perform_delivery_test(feed)
+      deliveries << feed 
+    end
+
+
+    include ActionMailer::Helpers
+    Dir.glob(File.join(RAILS_ROOT,"app","helpers","*_helper.rb")) do |file|
+      # load all helpers
+      helper_name = File.basename(file).gsub(/_helper.rb$/,'')
+      helper helper_name.to_sym
+      include ActionView::Helpers
+      include "#{helper_name}_helper".classify.constantize
+    end 
+
+    self.template_root = [File.join(RAILS_ROOT,"app","views")]
+
+  end
+end
+end

data/lib/fcid/session.rb

@@ -0,0 +1,5 @@
+# encoding: utf-8
+module Fcid
+  class Session < Base
+  end
+end

data/lib/fcid/user.rb

@@ -0,0 +1,50 @@
+# encoding: utf-8
+#这里似乎有个奇怪的问题 指定model的功能将被禁用
+module Fcid
+  class User < Base
+
+    def self.sub_domain?(domain)
+      a = domain.split(".").reverse[0,2]
+      b = Fcid.host.split(".").reverse[0,2]
+      return b == a
+      rescue
+        false
+    end
+
+    def self.config
+      Fcid.config
+    end
+
+    #通过auto_token来验证用户，成功返回用户，失败返回 false
+    def self.authenticate_by_auth_token(token)
+      user = get(:info,:token=>token)
+      rsync(user['username'])
+    end
+
+    def self.authenticate(username_or_email,password)
+      get(:authenticate,:email=>username_or_email,:password=>password)
+    end
+
+
+    def self.columns
+      Fcid.columns
+    end
+
+    def avatar(style = "thumb") 
+      avatar_url
+    end
+
+    [:username,:email,:password,:password_confirmation].each do |column|
+      define_method "#{column}" do
+        attributes[column.to_s]
+      end
+
+      define_method "#{column}=" do
+        attributes[column.to_s] = column
+      end
+    end
+
+    alias_method :name,:username
+
+  end
+end

data/lib/fcid/user_methods.rb

@@ -0,0 +1,39 @@
+# encoding: utf-8
+module Fcid
+  module UserMethods
+    def self.included(base)
+      base.class_eval do
+      end
+      base.send(:include,InstanceMethods)
+      base.send(:extend,ClassMethods)
+    end
+
+
+    module InstanceMethods
+      def avatar
+        read_attribute(:avatar).blank? ? "/assets/avatar.gif" : read_attribute(:avatar)
+      end
+      
+      def sync
+        self.class.sync id
+      end
+
+    end
+
+    module ClassMethods
+
+      def sync(id)
+        user_res = Fcid::User.find(id)
+        user = find_or_initialize_by_id(id)
+        Fcid.columns.each do |key,value|
+          user.send(:write_attribute,key,user_res.send(value))
+        end
+        user.after_sync if user.respond_to?(:after_sync) # can add other initialize code
+        user.save!
+        user
+      end
+
+    end
+
+  end
+end

data/lib/fcid/version.rb

@@ -0,0 +1,3 @@
+module Fcid
+  VERSION = "0.0.1"
+end

data/lib/fcid.rb

@@ -0,0 +1,12 @@
+# encoding: utf-8
+require "fcid/engine"
+require "fcid/config"
+require "fcid/controller"
+require "fcid/helpers"
+
+ActionController::Base.send(:include,Fcid::Controller)
+
+ActionView::Base.send(:include,Fcid::Helpers)
+
+require "fcid/user"
+require "fcid/session"

data/lib/fcid_client.rb

@@ -0,0 +1,14 @@
+# encoding: utf-8
+require "oauth_active_resource"
+module FcidClient
+
+  def self.register(options = {})
+    OAuthActiveResource.register(self.ancestors.first,self.ancestors.first.const_get('Models'),options)
+  end
+
+  module Models
+    class User < OAuthActiveResource::Resource
+    end
+  end
+
+end

data/lib/tasks/fcid_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :fcid do
+#   # Task goes here
+# end

data/lib/vendor/authenticated_system.rb

@@ -0,0 +1,153 @@
+# encoding: utf-8
+module AuthenticatedSystem
+  protected
+    # Returns true or false if the user is logged in.
+    # Preloads @current_user with the user model if they're logged in.
+    def logged_in?
+      !!current_user 
+    end
+
+
+    
+    # Accesses the current user from the session.  Set it to :false if login fails
+    # so that future calls do not hit the database.
+    def current_user
+      #@current_user ||= (login_from_session || login_from_basic_auth || login_from_cookie || login_from_url )
+      @current_user ||= (login_from_session || login_from_basic_auth || login_from_url )
+    end
+    
+    # Store the given user in the session.
+    def current_user=(new_user)
+      session[:user] = (new_user.nil? || new_user.is_a?(Symbol)) ? nil : new_user.id
+      @current_user = new_user
+    end
+    
+    # Check if the user is authorized
+    #
+    # Override this method in your controllers if you want to restrict access
+    # to only a few actions or if you want to check if the user
+    # has the correct rights.
+    #
+    # Example:
+    #
+    #  # only allow nonbobs
+    #  def authorized?
+    #    current_user.login != "bob"
+    #  end
+    def authorized?
+      logged_in?
+    end
+
+    # Filter method to enforce a login requirement.
+    #
+    # To require logins for all actions, use this in your controllers:
+    #
+    #   before_filter :login_required
+    #
+    # To require logins for specific actions, use this in your controllers:
+    #
+    #   before_filter :login_required, :only => [ :edit, :update ]
+    #
+    # To skip this in a subclassed controller:
+    #
+    #   skip_before_filter :login_required
+    #
+    def login_required
+      authorized? || access_denied
+    end
+
+    # Redirect as appropriate when an access request fails.
+    #
+    # The default action is to redirect to the login screen.
+    #
+    # Override this method in your controllers if you want to have special
+    # behavior in case the user is not authorized
+    # to access the requested action.  For example, a popup window might
+    # simply close itself.
+    def access_denied
+      respond_to do |accepts|
+        accepts.html do
+          store_location
+          redirect_to :controller => '/fcid/session', :action => 'new'
+        end
+        accepts.xml do
+          headers["Status"]           = "Unauthorized"
+          headers["WWW-Authenticate"] = %(Basic realm="Web Password")
+          render :text => "Could't authenticate you", :status => '401 Unauthorized'
+        end
+        
+        #added by aotianlong
+        accepts.js do 
+          render :update do |page|
+            page << "try{"
+            page.login_dialog.show
+            page << "} catch(e){}"
+          end
+        end
+      end
+      false
+    end  
+    
+    # Store the URI of the current request in the session.
+    #
+    # We can return to this location by calling #redirect_back_or_default.
+    def store_location
+      session[:return_to] = request.request_uri
+    end
+    
+    # Redirect to the URI stored by the most recent store_location call or
+    # to the passed default.
+    def redirect_back_or_default(default)
+      redirect_to(session[:return_to] || default)
+      session[:return_to] = nil
+    end
+    
+    # Inclusion hook to make #current_user and #logged_in?
+    # available as ActionView helper methods.
+    def self.included(base)
+      base.send :helper_method, :current_user, :logged_in?
+    end
+
+    # Called from #current_user.  First attempt to login by the user id stored in the session.
+    def login_from_session
+      self.current_user = User.find_by_id(session[:user]) if session[:user]
+    end
+
+    # Called from #current_user.  Now, attempt to login by basic authentication information.
+    def login_from_basic_auth
+      username, passwd = get_auth_data
+      self.current_user = User.authenticate(username, passwd) if username && passwd
+    end
+
+    # Called from #current_user.  Finaly, attempt to login by an expiring token in the cookie.
+    def login_from_cookie      
+      user = cookies[:auth_token] && User.find_by_remember_token(cookies[:auth_token])
+      if user && user.remember_token?
+        user.remember_me
+        cookies[:auth_token] = { :value => user.remember_token, :expires => user.remember_token_expires_at }
+        self.current_user = user
+      end
+    end
+
+    def login_from_url
+      fcid_auth_token = params[:fcid_auth_token]
+      if fcid_auth_token
+        user = Fcid::User.get(:authenticate,:fcid_auth_token=>fcid_auth_token)
+        if user
+          user_id = user["id"]
+          User.sync(user_id)
+          self.current_user = User.find(user_id)
+        end
+      end
+    end
+
+  private
+    @@http_auth_headers = %w(Authorization HTTP_AUTHORIZATION X-HTTP_AUTHORIZATION X_HTTP_AUTHORIZATION REDIRECT_X_HTTP_AUTHORIZATION)
+
+    # gets BASIC auth info
+    def get_auth_data
+      auth_key  = @@http_auth_headers.detect { |h| request.env.has_key?(h) }
+      auth_data = request.env[auth_key].to_s.split unless auth_key.blank?
+      return auth_data && auth_data[0] == 'Basic' ? Base64.decode64(auth_data[1]).split(':')[0..1] : [nil, nil] 
+    end
+end

data/lib/vendor/authenticated_test_helper.rb

@@ -0,0 +1,11 @@
+# encoding: utf-8
+module AuthenticatedTestHelper
+  # Sets the current user in the session from the user fixtures.
+  def login_as(user)
+    @request.session[:user] = user ? users(user).id : nil
+  end
+
+  def authorize_as(user)
+    @request.env["HTTP_AUTHORIZATION"] = user ? "Basic #{Base64.encode64("#{users(user).login}:test")}" : nil
+  end
+end