rails_event 0.0.1

data/app/controllers/eventual/admin/event_taxons_controller.rb

@@ -0,0 +1,55 @@
+module Eventual
+  class Admin::EventTaxonsController < Admin::BaseController
+    before_action :set_event_taxon, only: [:show, :edit, :update, :destroy]
+
+    def index
+      q_params = {}
+      q_params.merge! default_params
+
+      @event_taxons = EventTaxon.default_where(q_params).order(id: :asc).page(params[:page])
+    end
+
+    def new
+      @event_taxon = EventTaxon.new
+    end
+
+    def create
+      @event_taxon = EventTaxon.new(event_taxon_params)
+
+      unless @event_taxon.save
+        render :new, locals: { model: @event_taxon }, status: :unprocessable_entity
+      end
+    end
+
+    def show
+    end
+
+    def edit
+    end
+
+    def update
+      @event_taxon.assign_attributes(event_taxon_params)
+
+      unless @event_taxon.save
+        render :edit, locals: { model: @event_taxon }, status: :unprocessable_entity
+      end
+    end
+
+    def destroy
+      @event_taxon.destroy
+    end
+
+    private
+    def set_event_taxon
+      @event_taxon = EventTaxon.find(params[:id])
+    end
+
+    def event_taxon_params
+      p = params.fetch(:event_taxon, {}).permit(
+        :name
+      )
+      p.merge! default_form_params
+    end
+
+  end
+end

data/app/controllers/eventual/admin/events_controller.rb

@@ -0,0 +1,91 @@
+module Eventual
+  class Admin::EventsController < Admin::BaseController
+    before_action :set_event, only: [:show, :edit, :meet, :update, :destroy]
+
+    def index
+      q_params = {}
+      q_params.merge! default_params
+      q_params.merge! params.permit(:type, :title, :event_taxon_id, 'id-desc', 'id-asc', 'title-asc')
+
+      @events = Event.default_where(q_params).order(id: :desc).page(params[:page])
+      @event_taxons = EventTaxon.default_where(default_params)
+    end
+
+    def plan
+      q_params = {}
+      q_params.merge! teacher_id: current_member.id if current_member
+      q_params.merge! params.permit(:type, :event_taxon_id, 'id-desc', 'id-asc', 'title-asc')
+      @events = Event.default_where(q_params).page(params[:page])
+
+      render 'index'
+    end
+
+    def new
+      @event = Event.new
+      @event_taxons = EventTaxon.default_where(default_params)
+    end
+
+    def create
+      @event = Event.new(event_params)
+
+      unless @event.save
+        render :new, locals: { model: @event }, status: :unprocessable_entity
+      end
+    end
+
+    def show
+    end
+
+    def edit
+      @event_taxons = EventTaxon.default_where(default_params)
+    end
+
+    def update
+      @event.assign_attributes(event_params)
+
+      unless @event.save
+        render :edit, locals: { model: @event }, status: :unprocessable_entity
+      end
+    end
+
+    def meet
+
+    end
+
+    def destroy
+      @event.destroy
+    end
+
+    private
+    def set_event
+      @event = Event.find(params[:id])
+    end
+
+    def event_params
+      p = params.fetch(:event, {}).permit(
+        :event_taxon_id,
+        :name,
+        :description,
+        :position,
+        :author_id,
+        :teacher_id,
+        :price,
+        :compulsory,
+        event_items_attributes: [
+          :id,
+          :name,
+          :_destroy,
+          {
+            videos: [],
+            documents: [],
+            videos_attachments_attributes: [:id, :_destroy],
+            documents_attachments_attributes: [:id, :_destroy]
+          }
+        ]
+      )
+      p.merge! default_form_params
+      p
+    end
+
+  end
+end

data/app/controllers/eventual/admin/place_taxons_controller.rb

@@ -0,0 +1,57 @@
+module Eventual
+  class Admin::PlaceTaxonsController < Admin::BaseController
+    before_action :set_place_taxon, only: [:show, :edit, :update, :destroy]
+
+    def index
+      q_params = {}
+      q_params.merge! default_params
+
+      @place_taxons = PlaceTaxon.default_where(q_params).page(params[:page])
+    end
+
+    def new
+      @place_taxon = PlaceTaxon.new
+    end
+
+    def create
+      @place_taxon = PlaceTaxon.new(place_taxon_params)
+
+      unless @place_taxon.save
+        render :new, locals: { model: @place_taxon }, status: :unprocessable_entity
+      end
+    end
+
+    def show
+    end
+
+    def edit
+    end
+
+    def update
+      @place_taxon.assign_attributes(place_taxon_params)
+
+      unless @place_taxon.save
+        render :edit, locals: { model: @place_taxon }, status: :unprocessable_entity
+      end
+    end
+
+    def destroy
+      @place_taxon.destroy
+    end
+
+    private
+    def set_place_taxon
+      @place_taxon = PlaceTaxon.find(params[:id])
+    end
+
+    def place_taxon_params
+      p = params.fetch(:place_taxon, {}).permit(
+        :name,
+        :position,
+        :places_count
+      )
+      p.merge! default_form_params
+    end
+
+  end
+end

