raffle_v1 0.0.4 → 0.0.5

data/app/controllers/raffle_v1/versions_controller.rb

@@ -0,0 +1,15 @@
+require_dependency "raffle_v1/application_controller"
+
+module RaffleV1
+  class VersionsController < ApplicationController
+    skip_authorization_check
+
+    def changeset
+      version = Version.find(params[:id])
+
+      if can? :manage, version.item.class
+        render :partial => 'helpers/version_history_changeset', :locals => { :version => version}
+      end
+    end
+  end
+end

data/app/models/raffle_v1/ability.rb

@@ -0,0 +1,30 @@
+module RaffleV1
+  class Ability
+    include CanCan::Ability
+
+    def initialize(user)
+      # Define abilities for the passed in user here. For example:
+      #
+      #   user ||= User.new # guest user (not logged in)
+      #   if user.admin?
+      #     can :manage, :all
+      #   else
+      #     can :read, :all
+      #   end
+      #
+      # The first argument to `can` is the action you are giving the user permission to do.
+      # If you pass :manage it will apply to every action. Other common actions here are
+      # :read, :create, :update and :destroy.
+      #
+      # The second argument is the resource the user can perform the action on. If you pass
+      # :all it will apply to every resource. Otherwise pass a Ruby class of the resource.
+      #
+      # The third argument is an optional hash of conditions to further filter the objects.
+      # For example, here the user can only update published articles.
+      #
+      #   can :update, Article, :published => true
+      #
+      # See the wiki for details: https://github.com/ryanb/cancan/wiki/Defining-Abilities
+    end
+  end
+end

data/app/models/raffle_v1/admin.rb

@@ -0,0 +1,35 @@
+module RaffleV1
+  class Admin < ActiveRecord::Base
+    # Include default devise modules. Others available are:
+    # :token_authenticatable, :encryptable, :confirmable, :lockable, :timeoutable and :omniauthable
+    devise :database_authenticatable, #:registerable,
+           :recoverable, :rememberable, :trackable, :validatable,
+           :token_authenticatable, :lockable
+
+    # Setup accessible (or protected) attributes for your model
+    attr_accessible :email, :password, :password_confirmation, :remember_me, :admin_types, :program_ids
+    default_scope where(:deleted_at => nil)
+
+    has_and_belongs_to_many :programs
+
+    def has_type admin_type
+      if self.admin_types.present?
+        self.admin_types.split(",").include?(admin_type)
+      else
+        false
+      end
+    end
+
+    def self.admin_types
+      [
+        ["Admin", "admin"],
+        ["Service", "service"]
+      ]
+    end
+
+      def password_required?
+        !persisted? || !password.nil? || !password_confirmation.nil?
+      end
+
+  end
+end

data/app/models/raffle_v1/admin_ability.rb

@@ -0,0 +1,28 @@
+module RaffleV1
+  class AdminAbility
+    include CanCan::Ability
+
+    def initialize(user, current_program)
+
+      case user.admin_types
+        when :service
+          can :manage, :all
+          #can :index, :home
+              #can :manage, :user
+              #can :manage, User
+                  #can :reset_password_for, :user
+              #can :can_return_items_for, :order_line_item
+        when :admin
+          can :manage, :all 
+        else
+          can :manage, :all
+      end
+
+      if current_program.present?
+        cannot :index, :program
+      else
+        # cannot :manage, [Permission]
+      end
+    end
+  end
+end

data/app/models/raffle_v1/locale.rb

@@ -0,0 +1,29 @@
+module RaffleV1
+  class Locale < ActiveRecord::Base
+    attr_accessible :description, :name, :short_name
+
+    default_scope where(:deleted_at => nil)
+    validates :short_name, :presence => true
+    has_and_belongs_to_many :programs, join_table: :program_locales
+
+    before_save :uniform_data
+
+    def uniform_data
+      self.short_name = self.short_name.downcase
+    end
+
+    def deleted
+      self.unscoped.where('deleted_at IS NOT NULL')
+    end
+
+    def self.name_for(short_name)
+      locale = Locale.find_by_short_name(short_name)
+      if locale.present?
+        locale.name
+      else
+        ""
+      end
+    end
+  end
+end
+

data/app/models/raffle_v1/page.rb

