rails_event 0.0.1

data/app/models/eventual/event_item.rb

@@ -0,0 +1,5 @@
+module Eventual
+  class EventItem < ApplicationRecord
+    include Model::EventItem
+  end
+end

data/app/models/eventual/event_participant.rb

@@ -0,0 +1,6 @@
+module Eventual
+  class EventParticipant < ApplicationRecord
+    include Model::EventParticipant
+    include Com::Ext::StateMachine
+  end
+end

data/app/models/eventual/event_taxon.rb

@@ -0,0 +1,5 @@
+module Eventual
+  class EventTaxon < ApplicationRecord
+    include Model::EventTaxon
+  end
+end

data/app/models/eventual/ext/recurrence.rb

@@ -0,0 +1,86 @@
+module Eventual
+  module Ext::Recurrence
+    extend ActiveSupport::Concern
+
+    included do
+      attribute :repeat_type, :string, default: ''
+      attribute :repeat_days, :integer, array: true, default: []
+
+      enum repeat_type: {
+        once: 'once',
+        weekly: 'weekly',
+        monthly: 'monthly'
+      }
+
+      before_save :deal_repeat_days, if: -> { repeat_days_changed? }
+    end
+
+    def deal_repeat_days
+      self.repeat_days = self.repeat_days.map(&:to_i)
+    end
+
+
+    def next_start_at
+      return if start_at.nil?
+      _next_day = self.next_day
+      _next_day.change(hour: start_at.hour, min: start_at.min, sec: start_at.sec)
+    end
+
+    def next_finish_at
+      return if finish_at.nil?
+      _next_day = self.next_day
+      _next_day.change(hour: finish_at.hour, min: finish_at.min, sec: finish_at.sec)
+    end
+
+    def next_day(datetime = Time.now)
+      if self.repeat_type == 'weekly'
+        next_weekly_day(datetime)
+      elsif self.repeat_type == 'monthly'
+        next_monthly_day(datetime)
+      else
+        datetime
+      end
+    end
+
+    def next_weekly_day(datetime = Time.now)
+      start_at_date = self.start_at.change(year: datetime.year, month: datetime.month, day: datetime.day)
+
+      if start_at_date > datetime
+        next_days = self.repeat_days.select { |day| day >= datetime.days_to_week_start(:sunday) }
+      else
+        next_days = self.repeat_days.select { |day| day > datetime.days_to_week_start(:sunday) }
+      end
+
+      if next_days.size > 0
+        next_day = next_days.min
+      else
+        next_day = self.repeat_days.min
+      end
+
+      str = Date::DAYS_INTO_WEEK.key(next_day)
+      day = datetime.next_occurring(str)
+      datetime.change(month: day.month, day: day.day)
+    end
+
+    def next_monthly_day(datetime = Time.now)
+      start_at_date = self.start_at.change(year: datetime.year, month: datetime.month, day: datetime.day)
+
+      if start_at_date > datetime
+        next_days = self.repeat_days.select { |day| day >= datetime.day }
+      else
+        next_days = self.repeat_days.select { |day| day > datetime.day }
+      end
+
+      if next_days.size > 0
+        next_day = next_days.min
+        month = datetime.month
+      else
+        next_day = self.repeat_days.min
+        month = datetime.next_month.month
+      end
+
+      datetime.change(month: month, day: next_day)
+    end
+
+  end
+end

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

@@ -0,0 +1,18 @@
+module Eventual
+  module Model::Agency
+    extend ActiveSupport::Concern
+
+    included do
+      has_many :crowd_members
+      has_many :crowds, through: :crowd_members
+    end
+
+    def join_crowd(crowd_id)
+      cs = self.crowd_members.build
+      cs.member = client
+      cs.crowd_id = crowd_id
+      cs.save
+    end
+
+  end
+end

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

@@ -0,0 +1,10 @@
+module Eventual
+  module Model::Booked
+    extend ActiveSupport::Concern
+
+    included do
+      has_many :booked_bookings, class_name: 'Booking', as: :booked
+    end
+
+  end
+end

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

