atreides 2.0.0

data/app/models/atreides/product.rb

@@ -0,0 +1,75 @@
+class Atreides::Product < Atreides::Base
+
+  #
+  # Constants
+  #
+
+  #
+  # Associatons
+  #
+  has_many :photos, :as => :photoable, :order => "display_order"
+  has_many :line_items
+  has_many :orders, :through => :line_items
+  has_many :sizes, :order => "display_order"
+
+  #
+  # Behaviours
+  #
+  include Atreides::Base::Taggable
+  include Atreides::Base::AasmStates
+  composed_of :price, :class_name => "Money", :mapping => [%w(price_cents cents), %w(price_currency currency)]
+  accepts_nested_attributes_for :photos, :allow_destroy => true
+  accepts_nested_attributes_for :sizes, :allow_destroy => true, :reject_if => Proc.new {|s| s['name'].blank? }
+
+  #
+  # Validations
+  #
+  validates_presence_of :title, :body, :slug, :unless => :pending?
+  validates_uniqueness_of :slug, :unless => :pending?
+  validates_associated :sizes
+  validates_numericality_of :price_cents
+
+  validate :check_price, :on => :update
+
+  def check_price
+    errors.add(:price, "must be greater than zero") if price.zero? and !pending?
+  end
+
+  #
+  # Scopes
+  #
+
+  #
+  # Callbacks
+  #
+  before_validation :set_slug
+
+  def set_slug
+    # Set slug
+    self.slug = title.to_s.parameterize if !slug?
+  end
+
+  #
+  # Class Methods
+  #
+  class << self
+    def base_class
+      self
+    end
+  end
+
+  #
+  # Instance Methods
+  #
+  def size_for_name(name)
+    sizes.first(:conditions => {:name => name})
+  end
+
+  def sold_out?
+    self.sizes.sum(:qty).zero?
+  end
+
+  private
+
+  include Atreides::Extendable
+end

data/app/models/atreides/site.rb

@@ -0,0 +1,59 @@
+class Atreides::Site < Atreides::Base
+
+  #
+  # Constants
+  #
+
+  #
+  # Associatons
+  #
+  has_many :posts
+  has_many :pages
+  has_many :features
+
+  #
+  # Validations
+  #
+  validates :name, :presence => true, :uniqueness => true
+  validates :lang, :presence => true, :inclusion => { :in => I18n.available_locales }
+  before_validation :set_default_lang
+
+  #
+  # Scopes
+  #
+  default_scope :order => "id asc"
+
+  #
+  # Callbacks
+  #
+
+
+  #
+  # Class Methods
+  #
+  class << self
+
+    # Use www or go for the first one
+    def default
+      find_by_name('www') || first || create(:name => 'www', :lang => I18n.locale)
+    end
+
+  end
+
+  #
+  # Instance methods
+  #
+  def lang
+    # Symbolize to make easier to integrate w I18n
+    read_attribute(:lang) ? read_attribute(:lang).to_sym : nil
+  end
+
+  private
+
+  def set_default_lang
+    # Set the default value
+    self.lang ||= I18n.locale if new_record?
+  end
+
+  include Atreides::Extendable
+end

data/app/models/atreides/size.rb

@@ -0,0 +1,44 @@
+class Atreides::Size < Atreides::Base
+
+  #
+  # Constants
+  #
+
+  #
+  # Associatons
+  #
+  belongs_to :product
+
+  #
+  # Validations
+  #
+  validates_presence_of :name, :qty
+  validates_uniqueness_of :name, :scope => :product_id, :message => "can only be used once per product", :if => :product_id?
+  validates_numericality_of :qty, :greater_than_or_equal_to => 0
+  validates_numericality_of :display_order
+
+  #
+  # Scopes
+  #
+
+  #
+  # Callbacks
+  #
+
+  #
+  # Class Methods
+  #
+  class << self
+
+    def base_class
+      self
+    end
+
+  end
+
+  #
+  # Instance Methods
+  #
+
+  include Atreides::Extendable
+end

