subj_sub_models 0.0.0 → 0.0.1

data/lib/subj_models/content_block.rb

@@ -0,0 +1,28 @@
+require 'subj_models/concerns/comprising_external_id'
+
+module SubjModels
+
+  module ContentBlockModule
+
+    def self.included(including_class)
+
+      including_class.class_eval do
+
+        include SubjModels::ComprisingExternalId
+
+        belongs_to :document_file
+        has_one :brand
+
+      end
+
+    end
+
+    def to_s
+      brands = Brand.where('content_block1_id=? OR (content_block2_id=? OR content_block3_id=?)', id, id, id)
+      addition_text = brands.any? ? "#{brands.first.try(:name)}" : 'Без бренда'
+      "#{title} - " + addition_text
+    end
+
+  end
+
+end

data/lib/subj_models/document_file.rb

@@ -0,0 +1,38 @@
+require 'subj_models/concerns/comprising_external_id'
+
+module SubjModels
+
+  module DocumentFileModule
+
+    def self.included(including_class)
+
+      including_class.class_eval do
+
+        include SubjModels::ComprisingExternalId
+
+        has_one :nomenclature_photo
+        has_one :nomenclature_file
+        has_one :brand_line
+        has_one :user
+        has_one :manager
+        has_one :user_specialization_approval
+
+        has_many :videos
+        has_many :brands
+
+        mount_uploader :file_data, PhotoUploader
+        mount_uploader :alternative_file_data, PhotoUploader
+
+        validates :file_data, presence: true
+
+      end
+
+    end
+
+    def to_s
+      id.to_s
+    end
+
+  end
+
+end

data/lib/subj_models/event.rb

@@ -0,0 +1,79 @@
+require 'subj_models/concerns/comprising_external_id'
+
+module SubjModels
+
+  module EventModule
+
+    def self.included(including_class)
+
+      including_class.class_eval do
+
+        include SubjModels::ComprisingExternalId
+
+        belongs_to :manager
+        belongs_to :event_type
+        belongs_to :nomenclature
+        belongs_to :document_file
+        belongs_to :brand
+
+        has_one :event_schedule
+        has_one :nomenclature_price
+
+        has_many :order_items
+        has_many :event_bookings
+
+        has_and_belongs_to_many :user_specializations
+        has_and_belongs_to_many :nomenclatures
+
+        validates :document_file, :title, presence: true
+
+        scope :from_today, -> {
+          Event.joins(:event_schedule).where('event_schedules.event_date >= ?',  DateTime.now.beginning_of_day )
+          .includes(:event_schedule).order( 'event_schedules.event_date ASC' ).uniq
+        }
+
+        scope :where_nomenclature_ids, -> (ids) do
+          joins(:nomenclatures).where(nomenclatures: {id: ids})
+        end
+
+        scope :office_ids, -> (ids) do
+          joins(event_schedule: [:office]).where(event_schedule: { office: {id: ids}})
+        end
+
+        scope :type_ids, -> (ids) do
+          joins(:event_type).where(event_type: {id: ids})
+        end
+
+        scope :brand_ids, -> (ids) do
+          joins(:brand).where(brand: { id: ids})
+        end
+
+        scope :only_free, -> do
+          joins(:event_schedule).where(event_schedule: { is_free: true } )
+        end
+
+        scope :specialities_ids, -> (ids) do
+          joins(:user_specializations).where(user_specializations: { id: ids})
+        end
+
+        scope :date_range, -> (date) do
+          joins(:event_schedule)
+          .where(event_schedule: { event_date: DateTime.parse(date['from']).beginning_of_day..DateTime.parse(date['to']).end_of_day } )
+        end
+
+        scope :today_events, -> {
+          includes(:event_schedule).where(event_schedule: { event_date: DateTime.now.beginning_of_day..DateTime.now.end_of_day } )
+        }
+        scope :is_public, -> { where(is_public: true) }
+
+      end
+
+    end
+
+    def to_s
+      title.to_s
+    end
+
+  end
+
+end

data/lib/subj_models/event_booking.rb

@@ -0,0 +1,39 @@
+require 'subj_models/concerns/comprising_external_id'
+
+module SubjModels
+
+  module EventBookingModule
+
+    def self.included(including_class)
+
+      including_class.class_eval do
+
+        include SubjModels::ComprisingExternalId
+
+        belongs_to :order
+        belongs_to :user
+        belongs_to :event
+
+        validates :user, uniqueness: { scope: :event }
+
+        scope :user_id , -> (user_id) {where(user_id: user_id)}
+        scope :event_id , -> (event_id) {where(event_id: event_id)}
+        scope :only_new, -> (condition) do
+          if condition
+            where(external_id: nil)
+          else
+            all
+          end
+        end
+
+      end
+
+    end
+
+    def to_s
+      id.to_s
+    end
+
+  end
+
+end

data/lib/subj_models/event_schedule.rb