@@ -0,0 +1,15 @@
+module Eventual
+  module Model::Booker
+    extend ActiveSupport::Concern
+
+    included do
+      has_many :booker_bookings, class_name: 'Booking', as: :booker
+    end
+
+
+    def confirm_booker_time!(booked)
+      p 'implement in application'
+    end
+
+  end
+end

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

@@ -0,0 +1,37 @@
+module Eventual
+  module Model::Booking
+    extend ActiveSupport::Concern
+
+    included do
+      attribute :booking_on, :date
+
+      belongs_to :booker, polymorphic: true
+      belongs_to :booked, polymorphic: true, optional: true
+      belongs_to :plan_item, optional: true
+      belongs_to :time_item
+      belongs_to :place, optional: true
+      belongs_to :seat, optional: true
+
+      delegate :start_at, :finish_at, to: :plan_item, allow_nil: true
+
+      validates :booking_on, presence: true
+      validates :booker_id, uniqueness: { scope: [:booker_type, :plan_item_id] }
+
+      before_validation :sync_from_plan_item
+      after_create :sync_to_booker
+    end
+
+    def sync_from_plan_item
+      if plan_item
+        self.booked = plan_item.planned
+        self.booking_on = plan_item.plan_on
+        self.time_item_id = plan_item.time_item_id
+      end
+    end
+
+    def sync_to_booker
+      booker.confirm_booker_time!(self)
+    end
+
+  end
+end

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

@@ -0,0 +1,21 @@
+module Eventual
+  module Model::Crowd
+    extend ActiveSupport::Concern
+
+    included do
+      attribute :name, :string
+      attribute :member_type, :string, default: 'Profile'
+      attribute :crowd_members_count, :integer, default: 0
+
+      belongs_to :organ, optional: true
+      has_many :crowd_members
+      has_many :members, through: :crowd_members, source_type: 'Profile'
+      has_many :event_participants
+
+      validates :name, presence: true
+
+      has_one_attached :logo
+    end
+
+  end
+end

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

@@ -0,0 +1,20 @@
+module Eventual
+  module Model::CrowdMember
+    extend ActiveSupport::Concern
+
+    included do
+      attribute :state, :string
+
+      belongs_to :crowd, counter_cache: true
+      belongs_to :member, polymorphic: true
+      belongs_to :agency, optional: true
+
+      after_destroy_commit :quit_event
+    end
+
+    def quit_event
+
+    end
+
+  end
+end

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

@@ -0,0 +1,48 @@
+module Eventual
+  module Model::Event
+    extend ActiveSupport::Concern
+
+    included do
+      attribute :name, :string
+      attribute :description, :string, limit: 4096
+      attribute :position, :integer
+      attribute :price, :decimal
+      attribute :event_participants_count, :integer, default: 0
+      attribute :event_items_count, :integer, default: 0
+      attribute :members_count, :integer, default: 0
+
+      belongs_to :organ, optional: true
+      belongs_to :event_taxon, optional: true
+
+      has_many :event_items, dependent: :nullify
+      accepts_nested_attributes_for :event_items, allow_destroy: true
+
+      has_many :event_participants, dependent: :destroy
+      has_many :crowds, through: :event_participants
+      has_many :event_grants, dependent: :destroy
+    end
+
+    def member_type_ids
+      event_participants.pluck(:member_type, :member_id)
+    end
+
+    def save_with_remind
+      self.class.transaction do
+        self.save!
+      end
+
+      return unless self.persisted?
+
+      self.class.transaction do
+        EventParticipantMailer.assign(self.id).deliver_later
+        job = EventParticipantMailer.remind(self.id).deliver_later(wait_until: self.event.next_start_at - 1.day)
+        self.update(job_id: job.job_id)
+      end
+    end
+
+    def timestamp
+      self.event_participants.order(created_at: :desc).first&.created_at.to_i
+    end
+
+  end
+end

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