data/app/models/atreides/tag.rb

@@ -0,0 +1,31 @@
+class Atreides::Tag < ActsAsTaggableOn::Tag
+
+  #
+  # Constants
+  #
+
+  #
+  # Associatons
+  #
+
+  #
+  # Validations
+  #
+
+  #
+  # Callbacks
+  #
+
+
+  #
+  # Class Methods
+  #
+  class << self
+  end
+
+  #
+  # Instance Methods
+  #
+
+  include Atreides::Extendable
+end

data/app/models/atreides/tweet.rb

@@ -0,0 +1,123 @@
+class Atreides::Tweet < Atreides::Base
+
+  #
+  # Constants
+  #
+
+  #
+  # Associatons
+  #
+
+  #
+  # Validations
+  #
+  validates_presence_of :twitter_id, :text, :from_user, :tweeted_at
+  validates_uniqueness_of :twitter_id
+
+  class << self
+    def analytics(since = 1.month.ago)
+      days = select("count(id) as twitter_id, sum(reach) as reach, DATE(tweeted_at) as tweeted_at").
+        where("tweeted_at > ?", since).
+        group("DATE(tweeted_at)").order(:twitter_id).map { |t|
+          {
+            :tweets => t.twitter_id,
+            :reach => t.reach,
+            :date => t.tweeted_at.to_date
+          }
+        }
+    end
+
+    def exposure(since = 1.month.ago)
+      where("tweeted_at > ?", since).sum(:reach)
+    end
+
+    def reach(since = 1.month.ago)
+      select("distinct(from_user), reach").where("tweeted_at > ?", since).to_a.sum(&:reach)
+    end
+
+    # Get most recent
+    def fetch_recent(started_at = nil)
+      # Twitter mentions
+      started_at ||= Time.zone.now
+      continue = true
+      users = []
+      per_page = 100
+
+      while continue do
+        # Get most recent tweets
+        tweets = twitter[:search].search.json?(
+          :q => Settings.twitter.search_for,
+          :since_id => Atreides::Tweet.maximum(:twitter_id),
+          # :since => (Atreides::Tweet.maximum(:tweeted_at) || 1.month.ago).to_date.to_s,
+          # :max_id => self.minimum(:twitter_id, :conditions => ["created_at >= ?", started_at]),
+          :rpp => per_page,
+          :lang => "all"
+        ).results
+
+        if continue = !tweets.size.zero?
+          # Get user ids
+          user_ids = tweets.map(&:from_user).uniq
+          page = 0
+
+          # Don't double fetch user-ids
+          unless users.empty?
+            user_ids -= users.map(&:screen_name).map(&:downcase)
+          end
+
+          continue_u = true
+          while continue_u do
+            sub_users = user_ids[page*per_page .. (page+1)*per_page] || []
+            if continue_u = !sub_users.size.zero?
+              page +=1
+              results = twitter.users.lookup.json?(:screen_name => sub_users.join(','))
+              # Append to list
+              users += results
+            end
+          end
+
+          # Add to DB
+          tweets.each do |twt|
+            u = users.detect{|u|u.screen_name.downcase==twt.from_user}
+            self.create(
+              :twitter_id => twt.id,
+              :tweeted_at => Time.zone.parse(twt.created_at),
+              :text => twt.text,
+              :from_user => twt.from_user,
+              :to_user => twt.to_user,
+              :reach => (u ? u.followers_count : 0),
+              :profile_image_url => twt.profile_image_url
+            )
+          end
+        end
+
+        # Return new tweets created
+        where("created_at >= ?", started_at).count(:id)
+      end
+    end
+
+    private
+
+    def twitter
+      require 'grackle' unless defined?(Grackle)
+      @twitter ||= Grackle::Client.new(:auth => {
+        :type => :oauth,
+        :consumer_key => Settings.twitter.consumer_key,
+        :consumer_secret => Settings.twitter.consumer_secret,
+        :token => Settings.twitter.app_user_token,
+        :token_secret => Settings.twitter.app_user_secret
+      })
+      # Show debugging info
+      @twitter.transport.debug = true unless Rails.env.production?
+      @twitter
+    end
+
+  end
+
+  private
+
+  def twitter
+    self.class.twitter
+  end
+
+  include Atreides::Extendable
+end