@@ -0,0 +1,37 @@
+require 'subj_models/services/values_checker'
+require 'subj_models/services/types_support'
+require 'subj_models/concerns/comprising_external_id'
+
+module SubjModels
+
+  module EventScheduleModule
+
+    include SubjModels::TypesSupport::EventTypes
+    include SubjModels::ValuesChecker
+
+    def self.included(including_class)
+
+      including_class.class_eval do
+
+        include SubjModels::ComprisingExternalId
+
+        enum event_type: EVENT_TYPES
+
+        belongs_to :event
+        belongs_to :office
+
+        validates :event_date, presence: true
+
+        scope :event_id, -> (event_id) { parent_id_scope(event_id: event_id) }
+
+      end
+
+    end
+
+    def to_s
+      id.to_s # TODO
+    end
+
+  end
+
+end

data/lib/subj_models/event_type.rb

@@ -0,0 +1,27 @@
+require 'subj_models/concerns/comprising_external_id'
+
+module SubjModels
+
+  module EventTypeModule
+
+    def self.included(including_class)
+
+      including_class.class_eval do
+
+        include SubjModels::ComprisingExternalId
+
+        has_many :events
+
+        validates :name, presence: true
+
+      end
+
+    end
+
+    def to_s
+      name
+    end
+
+  end
+
+end

data/lib/subj_models/faq.rb

@@ -0,0 +1,46 @@
+require 'subj_models/concerns/comprising_external_id'
+
+module SubjModels
+
+  module FaqModule
+
+    include SubjModels::TypesSupport::FaqTypes
+    include SubjModels::ValuesChecker
+
+    def self.included(including_class)
+
+      including_class.class_eval do
+
+        include SubjModels::ComprisingExternalId
+
+        enum faq_type: FAQ_TYPES
+
+        after_save :notify_user
+
+        validates :question, presence: true, allow_blank: false,
+          uniqueness: { message: 'Простите, такой вопрос уже был задан' }
+        validates :faq_type, inclusion: { in: faq_types.keys },
+              on: :update
+
+        scope :with_answer, -> { where.not(answer: nil) }
+        scope :without_answer, -> { where(answer: nil) }
+        scope :on_site, -> { where(show_on_site: true) }
+        scope :type_is, -> (condition) { where(faq_type: condition) }
+
+      end
+
+    end
+
+    def to_s
+      question
+    end
+
+    private
+
+    def notify_user
+      FaqMailer.notify_user(self).deliver if send_to_user
+    end
+
+  end
+
+end

data/lib/subj_models/global_notification.rb

@@ -0,0 +1,16 @@
+module SubjModels
+
+  module GlobalNotificationModule
+
+    def self.included(including_class)
+
+      including_class.class_eval do
+
+
+      end
+
+    end
+
+  end
+
+end

data/lib/subj_models/manager.rb

@@ -0,0 +1,31 @@
+require 'subj_models/concerns/comprising_external_id'
+require 'subj_models/concerns/shared_scopes'
+
+module SubjModels
+
+  module ManagerModule
+
+    def self.included(including_class)
+
+      including_class.class_eval do
+
+        include SubjModels::SharedScopes
+        include SubjModels::ComprisingExternalId
+
+        belongs_to :document_file
+        has_many :events
+
+        validates :email, uniqueness: { case_sensitive: false }
+        validates :first_name, :last_name, :email, :phone, :document_file, presence: true
+
+      end
+
+    end
+
+    def to_s
+      "#{first_name} #{last_name}"
+    end
+
+  end
+
+end

data/lib/subj_models/measure_unit.rb

@@ -0,0 +1,28 @@
+require 'subj_models/concerns/comprising_external_id'
+
+module SubjModels
+
+  module MeasureUnitModule
+
+    def self.included(including_class)
+
+      including_class.class_eval do
+
+        include SubjModels::ComprisingExternalId
+
+        belongs_to :attribute_value
+
+        has_many :nomenclature_prices
+
+        validates :name, presence: true
+
+      end
+
+    end
+
+    def to_s
+      name
+    end
+
+  end
+end

data/lib/subj_models/nomenclature.rb