@@ -0,0 +1,26 @@
+module RaffleV1
+  class Page < ActiveRecord::Base
+    attr_accessible :archived, :body, :deleted_at, :expiration_date, :footer, :header, 
+      :method, :nav, :override_page, :page_status, :page_to_override, :page_type, :points,
+      :program_id, :publish_date, :status, :item_status, :title
+
+    belongs_to :program
+    belongs_to :page_layout
+
+    validates :expiration_date, :item_status, presence: true
+    validates :publish_date, date: { before: :expiration_date, message: "must be before expiration date" }
+
+    #validate :ensure_content, if: Proc.new{|x| x.deleted_at == nil }
+
+    scope :published, where('published_date IS NOT AND publish_date <= (?) AND expiration_date IS NOT NULL AND expiration_date >= (?)', Date.today, Date.today)
+    .order("publish_date DESC")
+
+    TYPES = ['Free Form', 'Pre-Defined', 'Snippet', 'Content Box']
+
+    #def ensure_content
+      #if translations.present?
+
+      #end
+    #end
+  end
+end

data/app/models/raffle_v1/page_layout.rb

@@ -0,0 +1,6 @@
+module RaffleV1
+  class PageLayout < ActiveRecord::Base
+    belongs_to :program
+    attr_accessible :description, :name
+  end
+end

data/app/models/raffle_v1/program.rb

@@ -0,0 +1,84 @@
+module RaffleV1
+  class Program < ActiveRecord::Base
+    #attr_accessible :name
+    default_scope where(:deleted_at => nil)
+
+    has_and_belongs_to_many :locales, join_table: :program_locales
+    has_and_belongs_to_many :admins
+
+    has_one :terms_and_conditions
+    has_one :program_stylesheet, class_name: "Stylesheet", conditions: ["program_default = ?", true]
+    has_one :program_stylesheet, class_name: "Stylesheet", conditions: ["program_default = ?", true]
+
+    has_many :users
+    has_many :stylesheets
+    has_many :pages
+    has_many :page_layouts, dependent: :destroy
+
+    before_save :set_program_locale
+
+    after_create :create_program_setting
+
+    after_initialize :init
+
+    validate  :validate
+    validates :name, :presence => true
+    validates :sub_domain, uniqueness: {allow_blank: true},
+              format: {with: /^[a-z0-9\-]*?$/, message: 'only include lowercase letters, numbers and hyphens'}
+    validates :vanity_domain, uniqueness: {allow_blank: true},
+              format: {with: /^[a-z0-9]+([\-\.]{1}[a-z0-9]+)*\.[a-z]{2,6}(:[0-9]{1,5})?(\/.*)?$/ix, message: 'must be a vaild domain', if: Proc.new { |p| p.vanity_domain.present? } }
+    validates_inclusion_of :locale, if: Proc.new {|p| bb = []; p.locale_ids.each{ |l| bb << l.present?}; bb.include?(true) }, in: Proc.new {|p| Locale.find(p.locale_ids).collect { |l| l.short_name } }, message: "must be included in available locales"
+    validates_presence_of :locale
+    validates_numericality_of :user_timeout, :only_integer => true
+    validates_numericality_of :maximum_failed_login_attempts, :only_integer => true,
+      :greater_than_or_equal_to => 1, :less_than_or_equal_to => 100, if:  Proc.new {|program| program.use_failed_login_attempts }
+
+    def available_locales_exist?
+      errors.add(:base, "Existing Locale should contain program default") unless self.locales.map{|x| x.short_name}.included?(self.locale)
+    end
+
+    def self.deleted
+      self.unscoped.where('deleted_at IS NOT NULL')
+    end
+
+    def locale_for locale
+      localeShortName = if locale.respond_to?(:short_name)
+        locale.short_name
+      else
+        locale
+      end
+      "#{self.locale_name.gsub(" ", "").underscore}"
+    end
+
+    def set_program_locale
+      self.locale_name =  "#{self.name.gsub(" ", "").underscore}"
+    end
+
+    def program_portal_path
+      if !self.subdomain.blank?
+        "http://#{self.subdomain}.#{Phoenixv2::Application.config.full_domain}"
+      elsif !self.vanity_domain.nil?
+        "http://#{self.vanity_domain}"
+      end
+    end
+
+    def init
+      self.user_timeout ||= 20
+      self.maximum_failed_login_attempts ||= 20
+      self.password_notifier ||= 1
+    end
+
+    def validate
+      is_valid = true
+      if self.user_timeout < 0
+        errors.add(:user_timeout, "should be a positive numeric number")
+        is_valid = false
+      end
+    end
+
+    def create_program_setting
+      ProgramSetting.create(program_id: self.id)
+    end
+
+  end
+end

data/app/models/raffle_v1/program_locale.rb