data/app/models/atreides/user.rb

@@ -0,0 +1,129 @@
+class Atreides::User < Atreides::Base
+  # Include default devise modules. Others available are:
+  # :token_authenticatable, :confirmable, :lockable and :timeoutable
+  begin
+    devise :database_authenticatable, :registerable,
+           :recoverable, :rememberable, :trackable, :validatable
+  rescue NoMethodError
+    puts "[WARNING] The Devise initializer seems to be missing. If you are generators, this is normal."
+    def self.devise *args
+    end
+  end
+
+  # Setup accessible (or protected) attributes for your model
+  attr_accessible :email, :password, :password_confirmation, :remember_me, :role
+
+
+  #
+  # Constants
+  #
+
+  #
+  # Associatons
+  #
+  has_many :comments
+  has_many :line_items
+  has_many :cart_items, :class_name => "LineItem", :conditions => "order_id is null"
+  has_many :orders
+  has_many :likes
+  has_many :posts, :class_name => "Atreides::Post", :through => :author_id
+  has_many :pages, :class_name => "Atreides::Page", :through => :author_id
+
+  #
+  # Behvaiours
+  #
+  attr_accessible :first_name, :last_name
+  # attr_accessible :twitter_token, :twitter_secret, :profile_pic_url, :fb_session_key
+
+  #
+  # Validations
+  #
+  validates :email, :presence => true, :uniqueness => true
+  validates :first_name, :presence => true
+  validates :last_name, :presence => true
+
+
+  #
+  # Callbacks
+  #
+  before_destroy :prevent_destroying_last_admin
+
+  #
+  # Scopes
+  #
+  scope :admins, lambda { where(:role => :admin) }
+
+  #
+  # Class Methods
+  #
+  class << self
+    def build_admin props
+      self.new (props || {}).merge :role => :admin
+    end
+
+    def can_destroy_admin?
+      admins.count > 1
+    end
+
+    # Sort by descending order of ability
+    def roles
+      [:admin, :editor, :writer]
+    end
+
+    def available_roles(user)
+      idx = roles.find_index(user.role.to_sym)
+      idx == nil ? [] : roles[idx..-1]
+    end
+  end
+
+  def prevent_destroying_last_admin
+    errors.add(:base, "not allowed destroying the last administrator") unless destroyable?
+    destroyable?
+  end
+
+  def destroyable?
+    !admin? || self.class.admins.count > 1
+  end
+
+  def admin?
+    role && role.to_sym == :admin
+  end
+
+  def role
+    @role ||= (self.attributes['role'] && self.attributes['role'].to_sym)
+  end
+
+  #
+  # Instance Methods
+  #
+  def full_name
+    [first_name, last_name].join(' ')
+  end
+
+  def add_to_cart(opts = {})
+    product = opts[:product]
+    size = opts[:size].to_s
+    qty = opts[:qty].to_i
+    return if !product or !product.is_a?(Product)
+
+    # Look for exisiting item
+    item = cart_items.detect{|i|i.product==product and i.product.size_for_name(size) }
+
+    # Create if not found
+    item = cart_items.build(:product => product, :size => size) if item.nil?
+
+    # Update qty
+    item.qty += qty
+
+    item.save
+    item
+  end
+
+  protected
+
+  def password_required?
+    !persisted? || password.present? || password_confirmation.present?
+  end
+
+  include Atreides::Extendable
+end