benmanns-atreides 2.0.4

data/app/models/atreides/facebook_user.rb

@@ -0,0 +1,103 @@
+class Atreides::FacebookUser
+
+  class << self
+
+    def clear
+      ["user_id", "access_token", "expiration", "page_token"].each do |key|
+        Atreides::Preference.set("facebook.#{key}",nil)
+      end
+    end
+
+    def find_or_create(params)
+      Rails.logger.debug("[FacebookUser] find_or_create")
+      access_token = params[:access_token]
+      user_id = params[:user_id]
+      expiration = params[:expiry]
+
+      # if !has_valid_token?
+        # Current user is invalid or does not exist
+        Rails.logger.debug("[FacebookUser] determined invalid token")
+        # See if we can get an extended token
+        token_hash = extend_token(access_token)
+        if token_hash["status"] == "ok"
+          Rails.logger.debug("[FacebookUser] got extended token")
+          access_token = token_hash["access_token"]
+          expiration = token_hash["expires"]
+        else
+          Rails.logger.debug("[FacebookUser] did not get extended token")
+        end
+
+        expiration_date = Time.now + expiration.to_i
+        expiration_string = expiration_date.to_s(:db)
+
+        fb_pref("user_id", user_id)
+        fb_pref("access_token", access_token)
+        fb_pref("expiration", expiration_string)
+        Rails.logger.debug("[FacebookUser] set all vars")
+      # else
+      #   Rails.logger.debug("[FacebookUser] token is valid")
+      # end
+
+      Rails.logger.debug("[FacebookUser] leaving")
+      true
+    end
+
+    # def has_valid_token?
+    #   !(fb_pref("access_token").blank? || current_token_expired?)
+    # end
+
+    def current_token_expired?
+      return true if fb_pref("expiration").blank?
+      Time.parse(fb_pref("expiration")) < Time.now
+    end
+
+    # Returns @response
+    # @response is a hash with either keys => ["access_token", "expires", "status"] or keys => ["status"]
+    # You may check for errors with ["status"] == "error"
+    def extend_token(token)
+      begin
+        response = MiniFB.fb_exchange_token(Settings.facebook.app_id, Settings.facebook.app_secret, token)
+        response["status"] = "ok"
+        response
+      rescue => e
+        {"status" => "error"}
+      end
+    end
+
+    def authorize_page(page_id)
+      Rails.logger.debug("[FacebookUser] authorize_page")
+      response = fb.get(fb_pref("user_id"), :type => "accounts/#{page_id}")
+      found = false
+      response.data.each do |account|
+        Rails.logger.debug("[FacebookUser] checking account #{account.id}")
+        if account.id.to_s == page_id.to_s
+          Rails.logger.debug("[FacebookUser] found account #{account.id}")
+          fb_pref("page_token", account.access_token)
+          found = true
+          break
+        end
+      end
+
+      found
+    end
+
+    private
+
+    def fb
+      MiniFB.disable_logging
+      MiniFB::OAuthSession.new(fb_pref("access_token"))
+    end
+
+    def fb_pref(key,value = nil)
+      if value.nil?
+        Atreides::Preference.get("facebook.#{key}")
+      else
+        Atreides::Preference.set("facebook.#{key}",value)
+      end
+    end
+
+  end
+
+
+
+end

data/app/models/atreides/feature.rb

