rails_event 0.0.1

data/app/models/eventual/model/event_taxon.rb

@@ -0,0 +1,13 @@
+module Eventual
+  module Model::EventTaxon
+    extend ActiveSupport::Concern
+
+    included do
+      attribute :name, :string
+
+      belongs_to :organ, optional: true
+      has_many :events, dependent: :nullify
+    end
+
+  end
+end

data/app/models/eventual/model/member.rb

@@ -0,0 +1,18 @@
+module Eventual
+  module Model::Member
+    extend ActiveSupport::Concern
+
+    included do
+      has_many :event_participants, as: :member, dependent: :destroy
+      has_many :events, through: :event_participants
+
+      has_many :crowd_members, as: :member, dependent: :destroy
+      has_many :crowds, through: :crowd_members
+
+      has_many :plan_members, as: :member, dependent: :destroy
+      has_many :plan_attenders, as: :attender, dependent: :destroy
+    end
+
+
+  end
+end

data/app/models/eventual/model/occurrence.rb

@@ -0,0 +1,62 @@
+module Eventual
+  module Model::Occurrence
+
+    def next_occurrence(now: Time.current)
+      ti = time_items.find { |i| i.start_at.to_s(:time) > now.to_s(:time) }
+      if ti
+        date = next_occurred_days(limit: 1).first
+        hour, min = ti.start_at.to_s(:time).split(':')
+        date.to_datetime.change(hour: hour.to_i, min: min.to_i)
+      else
+        date = next_occurred_days(limit: 2).last
+        t2 = time_items.first
+        hour, min = t2.start_at.to_s(:time).split(':')
+        date.to_datetime.change(hour: hour.to_i, min: min.to_i)
+      end
+    end
+
+    def next_occurred_days(now: Time.current, limit: 1)
+      days = self.repeat_days.keys
+      r = []
+      case self.repeat_type
+      when 'weekly'
+        first_days = days.select { |day| day.to_i >= now.days_to_week_start }
+        first_days.each do |day|
+          r << now.beginning_of_week.days_since(day.to_i)
+          limit -= 1
+          return r if limit.zero?
+        end
+        (1..).each do |week|
+          days.each do |day|
+            r << now.weeks_since(week).beginning_of_week.days_since(day.to_i)
+            limit -= 1
+            return r if limit.zero?
+          end
+        end
+      when 'monthly'
+        first_days = days.select { |day| day.to_i >= now.day }
+        first_days.each do |day|
+          r << now.beginning_of_month.days_since(day.to_i)
+          limit -= 1
+          return r if limit.zero?
+        end
+        (1..).each do |month|
+          days.each do |day|
+            r << now.weeks_since(month).beginning_of_month.days_since(day.to_i)
+            limit -= 1
+            return r if limit.zero?
+          end
+        end
+      when 'once'
+        first_days = days.select { |day| day.to_date >= now.to_date }
+        first_days.each do |date|
+          r << date
+          limit -= 1
+          return r if limit.zero?
+        end
+      end
+      r
+    end
+
+  end
+end

data/app/models/eventual/model/place.rb

@@ -0,0 +1,25 @@
+module Eventual
+  module Model::Place
+    extend ActiveSupport::Concern
+
+    included do
+      attribute :name, :string
+      attribute :description, :string
+      attribute :color, :string
+      attribute :seats_count, :integer, default: 0
+      attribute :plans_count, :integer, default: 0
+
+      belongs_to :organ, optional: true
+      belongs_to :area, optional: true
+      belongs_to :place_taxon, counter_cache: true, optional: true
+      belongs_to :taxon, class_name: 'PlaceTaxon', optional: true, foreign_key: :place_taxon_id
+      has_many :plans
+      has_many :seats, dependent: :delete_all
+
+      validates :name, presence: true
+
+      has_taxons :place_taxon
+    end
+
+  end
+end

data/app/models/eventual/model/place_taxon.rb

@@ -0,0 +1,18 @@
+module Eventual
+  module Model::PlaceTaxon
+    extend ActiveSupport::Concern
+
+    included do
+      attribute :name, :string
+      attribute :position, :integer
+      attribute :profit_margin, :decimal, precision: 4, scale: 2
+      attribute :places_count, :integer
+
+      belongs_to :organ, optional: true
+      has_many :places, dependent: :nullify
+
+      acts_as_list
+    end
+
+  end
+end

data/app/models/eventual/model/plan.rb

