effective_events 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 3286a2f4da1e484f185381cdbf1364c6d966825493a24694c60f7f2da84756b7
+  data.tar.gz: d8fdf171da09d771b7f0068071e526df263134cab9666e663e6828f0df1e91c1
+SHA512:
+  metadata.gz: f197f262daafb0496e7bf4b07c1bd339eac4ae2b921a6d98d57e1063242f5a901131233dda5626fe907faa39bb033daaacf3231c677b550e549e99c33426a0f3
+  data.tar.gz: 2c09ff365be81a9dfb9f9bab9dd93a9bb66fdcb260ce5a1998d2f61a5e5b21dd3c2db63f83dd37cf8cbb2a8cfecf1f521a6e4fbb76842b037054a3d5a85c3301

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2021 Code and Effect Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,97 @@
+# Effective Events
+
+Events, event registrants, event tickets and event products.
+
+## Getting Started
+
+This requires Rails 6+ and Twitter Bootstrap 4 and just works with Devise.
+
+Please first install the [effective_datatables](https://github.com/code-and-effect/effective_datatables) gem.
+
+Please download and install the [Twitter Bootstrap4](http://getbootstrap.com)
+
+Add to your Gemfile:
+
+```ruby
+gem 'haml-rails' # or try using gem 'hamlit-rails'
+gem 'effective_events'
+```
+
+Run the bundle command to install it:
+
+```console
+bundle install
+```
+
+Then run the generator:
+
+```ruby
+rails generate effective_events:install
+```
+
+The generator will install an initializer which describes all configuration options and creates a database migration.
+
+If you want to tweak the table names, manually adjust both the configuration file and the migration now.
+
+Then migrate the database:
+
+```ruby
+rake db:migrate
+```
+
+Use the following datatables to display to your user the events:
+
+```haml
+%h2 Events
+- datatable = EffectiveEventsDatatable.new
+```
+
+and
+
+```
+Add a link to the admin menu:
+
+```haml
+- if can? :admin, :effective_events
+  - if can? :index, Effective::Event
+    = nav_link_to 'Events', effective_events.admin_events_path
+```
+
+## Configuration
+
+## Authorization
+
+All authorization checks are handled via the effective_resources gem found in the `config/initializers/effective_resources.rb` file.
+
+## Permissions
+
+The permissions you actually want to define are as follows (using CanCan):
+
+```ruby
+can :index, Effective::Event
+
+if user.admin?
+  can :manage, Effective::Event
+end
+```
+
+## License
+
+MIT License.  Copyright [Code and Effect Inc.](http://www.codeandeffect.com/)
+
+## Testing
+
+Run tests by:
+
+```ruby
+rails test
+```
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Bonus points for test coverage
+6. Create new Pull Request

data/Rakefile

@@ -0,0 +1,18 @@
+require "bundler/setup"
+
+APP_RAKEFILE = File.expand_path("test/dummy/Rakefile", __dir__)
+load "rails/tasks/engine.rake"
+
+load "rails/tasks/statistics.rake"
+
+require "bundler/gem_tasks"
+
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+task default: :test

data/app/assets/config/effective_events_manifest.js

@@ -0,0 +1,3 @@
+//= link_directory ../javascripts .js
+//= link_directory ../stylesheets .css
+//= link_tree ../images

data/app/assets/javascripts/effective_events.js

@@ -0,0 +1 @@
+//= require_tree ./effective_events

data/app/assets/stylesheets/effective_events.scss

@@ -0,0 +1 @@
+@import 'effective_events/base';

data/app/controllers/admin/event_registrants_controller.rb

@@ -0,0 +1,11 @@
+module Admin
+  class EventRegistrantsController < ApplicationController
+    before_action(:authenticate_user!) if defined?(Devise)
+    before_action { EffectiveResources.authorize!(self, :admin, :effective_events) }
+
+    include Effective::CrudController
+
+    submit :mark_paid, 'Save and Mark Paid'
+
+  end
+end

data/app/controllers/admin/event_registrations_controller.rb

@@ -0,0 +1,19 @@
+module Admin
+  class EventRegistrationsController < ApplicationController
+    before_action(:authenticate_user!) if defined?(Devise)
+    before_action { EffectiveResources.authorize!(self, :admin, :effective_events) }
+
+    include Effective::CrudController
+
+    resource_scope -> { EffectiveEvents.EventRegistration.deep.all }
+    datatable -> { Admin::EffectiveEventRegistrationsDatatable.new }
+
+    private
+
+    def permitted_params
+      model = (params.key?(:effective_event_registration) ? :effective_event_registration : :event_registration)
+      params.require(model).permit!
+    end
+
+  end
+end

data/app/controllers/admin/event_tickets_controller.rb

@@ -0,0 +1,8 @@
+module Admin
+  class EventTicketsController < ApplicationController
+    before_action(:authenticate_user!) if defined?(Devise)
+    before_action { EffectiveResources.authorize!(self, :admin, :effective_events) }
+
+    include Effective::CrudController
+  end
+end

data/app/controllers/admin/events_controller.rb

@@ -0,0 +1,18 @@
+module Admin
+  class EventsController < ApplicationController
+    before_action(:authenticate_user!) if defined?(Devise)
+    before_action { EffectiveResources.authorize!(self, :admin, :effective_events) }
+
+    include Effective::CrudController
+
+    submit :save, 'Save'
+    submit :save, 'Save and Add New', redirect: :new
+    submit :save, 'Save and View', redirect: -> { effective_events.event_path(resource) }
+    submit :save, 'Duplicate', redirect: -> { effective_events.new_admin_event_path(duplicate_id: resource.id) }
+
+    def permitted_params
+      params.require(:effective_event).permit!
+    end
+
+  end
+end

data/app/controllers/effective/event_registrations_controller.rb

@@ -0,0 +1,53 @@
+module Effective
+  class EventRegistrationsController < ApplicationController
+    before_action(:authenticate_user!) if defined?(Devise)
+
+    include Effective::WizardController
+
+    resource_scope -> {
+      event = Effective::Event.find(params[:event_id])
+      EffectiveEvents.EventRegistration.deep.where(owner: current_owner, event: event)
+    }
+
+    # Allow only 1 in-progress event registration at a time
+    before_action(only: [:new, :show], unless: -> { resource&.done? }) do
+      existing = resource_scope.in_progress.where.not(id: resource).first
+
+      if existing.present?
+        flash[:success] = "You have been redirected to your existing in progress event registration"
+        redirect_to effective_events.event_event_registration_build_path(existing.event, existing, existing.next_step)
+      end
+    end
+
+    after_save do
+      flash.now[:success] = ''
+    end
+
+    # The default redirect doesn't respect nested resources here
+    def new
+      self.resource ||= (find_wizard_resource || resource_scope.new)
+      EffectiveResources.authorize!(self, :new, resource)
+
+      redirect_to effective_events.event_event_registration_build_path(
+        resource.event,
+        (resource.to_param || :new),
+        (resource.first_uncompleted_step || resource_wizard_steps.first)
+      )
+    end
+
+    private
+
+    def current_owner
+      (current_user.class.respond_to?(:effective_memberships_owner?) ? current_user.effective_memberships_owners : current_user)
+    end
+
+    def permitted_params
+      model = (params.key?(:effective_event_registration) ? :effective_event_registration : :event_registration)
+
+      params.require(model).permit!.except(
+        :status, :status_steps, :wizard_steps, :submitted_at
+      )
+    end
+
+  end
+end

data/app/controllers/effective/events_controller.rb

@@ -0,0 +1,47 @@
+module Effective
+  class EventsController < ApplicationController
+    include Effective::CrudController
+
+    resource_scope -> {
+      unpublished = EffectiveResources.authorized?(self, :admin, :effective_events)
+      Effective::Event.events(user: current_user, unpublished: unpublished)
+    }
+
+    def index
+      @events ||= resource_scope
+
+      @events = @events.paginate(page: params[:page])
+
+      # if params[:search].present?
+      #   search = params[:search].permit(EffectiveEvents.permitted_params).delete_if { |k, v| v.blank? }
+      #   @events = @events.where(search) if search.present?
+      # end
+
+      EffectiveResources.authorize!(self, :index, Effective::Event)
+
+      @page_title ||= ['Events', (" - Page #{params[:page]}" if params[:page])].compact.join
+    end
+
+    def show
+      @event = resource_scope.find(params[:id])
+
+      if @event.respond_to?(:roles_permit?)
+        raise Effective::AccessDenied.new('Access Denied', :show, @event) unless @event.roles_permit?(current_user)
+      end
+
+      EffectiveResources.authorize!(self, :show, @event)
+
+      if EffectiveResources.authorized?(self, :admin, :effective_events)
+        flash.now[:warning] = [
+          'Hi Admin!',
+          ('You are viewing a hidden event.' if @event.draft?),
+          'Click here to',
+          ("<a href='#{effective_events.edit_admin_event_path(@event)}' class='alert-link'>edit event settings</a>.")
+        ].compact.join(' ')
+      end
+
+      @page_title ||= @event.to_s
+    end
+
+  end
+end

data/app/datatables/admin/effective_event_registrants_datatable.rb

@@ -0,0 +1,47 @@
+module Admin
+  class EffectiveEventRegistrantsDatatable < Effective::Datatable
+    datatable do
+      col :updated_at, visible: false
+      col :created_at, visible: false
+      col :id, visible: false
+
+      col :event
+
+      col :owner, visible: false
+      col :event_registration, visible: false
+
+      if attributes[:event_id]
+        col :event_ticket, search: Effective::EventTicket.where(event: event).all
+      else
+        col :event_ticket, search: :string
+      end
+
+      col :purchased_order
+
+      col :first_name
+      col :last_name
+      col :email
+      col :company
+      col :number
+      col :notes, label: 'Restrictions and notes'
+
+      actions_col
+    end
+
+    collection do
+      scope = Effective::EventRegistrant.deep.purchased
+
+      if attributes[:event_id].present?
+        scope = scope.where(event: event)
+      end
+
+      scope
+    end
+
+    def event
+      @event ||= if attributes[:event_id]
+        Effective::Event.find(attributes[:event_id])
+      end
+    end
+  end
+end

data/app/datatables/admin/effective_event_registrations_datatable.rb

@@ -0,0 +1,25 @@
+class Admin::EffectiveEventRegistrationsDatatable < Effective::Datatable
+  datatable do
+    order :created_at
+
+    col :token, visible: false
+
+    col :created_at, label: 'Created', visible: false
+    col :updated_at, label: 'Updated', visible: false
+
+    col :submitted_at, label: 'Submitted', visible: false, as: :date
+
+    col :event
+    col :owner
+
+    col :event_registrants, search: :string
+    col :orders, label: 'Order'
+
+    actions_col
+  end
+
+  collection do
+    EffectiveEvents.EventRegistration.all.deep.done
+  end
+
+end

data/app/datatables/admin/effective_event_tickets_datatable.rb

@@ -0,0 +1,42 @@
+module Admin
+  class EffectiveEventTicketsDatatable < Effective::Datatable
+    datatable do
+      reorder :position
+
+      col :updated_at, visible: false
+      col :created_at, visible: false
+      col :id, visible: false
+
+      col :event
+
+      col :title
+      col :regular_price, as: :price
+      col :early_bird_price, as: :price
+
+      col :capacity
+      col :purchased_event_registrants_count, label: 'Registered'
+
+      col :purchased_event_registrants, label: 'Registrants' do |ticket|
+        ticket.purchased_event_registrants.sort_by(&:last_name).map do |registrant|
+          content_tag(:div, registrant.last_first_name, class: 'col-resource_item')
+        end.join.html_safe
+      end
+
+      actions_col
+    end
+
+    collection do
+      scope = Effective::EventTicket.deep.all
+
+      if attributes[:event_id]
+        scope = scope.where(event: event)
+      end
+
+      scope
+    end
+
+    def event
+      Effective::Event.find(attributes[:event_id])
+    end
+  end
+end

data/app/datatables/admin/effective_events_datatable.rb

@@ -0,0 +1,51 @@
+module Admin
+  class EffectiveEventsDatatable < Effective::Datatable
+    filters do
+      scope :all
+      scope :registerable
+      scope :drafts
+      scope :upcoming
+      scope :past
+    end
+
+    datatable do
+      col :updated_at, visible: false
+      col :created_at, visible: false
+      col :id, visible: false
+
+      col :title
+      col :draft
+      col :start_at, label: 'Event Date'
+
+      col :end_at, visible: false
+      col :excerpt, visible: false
+
+      col :registration_start_at, label: 'Registration opens'
+      col :registration_end_at, label: 'Registration closes'
+      col :early_bird_end_at, label: 'Early bird ends'
+
+      col :early_bird do |event|
+        if event.early_bird?
+          content_tag(:span, event.early_bird_status, class: 'badge badge-success')
+        else
+          event.early_bird_status
+        end
+      end
+
+      col :event_tickets, search: :string
+      col :event_registrants, search: :string
+
+      col :roles, visible: false
+      col :authenticate_user, visible: false
+
+      actions_col do |event|
+        dropdown_link_to('View Event', effective_events.event_path(event), target: '_blank')
+      end
+    end
+
+    collection do
+      Effective::Event.deep.all
+    end
+
+  end
+end

data/app/datatables/effective_event_registrants_datatable.rb

@@ -0,0 +1,50 @@
+# Used on the Event Registrations registrants step
+
+class EffectiveEventRegistrantsDatatable < Effective::Datatable
+  datatable do
+
+    col :event_ticket, search: :string
+
+    col :name do |er|
+      "#{er.first_name} #{er.last_name}<br><small>#{mail_to(er.email)}</small>"
+    end
+
+    col :first_name, visible: false
+    col :last_name, visible: false
+    col :email, visible: false
+    col :company, visible: false
+    col :number, visible: false
+
+    col :price, as: :price
+    col :notes
+
+    # no actions_col
+  end
+
+  collection do
+    scope = Effective::EventRegistrant.deep.all
+
+    if event.present?
+      scope = scope.where(event: event)
+    end
+
+    if event_registration.present?
+      scope = scope.where(event_registration_id: event_registration)
+    end
+
+    scope
+  end
+
+  def event
+    @event ||= if attributes[:event_id]
+      Effective::Event.find(attributes[:event_id])
+    end
+  end
+
+  def event_registration
+    @event_registration ||= if attributes[:event_registration_id]
+      EffectiveEvents.EventRegistration.find_by_id(attributes[:event_registration_id])
+    end
+  end
+
+end

data/app/datatables/effective_event_registrations_datatable.rb

@@ -0,0 +1,35 @@
+# Dashboard Event Registrations
+class EffectiveEventRegistrationsDatatable < Effective::Datatable
+  datatable do
+    order :created_at
+
+    col :token, visible: false
+    col :created_at, visible: false
+
+    col(:submitted_at, label: 'Registered on') do |er|
+      er.submitted_at&.strftime('%F') || 'Incomplete'
+    end
+
+    col :event, search: :string
+    col :owner, visible: false, search: :string
+    col :status, visible: false
+    col :event_registrants, search: :string
+    col :orders, action: :show, visible: false, search: :string
+
+    actions_col(actions: []) do |er|
+      if er.draft?
+        dropdown_link_to('Continue', effective_events.event_event_registration_build_path(er.event, er, er.next_step), 'data-turbolinks' => false)
+        dropdown_link_to('Delete', effective_events.event_event_registration_path(er.event, er), 'data-confirm': "Really delete #{er}?", 'data-method': :delete)
+      else
+        dropdown_link_to('Show', effective_events.event_event_registration_path(er.event, er))
+      end
+    end
+  end
+
+  collection do
+    owner = (current_user.respond_to?(:effective_memberships_owners) ? current_user.effective_memberships_owners : current_user)
+
+    EffectiveEvents.EventRegistration.deep.where(owner: owner)
+  end
+
+end

data/app/datatables/effective_events_datatable.rb

@@ -0,0 +1,42 @@
+# Dashboard Events
+class EffectiveEventsDatatable < Effective::Datatable
+  filters do
+    # Upcoming should be first here, so when displayed as a simple datatable on the dashboard they only see upcoming events
+    scope :registerable
+    scope :all
+  end
+
+  datatable do
+    order :title
+    col :id, visible: false
+
+    col :start_at, label: 'Event Date'
+    col :title, label: 'Event', action: :show
+    col :excerpt, label: 'Details'
+
+    col :registration_start_at, visible: false
+    col :registration_end_at, label: 'Registration ends'
+
+    col :early_bird do |event|
+      if event.early_bird?
+        content_tag(:span, event.early_bird_status, class: 'badge badge-success')
+      else
+        event.early_bird_status
+      end
+    end
+
+    col :event_tickets, visible: false, search: :string
+    col :early_bird_end_at, label: 'Early bird ends', visible: false
+
+    actions_col do |event|
+      if event.registerable?
+        dropdown_link_to('Register', effective_events.new_event_event_registration_path(event))
+      end
+    end
+  end
+
+  collection do
+    Effective::Event.deep.events(user: current_user)
+  end
+
+end

data/app/helpers/effective_events_helper.rb

@@ -0,0 +1,18 @@
+module EffectiveEventsHelper
+
+  def effective_events_event_tickets_collection(event)
+    raise('expected an Effective::Event') unless event.kind_of?(Effective::Event)
+
+    event.event_tickets.map do |ticket|
+      label = ticket.to_s
+      price = (ticket.price == 0 ? '$0' : number_to_currency(ticket.price))
+
+      ["#{label} - #{price}", ticket.to_param]
+    end
+  end
+
+  def edit_effective_event_registrations_wizard?
+    params[:controller] == 'effective/event_registrations' && defined?(resource) && resource.draft?
+  end
+
+end