rooftop-rails-events 0.1.9

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 43c3a9fa04042ebd6c88977baa161e2f99554620
+  data.tar.gz: dae897de59297fbf2ef58ed85984d44d1497a2db
+SHA512:
+  metadata.gz: b232cf857b16de7483e1ba8bb02223b3a055bccfab23575c1d21d5c8489236d0962e441cebe8f5dda4a256f674dc622e4519ea011acc2d91e53455881f6f322f
+  data.tar.gz: cff98c0085dd4f4e82d775c45fde94566af04a69eb47e28c8c16a46fdf44a00e47dab48ef713d13fbeef063d9896e9ebf515b899f43a39cae972e2aa78248738

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in rooftop-rails-events.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Ed Jones
+
+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,154 @@
+# Rooftop::Rails::Events
+
+A library to make it super-easy to integrate events from [Rooftop CMS](https://www.rooftopcms.com) into your Rails site.
+
+## What's included
+A bit of a mix of stuff, and all work in progress. Here's a flavour:
+
+## Controller Mixins
+You need to `include` these yourself.
+
+### Rooftop::Rails::Events::EventHandler
+A mixin for a controller which handles events. It has methods for show(), instances() and book_instance() which get the event from Rooftop for you.
+
+In the simplest form, you can just include this in your controller
+
+```
+class EventsController < ApplicationController
+    include Rooftop::Rails::Events::EventHandler
+end
+````
+
+But each method yields to a block so you can do other stuff if you want. Here's a more representative EventsController from a real project:
+
+```
+class EventsController < ApplicationController
+  include Rooftop::Rails::Events::EventHandler
+  decorates_assigned :events, :event, with: EventDecorator
+  layout :determine_layout
+
+  def instances
+    # Pass a block into the EventHandler mixin's method, which is yielded to at the end of the method
+    super do
+      # If the event has an external ticketing url, redirect to it instead of rendering a list of instances
+      # n.b. pretty obviously you'll need to define has_external_ticketing_url?() and external_ticketing_url() on your model
+      if @event.has_external_ticketing_url?
+        redirect_to @event.external_ticketing_url and return
+      end
+
+      # If the event only has 1 instance, it seems a bit mean to list that instance and make the user click again; go straight to the book_instance method
+      if @event.instances.count == 1
+        redirect_to action: :book_instance, instance_id: @event.instances.first.meta_attributes[:spektrix_id] and return
+      end
+
+    end
+  end
+
+  private
+  def determine_layout
+    case action_name.to_sym
+      when :show
+        "templates/event_detail"
+      when :instances
+        "templates/instance_list"
+      when :book_instance
+        "templates/iframe_wide"
+    end
+  end
+end
+```
+
+## Model Mixins
+These are `include`d automatically when you use this gem.
+
+
+### Rooftop::Rails::Events::Cache
+A mixin added to the Rooftop::Events::Event to cache / expire it.
+
+### Rooftop::Rails::Events::InstanceCache
+The same as `Rooftop::Rails::Events::Cache` but for instances. Allows you to receive a webhook for just an instance and be able to clear the cache for its associated `Event`.
+
+### Rooftop::Rails::Events::Scopes
+Handy scopes for dealing with events - finding after a date, between dates, in the future etc.
+
+## Object Decorators
+We use a lot of [Draper](https://github.com/drapergem/draper) as our decorator pattern at [Error Agency](https://error.agency). So there are some mixins you add to your EventDecorator to provide utility methods for use in views.
+
+```
+#in your project
+class EventDecorator < Draper::Decorator
+    include Rooftop::Rails::Events::Decorators
+end
+```
+
+## Controller mixin for Event collections
+The standard pattern we've found works well for Rooftop is to have a PagesController with mixins which check the template of the page you're rendering, and makes requests to get collections of objects you'll need.
+
+```
+class PagesController < ApplicationController
+    include Rooftop::Rails::Events::EventCollections 
+end
+```
+You get a bunch of stuff for free with this:
+
+* Rooftop events in the future will be returned as a collection called @events by default
+* if you pass in query params, you can filter these:
+  *  `q` will do a free-text search
+  *  `from` will take an dd-mm-yyyy date string and return things happening on or after that date
+  *  `to` will work likewise, in reverse
+ 
+### Customising querystring filters
+You might want to filter by something else. That's relatively easy.
+
+```
+class PagesController < ApplicationController
+    include Rooftop::Rails::Events::EventCollections
+    self.add_event_filter :genre, ->(events,params) {
+        # add something here which returns a collection when genre is passed in, for example
+        # very important - you must return something here
+        if params[:genre].present?
+            events.with_genre(params[:genre])
+        else
+            events
+        end
+    }
+end
+```
+
+
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'rooftop-rails-events'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install rooftop-rails-events
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/rooftop-rails-events. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+task :default => :spec

data/app/controllers/concerns/rooftop/rails/events/event_collections.rb

@@ -0,0 +1,88 @@
+module Rooftop
+  module Rails
+    module Events
+      # A mixin for your PagesController, to get events based on your page template. If the appropriate template is present in the response for a page from Rooftop, we generate an @events instance var with the events. @events is filtered according to some basic things like to and from date, if the params are present.
+      module EventCollections
+        extend ActiveSupport::Concern
+
+        included do
+          before_action :get_index_events, only: :show, if: :template_matches?
+        end
+
+        class_methods do
+          attr_reader :event_index_template, :event_filters, :filter_keys
+          def event_index_template=(template)
+            @event_index_template = template.to_s
+          end
+
+          # A method to allow us to filter on extra things from the command line (e.g. genre)
+          # To use in your controller:
+          # self.add_event_filter :genre, ->(events) {
+          #   return the matching set here
+          # }
+
+          def add_event_filter(key,filter)
+            if filter.is_a?(Proc)
+              @filter_keys ||= []
+              @event_filters ||= []
+              @filter_keys << key
+              @event_filters << filter
+            else
+              raise ArgumentError, "add_event_filter takes a proc which is evaluated in the filter_events method, and a params key to check for"
+            end
+          end
+        end
+
+        private
+        def template_matches?
+          self.class.event_index_template.present? && defined?(@page) && @page.template.present? && @page.template.underscore == self.class.event_index_template
+        end
+
+        def get_index_events
+          @events = filter_events(Rooftop::Events::Event.in_future).sort_by {|e| e.event_instance_dates[:first]} rescue []
+        end
+
+        def has_filter_keys?
+          fixed_filter_keys = ["from", "to", "q"]
+          self.class.filter_keys ||= []
+          all_filter_keys = fixed_filter_keys + self.class.filter_keys.collect(&:to_s)
+          (params.keys & all_filter_keys).any? && all_filter_keys.collect {|k| params[k].present?}.any?
+        end
+
+        def filter_events(events)
+          return events unless has_filter_keys?
+
+          # Build a collection of collections, which we will intersect to get only ones which match all
+          all_match = []
+
+
+          if params[:from].present? && params[:to].present?
+            from = DateTime.parse(params[:from]) rescue DateTime.now
+            to = DateTime.parse(params[:to]) rescue DateTime.now
+            all_match << events.showing_between(from,to)
+          elsif params[:from].present?
+            from = DateTime.parse(params[:from]) rescue DateTime.now
+            all_match << events.showing_on(from)
+          end
+
+          # free-text search
+          if params[:q].present?
+            all_match << events.matching_query(params[:q])
+          end
+
+          # Iterate over any other filters supplied in procs
+          if self.class.event_filters.present?
+            self.class.event_filters.each do |filter|
+              all_match << filter.call(events, params)
+            end
+          end
+
+          # intersect all the alls
+          all_match.inject(:&)
+
+        end
+      end
+    end
+  end
+
+end

data/app/controllers/concerns/rooftop/rails/events/event_handler.rb

@@ -0,0 +1,49 @@
+module Rooftop
+  module Rails
+    module Events
+      module EventHandler
+        # A module for showing an event and listing event instances. Note that we don't have an index endpoint in here - for that we use a template in the pages controller, and a mixin to get a collection of events if you're hitting that template. See Rooftop::Rails::Events::EventCollections for that.
+        extend ActiveSupport::Concern
+
+        def show
+          @event = Rooftop::Events::Event.where(
+            slug: params[:id],
+            per_page: 1,
+            include_embedded_resources: true,
+            instances_per_page: -1,
+            no_filter: [
+              :include_embedded_resources,
+              :instances_per_page
+            ]).first
+          if @event.nil?
+            raise Rooftop::RecordNotFoundError, "No event with slug #{params[:id]} found"
+          end
+
+          @instances = @event.embedded_instances
+
+          yield if block_given?
+        end
+
+        def instances
+          @event = Rooftop::Events::Event.where(slug: params[:event_id]).first
+
+          @instances = Rooftop::Events::Instance.all(_event_id: @event.id, include_embedded_resources: true).sort_by {|i| DateTime.parse(i.meta_attributes[:availability][:starts_at])}.to_a.reject! {|e| DateTime.parse(e.meta_attributes[:availability][:starts_at]) < DateTime.now}
+
+          @event_details = EventDetailDecorator.new(@event, @instances)
+
+          yield if block_given?
+        end
+
+        def book_instance
+          @event = Rooftop::Events::Event.where(slug: params[:event_id]).first
+          @instance_id = params[:instance_id]
+
+          yield if block_given?
+        end
+
+
+      end
+    end
+
+  end
+end

data/app/controllers/concerns/rooftop/rails/events/event_search.rb

@@ -0,0 +1,10 @@
+module Rooftop
+  module Rails
+    module Events
+      module EventSearch
+
+
+      end
+    end
+  end
+end

data/app/models/concerns/rooftop/rails/events/booking_information.rb

@@ -0,0 +1,22 @@
+module Rooftop
+  module Rails
+    module Events
+      module BookingInformation
+        extend ActiveSupport::Concern
+
+        def date_from
+          if event_instance_dates[:first].present?
+            DateTime.parse(event_instance_dates[:first])
+          end
+        end
+
+        def date_to
+          if event_instance_dates[:last].present?
+            DateTime.parse(event_instance_dates[:last])
+          end
+        end
+
+      end
+    end
+  end
+end

data/app/models/concerns/rooftop/rails/events/cache.rb

@@ -0,0 +1,44 @@
+module Rooftop
+  module Rails
+    module Events
+      module Cache
+        def self.included(base)
+          base.extend ClassMethods
+          if ::Rails.configuration.action_controller.perform_caching
+            base.send(:alias_method_chain, :related_events, :caching)
+          end
+
+          base.class_eval do
+            class << self
+              alias_method_chain :expire_cache_for, :related
+            end
+          end
+
+        end
+
+        def related_cache_key
+          "#{self.class.related_cache_key_base}/#{id}"
+        end
+
+
+        def related_events_with_caching(opts = {})
+          Rails.cache.fetch(related_cache_key) do
+            related_events_without_caching(opts)
+          end
+        end
+
+        module ClassMethods
+          def related_cache_key_base
+            "#{cache_key_base}/related"
+          end
+
+          def expire_cache_for_with_related(*args)
+            ::Rails.cache.delete_matched("#{related_cache_key_base}*")
+            expire_cache_for_without_related(args)
+          end
+        end
+
+      end
+    end
+  end
+end

data/app/models/concerns/rooftop/rails/events/instance_cache.rb

@@ -0,0 +1,76 @@
+module Rooftop
+  module Rails
+    module Events
+      module InstanceCache
+        def self.included(base)
+          base.extend ClassMethods
+
+          base.class_eval do
+            class << self
+              alias_method_chain :expire_cache_for, :parent
+            end
+          end
+
+        end
+
+        def parent_event_id_cache_key
+          "#{self.class.parent_event_id_cache_key_base}/#{id}"
+        end
+
+        # Cache the parent ID into a key
+        def cache_parent_id
+          if self.respond_to?(:event_id)
+            Rails.cache.write(parent_event_id_cache_key, self.event_id)
+          end
+        end
+
+        module ClassMethods
+
+          def parent_event_id_cache_key_base
+            "#{cache_key_base}/parent_event"
+          end
+
+          def expire_cache_for_with_parent(*args)
+            ids = args.collect {|a| a.respond_to?(:id) ? a.id : a}.flatten.collect(&:to_i)
+
+            #Parent events IDs are stored in a series of keys, one for each instance id. We get all the event ID keys into an array
+            parent_event_id_cache_keys = get_parent_id_cache_keys(ids)
+            # then we get read_multi to get them all from the cache, and derive a unique set of event ids
+
+            event_ids = get_event_ids_from_cache(parent_event_id_cache_keys)
+            if event_ids.count != ids.count #we have some missing event IDs, so we need to do an expensive lookup
+              Rooftop::Events::Event.all(
+                include_embedded_resources: true,
+                instances_per_page: -1,
+                no_filter: [
+                  :include_embedded_resources,
+                  :instance_per_page
+                ]
+              )
+            end
+
+            # Now we've hopefully cached them all, do the cache lookup again
+
+            get_event_ids_from_cache(parent_event_id_cache_keys).each do |event_id|
+              Rooftop::Events::Event.expire_cache_for(event_id.to_i)
+            end
+
+            #then we do the normal cache expiry
+            expire_cache_for_without_parent(*args)
+          end
+
+          private
+          def get_parent_id_cache_keys(ids)
+            ids.collect {|id| "#{parent_event_id_cache_key_base}/#{id}"}
+          end
+
+          def get_event_ids_from_cache(keys)
+            Rails.cache.read_multi(*keys).collect {|key, event_id| event_id}.uniq
+          end
+        end
+
+      end
+
+    end
+  end
+end

data/app/models/concerns/rooftop/rails/events/scopes.rb

@@ -0,0 +1,48 @@
+module Rooftop
+  module Rails
+    module Events
+      module Scopes
+        extend ActiveSupport::Concern
+
+        included do
+
+          scope :after_date, ->(date) {
+            where(
+              meta_key: :last_event_instance,
+              meta_query: {
+                key: :last_event_instance,
+                value: date,
+                compare: '>='
+              },
+              orderby: :meta_value_num,
+              order: :asc
+            )
+          }
+
+          scope :in_future, -> {
+            after_date(Date.today)
+          }
+
+          scope :showing_between, ->(from,to) {
+            to_a.select { |e|
+              from.beginning_of_day <= DateTime.parse(e.event_instance_dates[:last]) && to.end_of_day >=  DateTime.parse(e.event_instance_dates[:first])
+            }
+          }
+
+          scope :showing_on, ->(date) {
+            showing_between(date,date)
+          }
+
+          scope :showing_from, ->(date) {
+            to_a.select {|e| date.beginning_of_day >=  DateTime.parse(e.event_instance_dates[:first])}
+          }
+
+          scope :matching_query, ->(q) {
+            search(q)
+          }
+        end
+
+      end
+    end
+  end
+end

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "rooftop/rails/events"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/rooftop/rails/events.rb

@@ -0,0 +1,14 @@
+require 'require_all'
+require 'rooftop'
+require 'rooftop/rails'
+
+require "rooftop/rails/events/version"
+require "rooftop/rails/events/engine"
+require "rooftop/rails/events/decorators"
+require "rooftop/rails/events/instance_decorators"
+module Rooftop
+  module Rails
+    module Events
+    end
+  end
+end

data/lib/rooftop/rails/events/decorators.rb

@@ -0,0 +1,18 @@
+require_rel 'decorators'
+module Rooftop
+  module Rails
+    module Events
+      module Decorators
+
+        def self.included(base)
+          raise StandardError, "Rooftop::Rails::Events::Decorators expects to be mixed into a Draper decorator" unless defined?(Draper) && base.ancestors.include?(Draper::Decorator)
+          base.send(:include, Rooftop::Rails::Events::Content)
+          base.send(:include, Rooftop::Rails::Events::Cast)
+          base.send(:include, Rooftop::Rails::Events::Media)
+          base.send(:include, Rooftop::Rails::Events::Reviews)
+          base.send(:include, Rooftop::Rails::Events::Times)
+        end
+      end
+    end
+  end
+end

data/lib/rooftop/rails/events/decorators/cast.rb

@@ -0,0 +1,25 @@
+module Rooftop
+  module Rails
+    module Events
+      module Cast
+
+        def cast_members
+          if object.has_field?(:cast, Array)
+            object.fields.cast.collect{|cm| PersonDecorator.new(cm)}
+          else
+            []
+          end
+        end
+
+        def creatives
+          if object.has_field?(:creatives, Array)
+            object.fields.creatives.collect{|cm| PersonDecorator.new(cm)}
+          else
+            []
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/rooftop/rails/events/decorators/content.rb

@@ -0,0 +1,21 @@
+module Rooftop
+  module Rails
+    module Events
+      module Content
+
+        def title
+          object.title.html_safe
+        end
+
+        def content
+          h.parse_content object.fields.content
+        end
+
+        def excerpt
+          h.parse_content object.fields.excerpt
+        end
+
+      end
+    end
+  end
+end

data/lib/rooftop/rails/events/decorators/event_detail_decorator.rb

@@ -0,0 +1,142 @@
+module Rooftop
+  module Rails
+    module Events
+      class EventDetailDecorator
+        attr_reader :grouped, :price_lists, :date_ranges, :month_ranges, :accessibility, :instances, :month_ranges_with_sorted_instances
+
+        def initialize(event, instances)
+          @instances = instances ? instances : Rooftop::Events::Instance.all(event_id: event.id,include_embedded_resources: true)
+
+          price_list_ids = @instances.collect{|i| i.price_list_id.to_i}.sort.uniq
+          @price_lists = Rooftop::Events::PriceList.where(post__in: price_list_ids,include_embedded_resources: true).to_a
+
+          @date_ranges = grouped_by_performance_type!
+
+          @accessibility = grouped_by_access_feature!
+
+          @month_ranges = grouped_by_month!
+
+          @month_ranges_with_sorted_instances = grouped_by_month_with_sorted_instances
+        end
+
+        # group events by their performance types.
+        # type being, perview, evening, matinee, or other (special)
+        def grouped_by_performance_type!
+          performance_types = {'preview' => [], 'special_performance' => []}
+
+          @instances.each do |instance|
+            performance_type = instance.meta_attributes["time_of_day"]
+            performance_types[performance_type] ||= []
+
+            if instance.meta_attributes["preview"]=="true"
+              performance_types["preview"].push(instance)
+            end
+
+            if instance.meta_attributes.has_key?("time_of_day")
+              time_of_day = instance.meta_attributes["time_of_day"]
+              performance_types[time_of_day] ||= []
+
+              performance_types[time_of_day].push(instance)
+            else
+              performance_types['special_performance'].push(instance)
+            end
+          end
+
+          performance_types.each do |type, instances|
+            performance_types[type] = slice_instances_by_date(instances.reverse)
+          end
+
+          Hash[performance_types.reject{|k,v| k.nil? || k.empty? || v.empty?}.sort]
+        end
+
+        # Group the event instances by any known available accessibility facilities
+        #
+        def grouped_by_access_feature!
+          groups = {'audio_described_performance' => [], 'captioned_performance' => [], 'signed_performance' => [], 'touch_tour' => [], 'relaxed_performance' => [], 'talk_back' => []}
+
+          @instances.each do |instance|
+            instance_types = instance.meta_attributes.select{|attr_key, attr_value| groups.keys.include?(attr_key) && attr_value=="true"}.keys
+
+            if instance_types.any?
+              instance_types.each do |type|
+                groups[type].push(instance)
+              end
+            end
+          end
+
+          groups.each do |type, instances|
+            groups[type] = slice_instances_by_date(instances.reverse)
+          end
+
+          groups
+        end
+
+        def grouped_by_month!
+          sorted_instances = @instances.sort_by{|instance| DateTime.parse(instance.meta_attributes[:availability][:starts_at]).at_midnight}
+
+          sorted_instances.group_by do |instance|
+            DateTime.parse(instance.meta_attributes[:availability][:starts_at]).strftime('%B %Y')
+          end
+        end
+
+        def grouped_by_month_with_sorted_instances
+          sorted_instances = @instances.sort_by{|instance| DateTime.parse(instance.meta_attributes[:availability][:starts_at])}
+          sorted_instances.group_by do |instance| DateTime.parse(instance.meta_attributes[:availability][:starts_at]).strftime('%B %Y') end
+        end
+
+        def today
+          for_date(Date.today)
+        end
+
+        def tomorrow
+          for_date(Date.tomorrow)
+        end
+
+        def for_date(date)
+          @instances.sort_by{|instance| DateTime.parse(instance.meta_attributes[:availability][:starts_at])}.select {|instance| DateTime.parse(instance.meta_attributes[:availability][:starts_at]).to_date == date}
+        end
+
+
+
+        private
+
+        # sort the given instances and return a grouped result-set, splitting on sets of event instances that have > 1 day between them.
+        # for example, given an array of instances with the dates:
+        #
+        # [1st, 2nd, 3rd, 8th, 9th, 15th]
+        #
+        # we should return a grouped array:
+        #
+        # [[1st, 2nd, 3rd], [8th], [9th], [15th]]
+        #
+        # We can then iterate over these arrays and present the data (1st - 3rd, 8th, 9th and 15th)
+        #
+        def slice_instances_by_date(instances)
+          instance_dates = instances.collect{|i| instance_date(i)}.sort.uniq
+          instance_dates = instance_dates.slice_when{|prev, curr| prev != curr-1.day}.to_a
+
+          group = {}
+
+          instance_dates.each_with_index do |date_range, i|
+            date_range.each do |date|
+              group[i] ||= []
+              group[i].push(instances.select{|i| instance_date(i)==date})
+            end
+          end
+
+          group.inject({}) do |h,(k,v)|
+            h[k] = v.flatten unless v.empty?
+            h
+          end.values.reject(&:empty?)
+        end
+
+        # return the event instance (ignores the time)
+        #
+        def instance_date(instance)
+          Time.parse(instance.meta_attributes[:availability][:starts_at]).at_midnight
+        end
+      end
+
+    end
+  end
+end

data/lib/rooftop/rails/events/decorators/instance_decorator.rb

@@ -0,0 +1,63 @@
+module Rooftop
+  module Rails
+    module Events
+      module InstanceDecorator
+
+        def start_date_object
+          DateTime.parse(object.meta_attributes[:availability][:starts_at])
+        end
+
+        def start_date
+          start_date_object.strftime("%a %-d %-b")
+        end
+
+        def start_time
+          start_date_object.strftime("%l:%M%P")
+        end
+
+
+        def price(event_details)
+          price_list = event_details.price_lists.find{|pl| pl.id == object.price_list_id.to_i}
+
+          if price_list
+            price_list_range(price_list)
+          else
+            ""
+          end
+        end
+
+        def limited_availability?
+          available = event_instance_meta[:availability][:seats_available].to_i
+          capacity  = event_instance_meta[:availability][:seats_capacity].to_i
+
+          available <= capacity/10
+        end
+
+        def in_future?
+          DateTime.parse(object.event_instance_meta[:availability][:starts_at]).future?
+        end
+
+        def in_past?
+          !in_future?
+        end
+
+        def bookable?
+          return false if in_past?
+
+          available = event_instance_meta[:availability][:seats_available].to_i
+          available > 0
+        end
+
+        def is_public_dress_rehearsal?
+          event_instance_meta.has_key?(:public_dress_rehearsal) && event_instance_meta[:public_dress_rehearsal]=="true"
+        end
+
+        def price_list_range(price_list)
+          prices = price_list.prices.collect{|p| p.event_price_meta[:ticket_price].to_f}.flatten.sort
+          [prices[0], prices[-1]].uniq.sort
+        end
+      end
+
+    end
+  end
+end

data/lib/rooftop/rails/events/decorators/media.rb

@@ -0,0 +1,114 @@
+module Rooftop
+  module Rails
+    module Events
+      module Media
+
+        # Images. Requires ACF setup.
+
+        def has_hero_image?
+          has_field?(:hero_image) && fields.hero_image.present?
+        end
+
+        def has_poster_image?
+          has_field(:poster_image) && fields.poster_image.present?
+        end
+
+        def has_list_image?
+          has_field?(:event_list_image) && fields.event_list_image.present?
+        end
+
+        def hero_image
+          has_hero_image? ? fields.hero_image[:sizes][:large] : nil
+        end
+
+        def header_image
+          if has_hero_image?
+            hero_image
+          else
+            'https://placeholdit.imgix.net/~text?txtsize=33&txt=350×150&w=1200&h=670'
+          end
+        end
+
+        def list_image
+          if has_list_image?
+            fields.event_list_image[:sizes][:medium]
+          elsif has_hero_image?
+            hero_image
+          end
+        end
+
+        def poster_image
+          if has_poster_image?
+            fields.poster_image[:sizes][:medium]
+          end
+        end
+
+        # Media. Requires ACF.
+
+        def media
+          if object.has_field?(:media, Array) && object.fields.media.any?
+            object.fields.media.collect do |media_item|
+              collection = Rooftop::Content::Collection.new(media_item.collect(&:to_h))
+
+              next unless collection.video_or_image.present?
+
+              if collection.video_or_image == "video" && collection.youtube_url.present?
+                collection << Rooftop::Content::Field.new({name: "youtube_id", value: collection.youtube_url.match(/(youtu.be\/(\S+)$|v=(\S+))/).to_a.compact.last})
+              end
+              collection
+            end
+          else
+            []
+          end
+        end
+
+        def media_collection
+          media.collect do |item|
+            if item.video_or_image == 'image'
+              next unless item.image.is_a?(Hash)
+              {
+                title: item.caption.html_safe,
+                thumbnail: item.image[:sizes][:medium],
+                href: item.image[:sizes][:large],
+                media_type: item.video_or_image,
+              }
+            elsif item.video_or_image == "video"
+              {
+                title: item.caption.html_safe,
+                href: item.youtube_url,
+                type: 'text/html',
+                youtube: item.youtube_id,
+                thumbnail: '//img.youtube.com/vi/' + item.youtube_id + '/0.jpg',
+                poster: '//img.youtube.com/vi/' + item.youtube_id + '/0.jpg',
+                media_type: item.video_or_image,
+              }
+            end
+          end
+        end
+
+        def media_json
+          media_collection.compact.to_json.html_safe
+        end
+
+        def has_trailer?
+          has_field?(:trailer) && fields.trailer.present?
+        end
+
+        def trailer
+          if has_trailer?
+            "https://www.youtube.com/embed/" + fields.trailer.partition('=').last + "?rel=0&amp;showinfo=0"
+          end
+        end
+
+        def media_images
+          media.select {|m| m.video_or_image == 'image'}
+        end
+
+        def media_videos
+          media.select {|m| m.video_or_image == 'video'}
+        end
+      end
+
+    end
+  end
+end

data/lib/rooftop/rails/events/decorators/person_decorator.rb

@@ -0,0 +1,47 @@
+module Rooftop
+  module Rails
+    module Events
+      class PersonDecorator
+        attr_reader :attributes, :object, :advanced_fields
+
+        def initialize(relationship)
+          @attributes = {}
+          @object = relationship
+
+          @object.each do |key, value|
+            @attributes[key] = value
+            self.class.send(:attr_accessor, "#{key}")
+            instance_variable_set "@#{key}", value
+          end
+
+          if relationship.has_key?(:advanced) && relationship[:advanced].first && relationship[:advanced].first
+            @advanced_fields = Rooftop::Content::Collection.new(relationship[:advanced].collect{|adv| adv[:fields].first})
+
+            relationship[:advanced].collect{|adv| adv[:fields]}.flatten.each do |field|
+              self.class.send(:attr_accessor, "#{field[:name]}_field")
+              instance_variable_set("@#{field[:name]}_field", field[:value])
+            end
+          end
+        end
+
+        def role
+          self.respond_to?(:role_field) ? self.role_field : ''
+        end
+
+        def character
+          self.respond_to?(:character_played_field) ? self.character_played_field : ''
+        end
+
+        def image
+          (self.respond_to?(:headshot_field) && self.headshot_field.is_a?(Hash)) ? self.headshot_field[:sizes][:medium] : ''
+        end
+
+        def content
+          h.parse_content(self.fields.content).html_safe
+        end
+
+      end
+
+    end
+  end
+end

data/lib/rooftop/rails/events/decorators/reviews.rb

@@ -0,0 +1,33 @@
+module Rooftop
+  module Rails
+    module Events
+      module Reviews
+
+        # Reviews. Requires ACF setup.
+
+        def has_featured_review?
+          has_field?(:featured_review) && fields.featured_review.present?
+        end
+
+        def has_reviews?
+          has_field?(:reviews) && fields.reviews.present?
+        end
+
+        def featured_review
+          has_featured_review? ? Rooftop::Content::Collection.new(fields.featured_review.first[:advanced].first[:fields]) : nil
+        end
+
+        def reviews
+          if has_reviews?
+            fields.reviews.collect do |review|
+              Rooftop::Content::Collection.new(review[:advanced].first[:fields])
+            end
+          else
+            return []
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/rooftop/rails/events/decorators/times.rb

@@ -0,0 +1,39 @@
+module Rooftop
+  module Rails
+    module Events
+      module Times
+
+        def has_instance_availabilities?
+          respond_to?(:event_instance_availabilities) && event_instance_availabilities.size>0
+        end
+
+        def date_range
+          dates = event_instance_availabilities.first.values.collect{|instance| DateTime.parse(instance[:starts_at])}.sort
+          range = [dates[0], dates[-1]].uniq
+        end
+
+        def has_running_time?
+          meta_attributes[:duration].present?
+        end
+
+        def running_time
+          if has_running_time?
+            t = meta_attributes[:duration].to_i
+            mm, ss = t.divmod(60)            #=> [4515, 21]
+            hh, mm = mm.divmod(60)           #=> [75, 15]
+            dd, hh = hh.divmod(24)           #=> [3, 3]
+            time = ""
+            if mm == 0
+              time = "About #{h.pluralize(hh,'hour')}"
+            elsif hh == 0
+              time = "About #{h.pluralize(mm,'minute')}"
+            else
+              time = "About #{h.pluralize(hh, 'hour')} and #{h.pluralize(mm,'minute')}"
+            end
+            time
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rooftop/rails/events/engine.rb

@@ -0,0 +1,31 @@
+module Rooftop
+  module Rails
+    module Events
+      class Engine < ::Rails::Engine
+
+        isolate_namespace Rooftop::Rails::Events
+
+        config.before_initialize do
+
+        end
+
+        initializer "add_helpers" do
+          ActiveSupport.on_load(:action_view) do
+            # include Rooftop::Rails::Events::YourHelper
+
+          end
+        end
+
+        config.to_prepare do
+          ::Rails.application.eager_load!
+          Rooftop::Events::Event.send(:include, Rooftop::Rails::Events::Cache)
+          Rooftop::Events::Event.send(:include, Rooftop::Rails::Events::Scopes)
+          # Rooftop::Events::Instance.send(:include, Rooftop::Rails::Events::InstanceCache)
+          Rooftop::Events::Instance.send(:include, Rooftop::Rails::Events::BookingInformation)
+        end
+
+      end
+    end
+
+  end
+end

data/lib/rooftop/rails/events/instance_decorators.rb

@@ -0,0 +1,13 @@
+require_rel "./decorators"
+module Rooftop
+  module Rails
+    module Events
+      module InstanceDecorators
+        def self.included(base)
+          raise StandardError, "Rooftop::Rails::Events::InstanceDecorators expects to be mixed into a Draper decorator" unless defined?(Draper) && base.ancestors.include?(Draper::Decorator)
+          base.send(:include, Rooftop::Rails::Events::InstanceDecorator)
+        end
+      end
+    end
+  end
+end

data/lib/rooftop/rails/events/version.rb

@@ -0,0 +1,7 @@
+module Rooftop
+  module Rails
+    module Events
+      VERSION = "0.1.9"
+    end
+  end
+end

data/rooftop-rails-events.gemspec

@@ -0,0 +1,28 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'rooftop/rails/events/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "rooftop-rails-events"
+  spec.version       = Rooftop::Rails::Events::VERSION
+  spec.authors       = ["Ed Jones"]
+  spec.email         = ["ed@errorstudio.co.uk"]
+
+  spec.summary       = %q{Quickly add events to your Rails website with Rooftop CMS.}
+  spec.description   = %q{This library integrates with Rooftop CMS's events plugin to make it easy to add events to your site.}
+  spec.homepage      = "https://github.com/rooftopcms/rooftop-rails-events"
+  spec.license       = "GPLv3"
+
+    spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.11"
+  spec.add_development_dependency "rake", "~> 10.0"
+
+  spec.add_dependency "require_all"
+  spec.add_dependency "rooftop-rails"
+
+end

metadata

@@ -0,0 +1,129 @@
+--- !ruby/object:Gem::Specification
+name: rooftop-rails-events
+version: !ruby/object:Gem::Version
+  version: 0.1.9
+platform: ruby
+authors:
+- Ed Jones
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2016-09-27 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.11'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.11'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: require_all
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rooftop-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: This library integrates with Rooftop CMS's events plugin to make it easy
+  to add events to your site.
+email:
+- ed@errorstudio.co.uk
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- app/controllers/concerns/rooftop/rails/events/event_collections.rb
+- app/controllers/concerns/rooftop/rails/events/event_handler.rb
+- app/controllers/concerns/rooftop/rails/events/event_search.rb
+- app/models/concerns/rooftop/rails/events/booking_information.rb
+- app/models/concerns/rooftop/rails/events/cache.rb
+- app/models/concerns/rooftop/rails/events/instance_cache.rb
+- app/models/concerns/rooftop/rails/events/scopes.rb
+- bin/console
+- bin/setup
+- lib/rooftop/rails/events.rb
+- lib/rooftop/rails/events/decorators.rb
+- lib/rooftop/rails/events/decorators/cast.rb
+- lib/rooftop/rails/events/decorators/content.rb
+- lib/rooftop/rails/events/decorators/event_detail_decorator.rb
+- lib/rooftop/rails/events/decorators/instance_decorator.rb
+- lib/rooftop/rails/events/decorators/media.rb
+- lib/rooftop/rails/events/decorators/person_decorator.rb
+- lib/rooftop/rails/events/decorators/reviews.rb
+- lib/rooftop/rails/events/decorators/times.rb
+- lib/rooftop/rails/events/engine.rb
+- lib/rooftop/rails/events/instance_decorators.rb
+- lib/rooftop/rails/events/version.rb
+- rooftop-rails-events.gemspec
+homepage: https://github.com/rooftopcms/rooftop-rails-events
+licenses:
+- GPLv3
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Quickly add events to your Rails website with Rooftop CMS.
+test_files: []