data/app/controllers/eventual/admin/places_controller.rb

@@ -0,0 +1,59 @@
+module Eventual
+  class Admin::PlacesController < Admin::BaseController
+    before_action :set_place, only: [:show, :edit, :update, :destroy]
+
+    def index
+      q_params = {}
+      q_params.merge! default_params
+      q_params.merge! params.permit(:name, 'max_members-gte')
+      @places = Place.default_where(q_params).page(params[:page])
+    end
+
+    def new
+      @place = Place.new
+      @place.place_taxon = PlaceTaxon.new(default_params)
+    end
+
+    def create
+      @place = Place.new(place_params)
+
+      unless @place.save
+        render :new, locals: { model: @place }, status: :unprocessable_entity
+      end
+    end
+
+    def show
+    end
+
+    def edit
+      @place.place_taxon ||= PlaceTaxon.new(default_params)
+    end
+
+    def update
+      @place.assign_attributes(place_params)
+
+      unless @place.save
+        render :edit, locals: { model: @place }, status: :unprocessable_entity
+      end
+    end
+
+    def destroy
+      @place.destroy
+    end
+
+    private
+    def set_place
+      @place = Place.find(params[:id])
+    end
+
+    def place_params
+      p = params.fetch(:place, {}).permit(
+        :name,
+        :color,
+        :place_taxon_ancestors
+      )
+      p.merge! default_form_params
+    end
+
+  end
+end

data/app/controllers/eventual/admin/plan_attenders_controller.rb

@@ -0,0 +1,65 @@
+module Eventual
+  class Admin::PlanAttendersController < Admin::BaseController
+    before_action :set_plan_item
+    before_action :set_plan_attender, only: [:edit, :update, :attend, :absent]
+
+    def index
+      @plan_item.plan_participants.each(&:sync)
+      @plan_attenders = @plan_item.plan_attenders
+    end
+
+    def create
+      @plan_attender = @plan_item.plan_attenders.build(plan_participant_id: params[:plan_participant_id])
+      @plan_attender.attended = true
+
+      unless @plan_attender.save
+        render :new, locals: { model: @plan_attender }, status: :unprocessable_entity
+      end
+    end
+
+    def edit
+    end
+
+    def attend
+      @plan_attender.attended = true
+      @plan_attender.save
+    end
+
+    def absent
+      @plan_attender.attended = false
+      @plan_attender.save
+    end
+
+    def update
+      @plan_attender.assign_attributes(plan_attender_params)
+
+      unless @plan_attender.save
+        render :edit, locals: { model: @plan_attender }, status: :unprocessable_entity
+      end
+    end
+
+    def destroy
+      @plan_attender = @plan_item.plan_attenders.find_by(plan_participant_id: params[:plan_participant_id])
+      @plan_attender.destroy
+    end
+
+    private
+    def set_plan_item
+      @plan_item = PlanItem.find params[:plan_item_id]
+    end
+
+    def set_plan_attender
+      @plan_attender = @plan_item.plan_attenders.find(params[:id])
+    end
+
+    def plan_attender_params
+      params.fetch(:plan_attender, {}).permit(
+        :state,
+        :attender_type,
+        :attender_id,
+        :attended
+      )
+    end
+
+  end
+end

data/app/controllers/eventual/admin/plan_items_controller.rb