@@ -0,0 +1,54 @@
+module Eventual
+  module Model::EventCrowd
+    extend ActiveSupport::Concern
+
+    included do
+      attribute :present_number, :integer, default: 0
+
+      belongs_to :event
+      belongs_to :crowd
+
+      has_many :crowd_members, foreign_key: :crowd_id, primary_key: :crowd_id
+      has_many :plan_items, as: :plan, dependent: :destroy
+      has_many :event_participants
+      has_many :events, foreign_key: :event_id, primary_key: :event_id
+
+      after_create_commit :sync_to_event_participants
+      after_destroy_commit :destroy_from_event_participants
+      after_update_commit :sync_to_event_plans
+
+      delegate :title, to: :event
+      delegate :max_members, to: :place, allow_nil: true
+    end
+
+    def sync_to_event_participants
+      self.crowd_members.each do |i|
+        cs = self.event_participants.build(crowd_member_id: i.id)
+        cs.save
+      end
+    end
+
+    def sync_to_event_plans
+      if saved_change_to_teacher_id?
+        self.plan_items.where(teacher_id: nil).update_all(teacher_id: self.teacher_id)
+      end
+      if saved_change_to_room_id?
+        self.plan_items.where(room_id: nil).update_all(room_id: self.room_id)
+      end
+    end
+
+    def sync_to_plan_items
+      self.event_id ||= event_crowd.event_id
+      self.teacher_id ||= event_crowd.teacher_id
+      self.room_id ||= event_crowd.room_id
+    end
+
+    def destroy_from_event_participants
+      self.crowd.members.each do |i|
+        cs = i.event_participants.find_by(member_id: i.id)
+        cs&.destroy
+      end
+    end
+
+  end
+end

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

@@ -0,0 +1,14 @@
+module Eventual
+  module Model::EventGrant
+    extend ActiveSupport::Concern
+
+    included do
+      attribute :grant_kind, :string
+      attribute :grant_column, :string
+      attribute :filter, :json, default: {}
+
+      belongs_to :event
+    end
+
+  end
+end

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

@@ -0,0 +1,30 @@
+module Eventual
+  module Model::EventItem
+    extend ActiveSupport::Concern
+
+    included do
+      attribute :name, :string
+
+      belongs_to :event
+      belongs_to :author, class_name: 'Member', optional: true
+      has_many :event_item_members
+      has_many :members, through: :event_item_members, source_type: 'Profile'
+
+      has_many_attached :videos
+      has_many_attached :documents
+
+      accepts_nested_attributes_for :videos_attachments, allow_destroy: true
+      accepts_nested_attributes_for :documents_attachments, allow_destroy: true
+    end
+
+
+    def video_urls
+      videos.map(&:service_url)
+    end
+
+    def document_urls
+      documents.map(&:service_url)
+    end
+
+  end
+end

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

@@ -0,0 +1,63 @@
+module Eventual
+  module Model::EventParticipant
+    extend ActiveSupport::Concern
+
+    included do
+      attribute :score, :integer
+      attribute :comment, :string
+      attribute :quit_note, :string
+      attribute :assigned_status, :string
+      attribute :job_id, :string
+
+      belongs_to :event_crowd, optional: true
+      belongs_to :event, counter_cache: true
+      belongs_to :crowd_member, optional: true
+      belongs_to :participant, polymorphic: true
+
+      validates :member_id, uniqueness: { scope: [:member_type, :event_id] }
+
+      enum state: {
+        in_studying: 'in_studying',
+        request_quit: 'request_quit',
+        quit: 'quit',
+        in_evaluating: 'in_evaluating',
+        passed: 'passed',
+        failed: 'failed'
+      }, _default: 'in_studying'
+
+      before_validation :sync_from_crowd_member
+      after_destroy :delete_reminder_job
+    end
+
+    def sync_from_crowd_member
+      if self.crowd_member
+        self.member_type = crowd_member.member_type
+        self.member_id = crowd_member.member_id
+      end
+      if self.event_crowd
+        self.event_id = event_crowd.event_id
+      end
+    end
+
+    def save_with_remind
+      self.class.transaction do
+        self.save!
+      end
+
+      return unless self.persisted?
+
+      self.class.transaction do
+        EventParticipantMailer.assign(self.id).deliver_later
+        if self.event.next_start_time
+          job = EventParticipantMailer.remind(self.id).deliver_later(wait_until: self.event.next_start_time - 1.day)
+          self.update(job_id: job.job_id)
+        end
+      end
+    end
+
+    def delete_reminder_job
+      ActionMailer::DeliveryJob.cancel(self.job_id) if ActionMailer::DeliveryJob.respond_to?(:cancel)
+    end
+
+  end
+end