@@ -0,0 +1,166 @@
+require 'json'
+require 'subj_models/concerns/comprising_external_id'
+
+module SubjModels
+
+  module NomenclatureModule
+
+    def self.included(including_class)
+
+      including_class.class_eval do
+
+        include SubjModels::ComprisingExternalId
+
+        belongs_to :brand_line
+        belongs_to :brand
+        belongs_to :user_specialization
+        belongs_to :category
+
+        has_many :nomenclature_varieties, dependent: :destroy
+        has_many :nomenclature_photos, dependent: :destroy
+        has_many :nomenclature_reviews, dependent: :destroy
+        has_many :nomenclature_files, dependent: :destroy
+        has_many :attribute_values, dependent: :destroy
+        has_many :nomenclature_prices, dependent: :destroy
+
+        belongs_to :analog_related_nomenclature, class_name: "Nomenclature"
+        has_many :analogs, foreign_key: "analog_related_nomenclature_id", class_name: "Nomenclature"
+        belongs_to :bought_together_related_nomenclature, class_name: "Nomenclature"
+        has_many :bought_together, foreign_key: "bought_together_related_nomenclature_id", class_name: "Nomenclature"
+
+        has_and_belongs_to_many :action_banners
+        has_and_belongs_to_many :access_groups, through: :nomenclature_access_groups
+        has_and_belongs_to_many :events
+
+        validates :name, presence: true
+
+        scope :with_category, -> { where.not(category_id: nil) }
+        scope :brand_line_ids, -> (brand_line_id) { where(brand_line_id: brand_line_id) }
+        scope :with_action, -> { joins(:action_banners).distinct }
+        scope :is_recommended, -> condition { where(is_recommended: condition) }
+        scope :in_index_list, -> condition { where(show_on_index: condition) }
+        scope :is_stock, -> (condition) do
+          nomenclature_prices_join.joins("LEFT OUTER JOIN qualities ON qualities.id = nomenclature_prices.quality_id").where("qualities.is_stock" => condition).uniq
+        end
+
+        scope :bought_together_external_id, -> (ids) do
+          joins(:bought_together_related_nomenclature).where(bought_together_related_nomenclature: {external_id: ids }).uniq
+        end
+
+        scope :is_available, -> (params) do
+          is_available = params.first
+          return all unless is_available == 'true'
+          user = User.find_by(id: params.second.to_i)
+          not_professional_ids = Nomenclature.is_professional(false).pluck(:id)
+          ids = user ? user.available_nomenclature_ids.concat(not_professional_ids) : []
+          where(id: ids)
+        end
+
+        scope :only_promotional, -> do
+          joins(:action_banners).uniq
+        end
+
+        scope :is_professional, -> (condition) {where(is_professional: condition) }
+
+        scope :price, -> (prices) do
+          prices = prices.map { |p| p.split(',') }
+          nomenclature_prices_join.
+          where(
+            prices.map do |range|
+              if range[0] && range[1]
+                '(nomenclature_prices.current_price >= ? AND nomenclature_prices.current_price < ?)'
+              elsif range[0]
+                '(nomenclature_prices.current_price >= ?)'
+              elsif range[1]
+                '(nomenclature_prices.current_price < ?)'
+              end
+            end.join(' OR '),
+            *prices.map(&:compact).flatten
+          )
+        end
+
+        scope :order_by_name, -> (ordering) do
+          ordering = ordering.second.try(:to_sym)
+          if [:asc, :desc].include? ordering
+            order(name: ordering)
+          end
+        end
+
+        scope :order_by_popularity, -> (ordering) do
+          ordering = ordering.second.try(:to_sym)
+          if [:asc, :desc].include? ordering
+            order(popularity: ordering)
+          end
+        end
+
+        scope :attribute_value_ids, -> (attribute_value_name_strings) do
+          query_result = nil
+          nomenclature_ids = ids
+          attribute_value_name_strings.each do |str|
+            attr_names = str.split('/')
+            query_result = Nomenclature.joins(:attribute_values).where("attribute_values.nomenclature_value" => attr_names).where(id: nomenclature_ids).uniq
+            nomenclature_ids = query_result.pluck(:id)
+          end
+
+          query_result
+        end
+
+        scope :nomenclature_prices_join, -> do
+          joins(:nomenclature_prices)
+          #joins('LEFT OUTER JOIN nomenclature_varieties ON nomenclature_varieties.id = (SELECT innerNomVar.id FROM nomenclature_varieties as innerNomVar WHERE innerNomVar.nomenclature_id = nomenclatures.id LIMIT 1)')
+          #.joins('LEFT OUTER JOIN nomenclature_prices on nomenclature_prices.id = (SELECT innerNomPrice.id FROM nomenclature_prices AS innerNomPrice WHERE innerNomPrice.nomenclature_variety_id = nomenclature_varieties.id LIMIT 1)')
+        end
+
+        scope :order_by_price, -> (ordering) do
+          ordering = ordering.second.try(:to_sym)
+          if [:asc, :desc].include? ordering
+            nomenclature_prices_join.
+            order("nomenclature_prices.current_price #{ordering}")
+          end
+        end
+
+        scope :category_id, -> (category_id) do
+          return all unless category_id.present?
+          where(category_id: category_id)
+        end
+
+        scope :nomenclature_ids, -> (ids) { where(id: ids) }
+
+        scope :brand_ids, -> (brand) do
+          return all unless brand.present?
+          where(brand: brand)
+        end
+
+        scope :with_brand, -> (brand) do
+          return none unless brand.present?
+          where(brand: brand)
+        end
+
+        scope :brand_line_ids, -> (ids) do
+          return all unless ids.present?
+          where(brand_line_id: ids)
+        end
+
+      end
+
+    end
+
+    def is_bought(user_id)
+      Order.joins(order_items: :nomenclature)
+      .where("nomenclatures.id IN (?)", self.id)
+      .where(user_id: user_id).any?
+    end
+
+    def to_s
+      name.to_s # TODO
+    end
+
+    def self.name_field_update(field)
+      if field.to_s == 'name' #TODO refactor this
+        field = 'name.raw'
+      end
+    end
+
+  end
+
+end