@@ -0,0 +1,147 @@
+module Eventual
+  module Model::Plan
+    REPEAT = {
+      'once' => 0..6,
+      'weekly' => 0..6,
+      'monthly' => 0..30
+    }.freeze
+    extend ActiveSupport::Concern
+
+    included do
+      attribute :title, :string
+      attribute :begin_on, :date, default: -> { Date.today }
+      attribute :end_on, :date
+      attribute :produced_begin_on, :date
+      attribute :produced_end_on, :date
+      attribute :produce_done, :boolean
+      attribute :repeat_type, :string, comment: '日、周、月、天'
+      attribute :repeat_count, :integer, comment: '每几周'
+      attribute :repeat_days, :json
+
+      belongs_to :planned, polymorphic: true
+      belongs_to :time_list
+      belongs_to :place, optional: true
+
+      has_many :time_items, through: :time_list
+      has_many :time_bookings, ->(o){ where(booked_type: o.plan_type) }, foreign_key: :booked_id, primary_key: :plan_id
+      has_many :plan_items, dependent: :destroy
+
+      default_scope -> { order(begin_on: :asc) }
+
+      validates :begin_on, presence: true
+      after_initialize if: :new_record? do
+        self.planned_type ||= 'Event'
+      end
+    end
+
+    def selected_ids(date, index)
+      case repeat_type
+      when 'yearly'
+        Array(self.repeat_days[date.to_s])
+      when 'monthly'
+        Array(self.repeat_days[index.to_s])
+      when 'weekly'
+        Array(self.repeat_days[index.to_s])
+      end
+    end
+
+    def same_scopes
+      self.class.where.not(id: self.id).default_where(planned_type: self.plan_type, planned_id: self.plan_id)
+    end
+
+    def toggle(index, time_item_id)
+      if repeat_type_changed? || time_list_id_changed?
+        self.repeat_days = {}
+      end
+
+      repeat_days.toggle! index => time_item_id
+    end
+
+    def diff_toggle(index, time_item_id)
+      if repeat_type_changed? || time_list_id_changed?
+        self.repeat_days = {}
+      end
+
+      repeat_days.diff_toggle index => time_item_id
+    end
+
+    def produce(start_on: Date.today.beginning_of_week, finish_on: Date.today.end_of_week)
+      removes, adds = self.present_days.diff_changes self.next_days(start: start_on, finish: finish_on)
+
+      self.class.transaction do
+        self.produced_begin_on = start_on
+        self.produced_end_on = finish_on
+
+        removes.each do |date, time_item_ids|
+          Array(time_item_ids).each do |time_item_id|
+            self.plan_items.where(plan_on: date, time_item_id: time_item_id).each(&:destroy!)
+          end
+        end
+
+        adds.each do |date, time_item_ids|
+          Array(time_item_ids).each do |time_item_id|
+            pi = self.plan_items.find_or_initialize_by(plan_on: date, time_item_id: time_item_id)
+            pi.save!
+          end
+        end
+
+        self.save!
+      end
+
+      self
+    end
+
+    def present_days
+      self.plan_items.order(plan_on: :asc).group_by(&->(i){i.plan_on.to_s}).transform_values! do |v|
+        v.map(&:time_item_id)
+      end
+    end
+
+    class_methods do
+
+      def recent(date = Date.today)
+        default_where('begin_on-lte': date).unscope(:order).order(begin_on: :desc).first
+      end
+
+      def xxx(start_on: Date.today.beginning_of_week, finish_on: Date.today.end_of_week, **filter_params)
+        # 时间范围与时间参数存在重叠
+        q = { 'end_on-gte': start_on, 'begin_on-lte': finish_on }.merge! filter_params
+        or_q = {
+          or: {
+            'produced_begin_on-gt': start_on,
+            'produced_end_on-lt': finish_on,
+            'begin_on': nil,
+            'end_on': nil,
+            'produced_begin_on': nil,
+            'produced_end_on': nil
+          },
+          allow: {
+            'begin_on': nil,
+            'end_on': nil,
+            'produced_begin_on': nil,
+            'produced_end_on': nil
+          }
+        }
+
+        Plan.default_where(q.merge!(or_q))
+      end
+
+      def xx
+        Date::DAYS_INTO_WEEK.map do |name, index|
+          if Date.beginning_of_week == :monday
+            i = (index - 1) % 7
+          else
+            i = index
+          end
+          [i, I18n.t("date.week_day.#{name}.name")]
+        end.sort.to_h
+      end
+
+    end
+
+  end
+end
+
+# note
+# 如果已经存在 A ~ B 日期范围内的数据；
+# begin_on 位于 [A, B]之间, end_on

data/app/models/eventual/model/plan_attender.rb

@@ -0,0 +1,31 @@
+module Eventual
+  module Model::PlanAttender
+    extend ActiveSupport::Concern
+
+    included do
+      attribute :attended, :boolean, default: false
+      attribute :state, :string
+      attribute :extra, :json
+
+      belongs_to :plan_participant, optional: true
+      belongs_to :attender, polymorphic: true
+      belongs_to :plan_item
+      belongs_to :plan
+      belongs_to :place
+
+      enum state: {
+        absent: 'absent'  # 请假
+      }
+
+      after_initialize if: :new_record? do
+        if plan_item
+          self.assign_attributes plan_item.as_json(only: [:place_id])
+        end
+        if plan_participant
+          self.attender = plan_participant.participant
+        end
+      end
+    end
+
+  end
+end