@@ -0,0 +1,90 @@
+class Atreides::Feature < Atreides::Base
+
+  #
+  # Behaviours
+  #
+  include Atreides::Base::Taggable
+  include Atreides::Base::AasmStates
+  include Atreides::Base::Validation
+
+  #
+  # Associatons
+  #
+  belongs_to :photo
+  belongs_to :post, :class_name => "Atreides::Post"
+  belongs_to :site, :class_name => "Atreides::Site"
+
+  #
+  # Constants
+  #
+  attr_accessor :photo_url
+  accepts_nested_attributes_for :photo, :allow_destroy => true
+
+  #
+  # Validations
+  #
+  include ActiveRecord::Validations
+  validates_presence_of :photo, :display_order, :if => Proc.new{|f| !f.pending? && !f.post_id? }
+  validates_numericality_of :display_order
+  validates :url, :presence => true, :url => true, :if => :url?
+  validates :tag_list, :presence => true, :allow_blank => false
+
+
+  #
+  # Scopes
+  #
+  default_scope order("features.display_order asc, features.id desc")
+
+  #
+  # Callbacks
+  #
+  after_initialize :set_tag_list
+
+  def set_tag_list
+    self.tag_list = [Settings.tags.posts.features.first] if self.tag_list.empty? rescue []
+  end
+
+  #
+  # Class Methods
+  #
+  class << self
+  end
+
+  #
+  # Instance Methods
+  #
+
+  def thumbnail(size = :thumb)
+    # Find the first thumbnail image
+    if post_id?
+      post.thumbnail
+    elsif photo_id?
+      photo.image(size)
+    else
+      # FIXME: THIS NEEDS TO BE MOVED TO A VIEW/PRESENTER/DECORATOR
+      # asset_path('atreides/missing_thumb.png')
+
+      "/images/missing_thumb.png"
+    end
+  end
+
+  def photo
+    if post_id?
+      part = post.parts.detect{|p|p.content_type && p.content_type.photos?}
+      part ? part.photos.first : nil
+    elsif photo_id?
+      @photo ||= Atreides::Photo.find(photo_id)
+    end
+  end
+
+  def video
+    if post_id?
+      part = post.parts.detect{|p|p.content_type && p.content_type.videos?}
+      part ? part.videos.first : nil
+    end
+  end
+
+  private
+
+  include Atreides::Extendable
+end

data/app/models/atreides/github.rb

@@ -0,0 +1,74 @@
+class Atreides::Github
+  attr_reader :data
+
+  def initialize(json_data)
+    @data = Hashie::Mash.new(json_data)
+  end
+
+  def method_missing(method)
+    @data.send(method)
+  end
+
+  def comments
+    id = @data.number
+    @comments ||= get_comments(id)
+  end
+
+
+  class << self
+    def all(options={})
+      issues(options)
+    end
+
+    def find(id)
+      Atreides::Github.new(issue(id))
+    end
+
+    def issue(id)
+      JSON.parse( get("repos/#{Settings.github.user}/#{Settings.github.repo}/issues/#{id}").body )
+    end
+
+    def issues(options)
+      options.reverse_merge!({:labels => "site,review me"})
+      JSON.parse( get("repos/#{Settings.github.user}/#{Settings.github.repo}/issues", {:params => options}).body )
+    end
+
+    def get(method, params={})
+      access_token.get("https://api.github.com/#{method}", params)
+    end
+
+    def authorize_url
+      client.auth_code.authorize_url(:redirect_uri => Settings.github.callback, :scope => Settings.github.scope)
+    end
+
+    def get_token(code)
+      client.auth_code.get_token(code, :redirect_uri => Settings.github.callback)
+    end
+
+  private
+
+    def client
+      OAuth2::Client.new( Settings.github.id,
+                          Settings.github.secret,
+                            :site => "https://github.com/",
+                            :authorize_url => Settings.github.auth_url,
+                            :token_url => Settings.github.access_token_url,
+                            :http_method => :get
+                          )
+    end
+
+    def access_token
+     OAuth2::AccessToken.new( client, Settings.github.token )
+    end
+
+
+
+  end
+
+  private
+
+  def get_comments(id)
+    JSON.parse( Atreides::Github.get("repos/#{Settings.github.user}/#{Settings.github.repo}/issues/#{id}/comments").body )
+  end
+
+end

data/app/models/atreides/like.rb