@@ -0,0 +1,84 @@
+module Eventual
+  class Admin::PlanItemsController < Admin::BaseController
+    before_action :set_plan_item, only: [:show, :edit, :update, :qrcode, :destroy]
+
+    def index
+      q_params = {}
+      filter_params = {
+        start_on: Date.today.beginning_of_week,
+        finish_on: Date.today.end_of_week
+      }.with_indifferent_access
+      filter_params.merge! params.permit(:start_on, :finish_on)
+      filter_params.merge! default_params
+
+      q_params.merge! params.permit(:planned_type, :planned_id, :place_id, 'plan_participants.event_participant_id')
+
+      @plans = Plan.xxx(**filter_params.symbolize_keys)
+      @plans.each { |plan| plan.produce(start_on: filter_params[:start_on], finish_on: filter_params[:finish_on]) }
+
+      @plan_items = PlanItem.to_events(**filter_params.symbolize_keys)
+
+      booking_params = {
+        booker_type: 'Maintain',
+        booker_id: params[:maintain_id],
+        'booking_on-gte': filter_params[:start_on],
+        'booking_on-lte': filter_params[:finish_on]
+      }
+
+      @booked_ids = Booking.default_where(booking_params).pluck(:plan_item_id)
+    end
+
+    def new
+      @plan_item = PlanItem.new
+    end
+
+    def create
+      @plan_item = PlanItem.new(plan_item_params)
+
+      unless @plan_item.save
+        render :new, locals: { model: @plan_item }, status: :unprocessable_entity
+      end
+    end
+
+    def show
+    end
+
+    def edit
+      @places = Place.default_where(default_params)
+    end
+
+    def update
+      @plan_item.assign_attributes(plan_item_params)
+
+      unless @plan_item.save
+        render :edit, locals: { model: @plan_item }, status: :unprocessable_entity
+      end
+    end
+
+    def qrcode
+      @plan_item.qrcode
+    end
+
+    def destroy
+      @plan_item.destroy
+    end
+
+    private
+    def set_plan_item
+      @plan_item = PlanItem.find(params[:id])
+    end
+
+    def plan_item_params
+      params.fetch(:plan_item, {}).permit(
+        :planned_type,
+        :planned_id,
+        :plan_on,
+        :time_item_id,
+        :event_item_id,
+        :place_id,
+        plan_participants_attributes: [:participant_type, :participant_id]
+      )
+    end
+
+  end
+end

data/app/controllers/eventual/admin/plans_controller.rb

@@ -0,0 +1,127 @@
+module Eventual
+  class Admin::PlansController < Admin::BaseController
+    before_action :set_time_lists
+    before_action :set_plan, only: [:show, :show_calendar, :edit, :update, :destroy]
+
+    def index
+      q_params = {}
+      q_params.merge! params.permit('end_on-gte', 'begin_on-lte', :planned_type, :planned_id, :place_id, 'plan_participants.event_participant_id')
+      q_params.merge! default_params
+
+      @plans = Plan.default_where(q_params)
+      @plan_items = PlanItem.default_where(q_params)
+    end
+
+    def calendar
+      @time_list = TimeList.find params[:time_list_id]
+      set_settings
+      @events = @time_list.events(@settings[:defaultDate], @settings[:dayCount])
+    end
+
+    def new
+      @plan = Plan.new
+    end
+
+    def create
+      @plan = Plan.new
+      @plan.time_list ||= @time_lists.default
+      @plan.assign_attributes plan_params
+
+      unless @plan.save
+        render :new, locals: { model: @plan }, status: :unprocessable_entity
+      end
+    end
+
+    def show
+    end
+
+    def show_calendar
+      @time_list = TimeList.find params[:time_list_id]
+      set_settings
+      @events = @time_list.events(@settings[:defaultDate], @settings[:dayCount])
+
+      render :calendar
+    end
+
+    def edit
+    end
+
+    def update
+      @plan.assign_attributes plan_params
+
+      unless @plan.save
+        render :edit, locals: { model: @plan }, status: :unprocessable_entity
+      end
+    end
+
+    def xx
+      dt = params[:index].to_s
+      if dt
+        @plan.toggle(dt, params[:time_item_id].to_i)
+      end
+    end
+
+    def destroy
+      @plan.destroy
+    end
+
+    private
+    def set_plan
+      @plan = Plan.find(params[:id])
+    end
+
+    def set_time_lists
+      q_params = {}
+      q_params.merge! default_params
+      @places = Place.default_where(q_params)
+      @time_lists = TimeList.default_where(q_params)
+      @time_list = @time_lists.default
+    end
+
+    def set_settings
+      @time_list ||= @plan.time_list
+      if @time_list
+        @settings = {
+          minTime: @time_list.min_time,
+          maxTime: @time_list.max_time,
+          slotDuration: @time_list.slot_duration,
+          slotLabelInterval: @time_list.slot_label_interval
+        }
+      else
+        @settings = {
+          defaultDate: '2000-01-01',
+          dayCount: 7,
+          minTime: '07:30:00',
+          maxTime: '18:30:00',
+          slotDuration: '00:10',
+          slotLabelInterval: '1:00'
+        }
+      end
+      if @plan
+        @settings.merge!(
+          defaultDate: @plan.default_date.to_s(:date)
+        )
+        @settings.merge! repeat_settings
+      end
+    end
+
+    def plan_params
+      p = params.fetch(:plan, {}).permit(
+        :planned_type,
+        :planned_id,
+        :time_list_id,
+        :place_id,
+        :begin_on,
+        :end_on,
+        :repeat_type,
+        repeat_days: {},
+        plan_participants_attributes: [:participant_type, :participant_id, :event_participant_id]
+      )
+      unless p[:planned_type] || p[:planned_id]
+        p.merge! params.permit(:planned_type, :planned_id)
+      end
+      p
+    end
+
+  end
+end