data/app/models/eventual/model/plan_item.rb

@@ -0,0 +1,84 @@
+module Eventual
+  module Model::PlanItem
+    extend ActiveSupport::Concern
+
+    included do
+      attribute :plan_on, :date
+      attribute :bookings_count, :integer, default: 0
+      attribute :plan_participants_count, :integer, default: 0
+      attribute :plan_on, :date
+      attribute :repeat_index, :string
+      attribute :extra, :json
+
+
+      belongs_to :time_item
+      belongs_to :time_list
+      belongs_to :plan, optional: true
+      belongs_to :planned, polymorphic: true
+      belongs_to :place, optional: true
+      belongs_to :event, optional: true
+      belongs_to :event_item, optional: true
+      has_many :bookings, dependent: :destroy
+      has_many :plan_attenders, dependent: :nullify
+
+      validates :plan_on, presence: true
+
+      default_scope -> { order(plan_on: :asc) }
+      scope :valid, -> { default_where('plan_on-gte': Date.today) }
+
+      before_validation :sync_from_plan
+    end
+
+    def attenders
+      plan_attenders.where(attended: true).pluck(:attender_type, :attender_id).map { |i| i.join('_') }
+    end
+
+    def start_at
+      time_item.start_at.change(plan_on.parts)
+    end
+
+    def finish_at
+      time_item.finish_at.change(plan_on.parts)
+    end
+
+    def sync_from_plan
+      if plan
+        self.place_id = plan.place_id
+        self.planned = plan.planned
+        self.repeat_index = self.plan.repeat_index(plan_on)
+        self.plan.plan_participants.each do |plan_participant|
+          self.plan_participants.build plan_participant.as_json(only: [:participant_type, :participant_id, :event_participant_id, :status])
+        end
+      end
+      if time_item
+        self.time_list_id = time_item.time_list_id
+      end
+    end
+
+    class_methods do
+
+      def to_events(start_on: Date.today.beginning_of_week, finish_on: Date.today.end_of_week, **options)
+        options.merge! 'plan_on-gte': start_on, 'plan_on-lte': finish_on
+        cols = (start_on.to_date .. finish_on.to_date).map { |i| [i, []] }.to_h
+        if options[:time_list_id]
+          time_list = TimeList.find options[:time_list_id]
+        elsif options.key?(:organ_id)
+          time_list = TimeList.where(organ_id: options[:organ_id]).default
+          options.merge! time_list_id: time_list&.id
+        else
+          time_list = TimeList.where(organ_id: nil).default
+          options.merge! time_list_id: time_list&.id
+        end
+        rows = time_list.time_items.map { |i| [i, []] }.to_h
+
+        cols.merge! PlanItem.includes(:time_item).default_where(options).group_by(&->(i){i.plan_on})
+        cols.each do |date, items|
+          cols[date] = rows.merge items.group_by(&->(i){i.time_item})
+        end
+        cols
+      end
+
+    end
+
+  end
+end

data/app/models/eventual/model/plan_participant/crowd_participant.rb

@@ -0,0 +1,17 @@
+module Eventual
+  module Model::PlanParticipant::CrowdParticipant
+    extend ActiveSupport::Concern
+
+    included do
+      belongs_to :crowd, foreign_key: :participant_id
+      has_many :members, through: :crowd
+    end
+
+    def sync
+      self.members.each do |member|
+        self.planning.plan_attenders.find_or_create_by(attender_type: member.class_name, attender_id: member.id)
+      end
+    end
+
+  end
+end

data/app/models/eventual/model/plan_participant/normal_participant.rb

@@ -0,0 +1,9 @@
+module Eventual
+  module Model::PlanParticipant::NormalParticipant
+    extend ActiveSupport::Concern
+
+    included do
+    end
+
+  end
+end

data/app/models/eventual/model/plan_participant.rb

@@ -0,0 +1,30 @@
+module Eventual
+  module Model::PlanParticipant
+    extend ActiveSupport::Concern
+
+    included do
+      attribute :type, :string
+      attribute :status, :string, comment: '默认 event_participant 有效'
+
+      belongs_to :planning, polymorphic: true
+      belongs_to :event_participant, optional: true
+      belongs_to :participant, polymorphic: true
+
+      after_initialize if: :new_record? do
+        if self.event_participant
+          self.participant = event_participant.participant
+        end
+        if self.participant_type == 'Crowd'
+          self.type = 'CrowdParticipant'
+        else
+          self.type = 'NormalParticipant'
+        end
+      end
+    end
+
+    def sync
+      self.planning.plan_attenders.find_or_create_by(plan_participant_id: self.id)
+    end
+
+  end
+end