@@ -0,0 +1,35 @@
+class Atreides::Like < Atreides::Base
+
+  #
+  # Constants
+  #
+
+  #
+  # Associations
+  #
+  belongs_to :likeable, :polymorphic => true, :counter_cache => true
+  belongs_to :user
+
+  #
+  # Validations
+  #
+  validates_presence_of :user
+  validates_uniqueness_of :user_id, :scope => [:likeable_type, :likeable_id]
+
+  #
+  # Scopes
+  #
+  default_scope order('created_at ASC')
+
+  #
+  # Class Methods
+  #
+  class << self
+  end
+
+  #
+  # Instance Methods
+  #
+
+  include Atreides::Extendable
+end

data/app/models/atreides/line_item.rb

@@ -0,0 +1,4 @@
+class Atreides::LineItem < Atreides::Base
+
+  include Atreides::Extendable
+end

data/app/models/atreides/link.rb

@@ -0,0 +1,32 @@
+class Atreides::Link < Atreides::Base
+
+  #
+  # Constants
+  #
+
+  #
+  # Associatons
+  #
+  belongs_to :post
+
+  #
+  # Validations
+  #
+  validates :url, :presence => true, :url => true, :if => :url?
+
+  #
+  # Scopes
+  #
+
+  #
+  # Class Methods
+  #
+  class << self
+  end
+
+  #
+  # Instance Methods
+  #
+
+  include Atreides::Extendable
+end

data/app/models/atreides/message.rb

@@ -0,0 +1,34 @@
+class Atreides::Message < Atreides::Base
+
+  #
+  # Constants
+  #
+
+  #
+  # Associatons
+  #
+  belongs_to :messagable, :polymorphic => true
+  belongs_to :user
+
+  #
+  # Validations
+  #
+  validates_presence_of :name, :email, :body, :messagable_type, :messagable_id
+  validates_email_format_of :email
+
+  #
+  # Scopes
+  #
+
+  #
+  # Class Methods
+  #
+  class << self
+  end
+
+  #
+  # Instance Methods
+  #
+
+  include Atreides::Extendable
+end

data/app/models/atreides/order.rb