@@ -0,0 +1,11 @@
+module RaffleV1
+  class ProgramLocale < ActiveRecord::Base
+    #attr_accessible :locale_id, :program_id
+
+    default_scope where(:deleted_at => nil)
+
+    def self.deleted
+      self.unscoped.where('deleted_at IS NOT NULL')
+    end
+  end
+end

data/app/models/raffle_v1/program_setting.rb

@@ -0,0 +1,5 @@
+module RaffleV1
+  class ProgramSetting < ActiveRecord::Base
+    attr_accessible :program_id
+  end
+end

data/app/models/raffle_v1/role.rb

@@ -0,0 +1,5 @@
+module RaffleV1
+  class Role < ActiveRecord::Base
+    attr_accessible :name
+  end
+end

data/app/models/raffle_v1/roles_users.rb

@@ -0,0 +1,5 @@
+module RaffleV1
+  class RolesUsers < ActiveRecord::Base
+    # attr_accessible :title, :body
+  end
+end

data/app/models/raffle_v1/stylesheet.rb

@@ -0,0 +1,9 @@
+module RaffleV1
+  class Stylesheet < ActiveRecord::Base
+    #attr_accessible :contents, :deleted_at, :program_default, :program_id, :theme_settings_id, :user_id
+    
+    belongs_to :program
+    belongs_to :theme_setting
+    has_many :users
+  end
+end

data/app/models/raffle_v1/terms_and_condition.rb

@@ -0,0 +1,17 @@
+module RaffleV1
+  class TermsAndCondition < ActiveRecord::Base
+    #include Commonscope
+    #include CheckBannedWords
+    #include ReachRoleExtensions
+
+    belongs_to :program
+    #has_reach
+    #has_paper_trail  
+    #is_hierarchable
+
+    #is_dynamically_translatable title: { required: true },  content: { required: true }, akm_content: { required: false },  accept_text: { required: true },  decline_text: { required: true },  decline_message: { required: true }
+
+    attr_accessible :accept, :program_id, :accept_text, :active, :akm_content, :content, :decline, 
+                    :decline_message, :decline_text, :force_accept, :required_renewed, :title
+  end
+end

data/app/models/raffle_v1/translation.rb

@@ -0,0 +1,29 @@
+module RaffleV1
+  class Translation < ActiveRecord::Base
+    #attr_accessible :interpolations, :key, :locale, :value
+    #include CommonScopes
+    
+    belongs_to :translation_key
+    belongs_to :program
+
+    validates_presence_of :language
+
+    before_save :set_key
+    before_create :set_locale
+
+    def set_key
+      translation_key = TranslationKey.find(self.translation_key_id)
+      self.key = translation_key.key
+    end
+
+    def set_locale
+      program_prefix = ""
+      unless self.program_id.nil?
+        program = Program.find(self.program.id)
+        program_prefix = "#{program.name.underscore}_"
+      end
+      self.locale = "#{program_prefix}#{self.language}"
+    end
+
+  end
+end

data/app/models/raffle_v1/translation_key.rb

@@ -0,0 +1,35 @@
+module RaffleV1
+  class TranslationKey < ActiveRecord::Base
+    attr_accessible :key, :name
+    #include CommonScopes
+    
+    belongs_to :translation_object
+    has_many :translations, :dependent => :destroy
+    has_one :primary_translation, :class_name => "Translation", :condition => ['locale = ?', 'en']
+
+    before_save :set_key
+    
+     def set_key
+      key_prefix = ""
+      translation_object = TranslationObject.find(self.translation_object_id)
+      key_override = nil
+
+      if translation_object.object_type == "Model"
+        if self.name == "model_name"
+          key_override = "#{translation_object.name.underscore.downcase}.one"
+          key_prefix = "activerecord.models."
+        elsif self.name == "model_name_plural"
+          key_override = "#{translation_object.name.underscore.downcase}.other"
+          key_prefix = "activerecord.models."
+        else
+          key_prefix = "activerecord.attributes.#{translation_object.name.underscore.downcase}."
+        end
+      else
+        key_prefix = "#{translation_object.object_type.underscore.downcase}.#{translation_object.name.underscore.downcase}."
+      end
+
+      self.key = "#{key_prefix}#{key_override || self.name.gsub(/\s+/, "").underscore.downcase}"
+    end
+
+  end
+end

data/app/models/raffle_v1/translation_object.rb

@@ -0,0 +1,11 @@
+module RaffleV1
+  class TranslationObject < ActiveRecord::Base
+    attr_accessible :name, :object_type
+
+    has_many :translation_keys, dependent: :destroy
+
+    TYPES = ["Message", "Model", "Page"]
+    OBJECTS = ["User"]
+    
+  end
+end