@@ -0,0 +1,209 @@
+class Atreides::Order < Atreides::Base
+
+  #
+  # Constants
+  #
+  BILLING_COLS = %w(zip country street city province).freeze
+
+  #
+  # Behaviours
+  #
+  composed_of :amount, :class_name => "Money", :mapping => [%w(amount_cents cents), %w(currency currency)]
+  composed_of :discount, :class_name => "Money", :mapping => [%w(discount_cents cents), %w(currency currency)]
+  composed_of :final_amount, :class_name => "Money", :mapping => [%w(final_amount_cents cents), %w(currency currency)]
+
+  serialize :gateway_data
+
+  attr_accessor :card_type, :card_number, :card_verification, :card_expires_on
+
+  #
+  # States
+  #
+  require 'aasm'
+  include ::AASM
+  aasm_column :state
+  aasm_initial_state :pending
+  aasm_state :pending
+  aasm_state :completed
+  aasm_state :failed
+
+  aasm_event :complete do
+    transitions :from => [:pending], :to => :completed
+  end
+
+  aasm_event :fail do
+    transitions :from => [:pending, :failed], :to => :failed
+  end
+
+  #
+  # Associatons
+  #
+  belongs_to :user
+  has_many :line_items
+  has_many :products, :through => :line_items
+
+  #
+  # Validations
+  #
+  validates_numericality_of :amount_cents, :greater_than => 0
+  validates_numericality_of :discount_cents, :greater_than_or_equal_to => 0
+  validates_numericality_of :final_amount_cents, :greater_than_or_equal_to => 0
+  validates_presence_of :user, :email, :first_name, :last_name, :zip, :currency, :country, :street, :city, :province, :ip_address, :products
+
+  #
+  # Scopes
+  #
+  default_scope order('created_at DESC')
+
+  scope :by_month, lambda { |month|
+    where("MONTH(created_at) = ?", month.to_i)
+  }
+
+  scope :by_year, lambda { |year|
+    where("YEAR(created_at) = ?", year.to_i)
+  }
+
+  #
+  # Callbacks
+  #
+  after_create :do_gateway_payment
+  after_create :reduce_qty
+  before_validation :total_amounts, :on => :create
+
+  #
+  # Class Methods
+  #
+  class << self
+    def build_order_for_user(user)
+      # Get address info if user has previous orders
+      attrs = {}
+      if old_order = user.orders.first
+        old_order.attributes.each{|k,v| attrs[k] = v if BILLING_COLS.include?(k) }
+      end
+
+      # Build new object
+      new(attrs.update({
+        :user       => user,
+        :first_name => user.first_name,
+        :last_name  => user.last_name,
+        :line_items => user.cart_items,
+        :amount     => Money.new(user.cart_items.sum(:price_cents)),
+        :ip_address => user.current_login_ip
+      }))
+    end
+  end
+
+  #
+  # Instance Methods
+  #
+  def full_name
+    [first_name, last_name].join(' ')
+  end
+
+  def number
+    # TODO: Format this as something more user friendly
+    [id, created_at].map(&:to_i).join('-')
+  end
+
+  def address
+    %w(street city province zip country).map{|f| self.send(f) }.compact.join("\n")
+  end
+
+  def total_amounts
+    # Set price
+    self.amount = line_items.to_a.sum{ |i| i.total_price }
+
+    # Set final amount to be paid
+    self.final_amount = amount - discount
+  end
+
+  private
+
+  def reduce_qty
+    sold_outs = []
+    line_items.each do |l|
+      if product_size = l.product.sizes.detect{|s| s.name == l.size }
+        product_size.increment!(:qty, -1)
+        if product_size.qty.zero?
+          sold_outs << product_size.product
+        end
+      end
+    end
+
+    # Mail admin if sold out
+    Notifier.deliver_sold_out_warning(sold_outs) if !sold_outs.empty?
+  end
+
+  def do_gateway_payment
+    # we set the serials first to raise error before payment
+    auth = gateway.authorize(final_amount, credit_card, purchase_options)
+
+    raise auth.message unless auth.success?
+
+    # Authorization is zero if account is globally in test mode, you cannot capture:
+    unless auth.authorization == "0"
+      capture = gateway.capture(price, capture.authorization) #, purchase_options)
+    end
+
+    update_attribute(:gateway_data, capture)
+
+    capture.success? ? complete! : fail!
+    capture.success?
+  end
+
+  def purchase_options
+    options = {
+      :order_id => id,
+      :ip => ip_address,
+      :customer => full_name,
+      :invoice => number,
+      :merchant => Settings.app_name,
+      :description => "#{Settings.domain}: Purchase of #{products.map(&:title).join(', ')}",
+      :email => email,
+      :currency => currency,
+      :billing_address => {
+        :name     => full_name,
+        :city     => city,
+        :state    => province,
+        :country  => country,
+        :zip      => zip,
+        :address1 => street
+      }
+    }
+    options[:test] = true if Rails.env.development?
+    options
+  end
+
+  def credit_card
+    @credit_card ||= ActiveMerchant::Billing::CreditCard.new(
+      :type               => card_type,
+      :number             => card_number,
+      :verification_value => card_verification,
+      :month              => card_expires_on.month,
+      :year               => card_expires_on.year,
+      :first_name         => first_name,
+      :last_name          => last_name
+    )
+  end
+
+  def validate_card
+    unless credit_card.valid?
+      credit_card.errors.full_messages.each do |message|
+        errors.add(:base, message)
+      end
+    end
+  end
+
+  def gateway
+    ActiveMerchant::Billing::Base.mode = Rails.env.production? ? :production : :test
+    if Rails.env.test? || Rails.env.development?
+      ActiveMerchant::Billing::BogusGateway.new
+    else
+      ActiveMerchant::Billing::AuthorizeNetGateway.new({
+        :login => Settings.paypal.login,
+        :password => Settings.paypal.password})
+    end
+  end
+
+  include Atreides::Extendable
+end