data/app/models/raffle_v1/user.rb

@@ -0,0 +1,108 @@
+module RaffleV1
+  class User < ActiveRecord::Base
+
+    STATUSES = ["active", "terminated"]
+    # Include default devise modules. Others available are:
+    devise :database_authenticatable,
+      :recoverable, :rememberable, :trackable, 
+      :token_authenticatable, :lockable, :authentication_keys => [:username, :program_id],
+      :lock_strategy => :failed_attempts, :unlock_strategy => :time, 
+      :maximum_attempts => 1000, :unlock_in => 1000 # These are ignored and overridden by the attempts_exceeded? and lock_expired?
+
+    # Setup accessible (or protected) attributes for the user model
+    attr_accessible :email, :password, :password_confirmation, :remember_me, :first_name, :last_name, :middle_initial, :suffix, 
+                    :work_email, :employee_number, :employee_id, :work_address, :work_city, :work_state, :work_postal, :work_county, :home_address, :home_city,:home_state,
+                    :home_postal,:home_county, :work_phone,:home_phone, :department_code, :department_name, :cost_center_cost, :user_name, 
+                    :job_title, :date_of_hire, :date_of_rehire, :date_of_birth, :preferred_language, :user_type, :employment_type, :vip_flag, :time_offset, :date_of_terminate, :manager_id, 
+                    :hierarchy_node, :hierarchy_node_id
+
+    default_scope where(:deleted_at => nil)
+
+    belongs_to :program
+
+    has_many :belongs_to_user_relationships, class_name: "UserRelationship", foreign_key: "user_id"
+    has_many :has_many_user_relationships, class_name: "UserRelationship", foreign_key: "related_user_id"
+
+    before_validation :generate_password_for_new_user
+
+    validates :username, :employee_id,  :presence => true
+    validates_confirmation_of :password, unless: Proc.new{|u| u.is_temporary_password == true or u.deleted_at != nil}
+    validates :date_of_birth, date: { before: Date.today, message: "must be before #{Date.today}"}, if: Proc.new { self.date_of_birth.present? }
+    validates_presence_of :password, :if => :password_required?
+    validates_confirmation_of :password, :if => :password_required?
+    validates_length_of :password, :within => Devise.password_length, :allow_blank => true
+
+    validate :password, presence: true, unless: Proc.new {|u| u.is_temporary_password == true or u.deleted_at != nil}
+    validate :custom_password_strength, unless: Proc.new { |u| u.deleted_at != nil}
+    validate :unique_usernames, on: :create
+
+    def generate_password_for_new_user
+      if password.nil? and self.new_record?
+        self.password = SecureRadom.hex(8) + "!&4$"
+        self.password_created_at = Time.now
+        self.is_temporary_password = true
+      end
+    end
+
+    def reset_password_token_and_notify host = nil
+      self.password = User.reset_password_token
+      self.reset_password_sent_at = User.reset_password_token
+      self.reset_password_sent_at = Time.now
+      self.save
+      puts UserMailer.reset_password(self, host).deliver
+    end
+
+    def custom_password_strength
+      if self.password.present? && self.encrypted_password_changed?
+        program = Program.find(self.program.id)
+        strength = PasswordStrength.test(self.username, self.password)
+        unless strength.valid?(program.password_strength.to_sym)
+          is_valid = false
+          self.errors.add(:password, "is not secure. Password must be #{program.password_strength.to_sym}")
+        end
+      end
+
+      is_valid
+    end
+
+    def self.generate_random_password
+      start_length = 10
+      token = ""
+
+      #loop over token generation untill we get something matching our desired length
+      #the reason we loop is so that we can confidently filter our barred characters
+      #while resorting the gaps with the new random characters
+      while token.length < start_length
+        token << Devise.friendly_token.first(start_length)
+        token.gsub!(/[iIlLoO10]/, "")
+      end
+      #slice incase the string became too long
+      token = token[0, start_length]
+
+      #need to add special chars into the string
+      random = Random.new
+
+      token.insert(random.rand(0..token.length), "@")
+      token.insert(random.rand(0..token.length), "!")
+
+      token
+    end
+
+    def fullname
+      "#{self.first_name} #{self.last_name}"
+    end
+
+    def full_home_phone_number
+      "(#{home_telephone_country_code}) #{home_telephone_area_code}-#{home_telephone_number}"
+    end
+
+    def full_home_address
+      "#{home_address}\n #{home_city}, #{home_state}"
+    end
+
+    def active?
+      self.date_of_termination.blank? || self.date_of_termination < Date.new
+    end
+
+  end
+end