rooftop-spektrix_sync 0.0.2.15

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: bb6fd037cce26a2e0f142bf431ef45fc4c1989a9
+  data.tar.gz: a7a3bb0ae24fe58aa5c0d8af3b3f51e8d8a2091e
+SHA512:
+  metadata.gz: b4d00862c48da22fc7cb8dface4fba4b0a9546d2ce964427d9dc59a83a715cf9073f3f21e25f05b23cd89151cf454b20d401a8c97db3d38232d5a36c9ec98ec4
+  data.tar.gz: 129902d9ea10654f3d6737bc759154306256286a408810a15c12dd8bbc8c9c044f7031b0a3ed4e1ea34891e366ee5b9d07d960815a7e089db29fa17331d2951c

data/.gitignore

@@ -0,0 +1,23 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log
+.idea

data/.ruby-gemset

@@ -0,0 +1 @@
+rooftop-spektrix_sync

data/.ruby-version

@@ -0,0 +1 @@
+2.2.3

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2016 Ed Jones
+
+MIT License
+
+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,29 @@
+# Rooftop::SpektrixSync
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'rooftop-spektrix_sync'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install rooftop-spektrix_sync
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/rooftop-spektrix_sync/fork )
+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. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+

data/lib/rooftop/spektrix_sync/lib/event_sync.rb

@@ -0,0 +1,92 @@
+module Rooftop
+  module SpektrixSync
+    class EventSync
+      attr_reader :spektrix_event,
+                  :rooftop_event,
+                  :rooftop_price_lists,
+                  :logger
+
+      def initialize(spektrix_event, sync_task)
+        @rooftop_events = sync_task.rooftop_events
+        @spektrix_events = sync_task.spektrix_events
+        @logger = sync_task.logger
+        @spektrix_event = spektrix_event
+        @rooftop_event = @rooftop_events.find {|e| e.meta_attributes[:spektrix_id].try(:to_i) == @spektrix_event.id.to_i}
+        @rooftop_price_lists = sync_task.rooftop_price_lists
+      end
+
+      def sync_to_rooftop
+        begin
+          # find the event
+          @rooftop_event ||= Rooftop::Events::Event.new({
+            title: @spektrix_event.title,
+            content: {basic: {content: @spektrix_event.description}},
+            meta_attributes: {},
+            status: nil
+          })
+          sync()
+        rescue => e
+          @logger.error(e.to_s)
+        end
+      end
+
+      def sync
+        update_meta_attributes
+        update_on_sale
+        if @rooftop_event.persisted?
+          # Ensure we're not overwriting newer stuff in RT with older stuff from this sync by
+          # removing the title and content if this is a PUT request (i.e. it already exists in RT)
+          @rooftop_event.restore_title!
+          @rooftop_event.restore_content!
+          @rooftop_event.restore_slug!
+          @rooftop_event.restore_link!
+          @rooftop_event.restore_event_instance_availabilities!
+        end
+
+        if @rooftop_event.save!
+          @logger.debug("Saved event: #{@rooftop_event.title} #{@rooftop_event.id}")
+          sync_instances
+        end
+      end
+
+      private
+      def update_meta_attributes
+        @rooftop_event.meta_attributes ||= {}
+        @rooftop_event.meta_attributes[:spektrix_id] = @spektrix_event.id
+        @spektrix_event.custom_attributes.each do |key, value|
+          @rooftop_event.meta_attributes[key] = value
+        end
+        @rooftop_event.meta_attributes[:duration] = @spektrix_event.duration.to_i
+      end
+
+      def update_on_sale
+        if SpektrixSync.configuration.present? && SpektrixSync.configuration[:on_sale_if_new_event]
+          @rooftop_event.status = @spektrix_event.is_on_sale ? 'publish' : 'draft'
+        else
+          @rooftop_event.restore_status! #don't send status with the request
+        end
+      end
+
+      def sync_instances
+        @rooftop_instances = @rooftop_event.instances.to_a
+        @spektrix_instances = @spektrix_event.instances.to_a
+        @spektrix_instances.each_with_index do |instance, i|
+          begin
+            tries ||= 2
+            instance_sync = Rooftop::SpektrixSync::InstanceSync.new(instance, self)
+            instance_sync.sync
+          rescue
+            retry unless (tries -= 1 ).zero?
+          end
+        end
+
+        update_event_metadata unless @rooftop_instances.empty?
+      end
+
+      def update_event_metadata
+        @logger.debug("Saved event instances. Updating event metadata")
+        Rooftop::Events::Event.post("#{@rooftop_event.class.collection_path}/#{@rooftop_event.id}/update_metadata")
+      end
+    end
+  end
+end

data/lib/rooftop/spektrix_sync/lib/instance_sync.rb

@@ -0,0 +1,76 @@
+module Rooftop
+  module SpektrixSync
+    class InstanceSync
+
+      def initialize(spektrix_instance, event_sync)
+        @spektrix_event = event_sync.spektrix_event
+        @rooftop_event = event_sync.rooftop_event
+        @logger = event_sync.logger
+        @spektrix_instance = spektrix_instance
+        @rooftop_instance = find_rooftop_instance_by_spektrix_id(@spektrix_instance.id) || @rooftop_event.instances.build(status: nil, meta_attributes: {})
+        @rooftop_price_lists = event_sync.rooftop_price_lists
+      end
+
+      def sync
+        # This is a bit of a hack: we have to create a new instance and assign all the attributes from the old one, so it has an _event_id param.
+        if @rooftop_instance.persisted?
+          @rooftop_instance = @rooftop_event.instances.build(@rooftop_instance.attributes)
+          instance_updated = true
+        end
+        update_price
+        if @rooftop_instance.price_list_id.nil?
+          @logger.warn("No price list for Spektrix instance id #{@spektrix_instance.id}")
+          return
+        end
+        update_meta_attributes
+        update_availability
+        update_on_sale
+        if @rooftop_instance.save!
+          @logger.debug("#{instance_updated ? "Updated" : "Created"} Rooftop instance #{@rooftop_instance.id}")
+        end
+      end
+
+      private
+      def find_rooftop_instance_by_spektrix_id(spektrix_id)
+        @rooftop_event.instances.to_a.find {|i| i.meta_attributes[:spektrix_id] == spektrix_id }
+      end
+
+      def update_price
+        @rooftop_instance.price_list_id = @rooftop_price_lists.find {|l| l.meta_attributes[:spektrix_id].to_i == @spektrix_instance.price_list_id}.try(:id)
+      end
+
+      def update_meta_attributes
+        @rooftop_instance.meta_attributes = @spektrix_instance.custom_attributes.merge(spektrix_id: @spektrix_instance.id)
+      end
+
+      def update_on_sale
+        # TODO: there is a bug in the Rooftop events plugin which means that instances which are draft won't be shown
+        # as assigned to the event. Because it's a nested resource, there's no real risk to publishing
+        # the instance immediately.
+        # if SpektrixSync.configuration.present? && SpektrixSync.configuration[:on_sale_if_new_event]
+        #   @rooftop_instance.status = @spektrix_instance.is_on_sale ? 'publish' : 'draft'
+        # else
+        #   @rooftop_instance.status ||= "draft"
+        # end
+        # @rooftop_instance.status = "publish"
+
+        @rooftop_instance.status = @spektrix_instance.is_on_sale=="true" ? 'publish' : 'draft'
+      end
+
+      def update_availability
+        availability = {
+          availability: {
+            starts_at: @spektrix_instance.start.iso8601,
+            stops_at: @spektrix_instance.start.advance(seconds: @rooftop_event.meta_attributes[:duration]),
+            seats_capacity: @spektrix_instance.status.capacity,
+            seats_available: @spektrix_instance.status.available
+          }
+        }
+        @rooftop_instance.title = @rooftop_event.title + ": " + @spektrix_instance.start.strftime("%d %b %Y %H:%M")
+        @rooftop_instance.meta_attributes.merge!(availability)
+      end
+
+
+    end
+  end
+end

data/lib/rooftop/spektrix_sync/lib/price_list_sync.rb

@@ -0,0 +1,110 @@
+module Rooftop
+  module SpektrixSync
+    class PriceListSync
+
+      def initialize(sync_task)
+        @spektrix_price_lists = sync_task.spektrix_price_lists
+        @rooftop_price_lists = sync_task.rooftop_price_lists
+        @rooftop_ticket_types = sync_task.rooftop_ticket_types
+        @rooftop_price_bands = sync_task.rooftop_price_bands
+        @logger = sync_task.logger
+      end
+
+      def run
+        sync_price_lists
+        # Todo we need to put this in a rake task instead of running every time.
+        # remove_orphan_price_lists
+      end
+
+      private
+
+      def sync_price_lists
+        # begin
+          @spektrix_price_lists.each do |spektrix_price_list|
+            # Don't bother syncing a price list where none of the prices have bands.
+            if spektrix_price_list.prices.select {|p| !p.band.nil?}.empty?
+              @logger.warn("Spektrix price list ID #{spektrix_price_list.id} has prices with missing bands.")
+            end
+
+            # find or create a price list
+            @rooftop_price_list = @rooftop_price_lists.find {|l| l.meta_attributes[:spektrix_id] == spektrix_price_list.id.to_s} || Rooftop::Events::PriceList.new(title: spektrix_price_list.id, meta_attributes: {})
+            @rooftop_price_list.meta_attributes[:spektrix_id] = spektrix_price_list.id
+
+            new_price_list = @rooftop_price_list.new?
+            # save the price list to rooftop
+            if @rooftop_price_list.save!
+              @logger.debug("#{new_price_list ? "Created" : "Updated"} price list #{spektrix_price_list.id}")
+              sync_prices(spektrix_price_list, @rooftop_price_list)
+            end
+          end
+        # rescue => e
+        #   @logger.warn(e.to_s)
+        # end
+      end
+
+      def sync_prices(spektrix_price_list, rooftop_price_list)
+        # begin
+          spektrix_price_list.prices.each_with_index do |spektrix_price, i |
+            @logger.debug("syncing price #{i+1} / #{spektrix_price_list.prices.count}")
+            # skip ones without a band
+            if spektrix_price.band.nil?
+              @logger.warn("Spektrix price list ID: #{spektrix_price_list.id}: Price #{spektrix_price.price} with ticket type #{spektrix_price.ticket_type.name} does not have a band")
+              next
+            end
+            current_rooftop_price = find_rooftop_price(rooftop_price_list, spektrix_price)
+            # because updating a price is hard with a nested resource, we'll destroy and recreate with the same settings
+            new_price = rooftop_price_list.prices.build
+            if current_rooftop_price
+              new_price.assign_attributes(current_rooftop_price.attributes)
+            end
+
+            new_price.meta_attributes = {
+              is_band_default: (spektrix_price.is_band_default == "true"),
+              ticket_type_id: find_rooftop_ticket_type(spektrix_price).id,
+              price_band_id: find_rooftop_price_band(spektrix_price).id,
+              ticket_price: spektrix_price.price.to_f
+            }
+
+            new_price.title = "#{spektrix_price.band.name} (£#{new_price.meta_attributes[:ticket_price]})"
+            if new_price.save!
+              @logger.debug("Spektrix price list ID: #{spektrix_price_list.id}: Saved price £#{new_price.meta_attributes[:ticket_price]} with ticket type #{spektrix_price.ticket_type.name} for price band #{spektrix_price.band.name}")
+            end
+          end
+        # rescue => e
+        #   @logger.error(e.to_s)
+        # end
+      end
+
+      def remove_orphan_price_lists
+        begin
+          rooftop_spektrix_ids = @rooftop_price_lists.collect {|l| l.meta_attributes[:spektrix_id].to_i}
+          spektrix_ids = @spektrix_price_lists.collect {|l| l.id.to_i}
+          spektrix_ids_to_remove = (rooftop_spektrix_ids - (rooftop_spektrix_ids & spektrix_ids))
+          rooftop_ids_to_remove = spektrix_ids_to_remove.collect do |spektrix_id|
+            @rooftop_price_lists.find {|l| l.meta_attributes[:spektrix_id].to_i == spektrix_id}.id
+          end
+          Rooftop::Events::PriceList.where(post__in: rooftop_ids_to_remove).each do |pricelist|
+            if pricelist.destroy
+              @logger.debug("Removed rooftop price list #{id} which didn't exist in spektrix")
+            end
+          end
+        rescue => e
+          @logger.error(e.to_s)
+        end
+      end
+
+      def find_rooftop_price(rooftop_price_list,spektrix_price)
+        rooftop_price_list.prices.to_a.find {|p| p.meta_attributes[:spektrix_id] == spektrix_price.id}
+      end
+
+      def find_rooftop_ticket_type(spektrix_price)
+        @rooftop_ticket_types.find {|t| CGI::unescapeHTML(t.title.gsub(/&#8211\;/, '-')) == CGI::unescapeHTML(spektrix_price.ticket_type.name)}
+      end
+
+      def find_rooftop_price_band(spektrix_price)
+        @rooftop_price_bands.find {|b| CGI::unescapeHTML(b.title.gsub(/&#8211\;/, '-')) == CGI::unescapeHTML(spektrix_price.band.name)}
+      end
+
+    end
+  end
+end

data/lib/rooftop/spektrix_sync/lib/sync_task.rb

@@ -0,0 +1,227 @@
+module Rooftop
+  module SpektrixSync
+    class SyncTask
+      attr_accessor :starting_at, :logger, :error_file
+      attr_reader :spektrix_events,
+                  :rooftop_events,
+                  :spektrix_price_lists,
+                  :rooftop_price_lists,
+                  :rooftop_ticket_types,
+                  :rooftop_price_bands,
+                  :options
+
+      PIDPATH = "/tmp/rooftop-spektrix-sync.pid"
+
+      def initialize(starting_at, opts={})
+        begin
+          Rooftop.preview = true
+          if defined?(Rooftop::Rails)
+            Rooftop::Rails.configuration.perform_object_caching = false
+          end
+          @starting_at = starting_at || DateTime.now
+          @logger = SpektrixSync.logger || Logger.new(STDOUT)
+          default_opts = {
+            import_price_bands: false,
+            import_ticket_types: false,
+            import_prices: false,
+            import_events: true,
+            delete_orphan_events: false,
+            accept_empty_rooftop_events: false
+          }
+          @options = default_opts.merge!(opts)
+          @logger.debug("*************************************************************************")
+          @logger.debug("Running with options: #{@options.select {|k,v| k if v}.keys.join(", ")}")
+          @logger.debug("*************************************************************************")
+        rescue => e
+          @logger.error("Couldn't start sync: #{e}")
+        end
+      end
+
+      def fetch_rooftop_and_spektrix_data
+        @logger.debug("Fetching all Spektrix events")
+        @spektrix_events = @spektrix_events.present? ? @spektrix_events : Spektrix::Events::Event.all(instance_start_from: @starting_at.iso8601).to_a
+        if @options[:spektrix_event_id]
+          @spektrix_events = @spektrix_events.select {|e| e.id == @options[:spektrix_event_id].to_s}
+        end
+        @logger.debug("Fetching all Rooftop events")
+        @rooftop_events = Rooftop::Events::Event.all.to_a
+        unless @options[:accept_empty_rooftop_events]
+          raise StandardError, "Rooftop returned an empty set of events which is probably wrong" if @rooftop_events.empty?
+        end
+        @logger.debug("Fetching all Spektrix price lists")
+        @spektrix_price_lists = @spektrix_price_lists.present? ? @spektrix_price_lists : Spektrix::Tickets::PriceList.all.to_a
+        @logger.debug("Fetching all Rooftop Price lists")
+        @rooftop_price_lists = Rooftop::Events::PriceList.all.to_a
+        @logger.debug("Fetching all Rooftop ticket types")
+        @rooftop_ticket_types = Rooftop::Events::TicketType.all.to_a
+        @logger.debug("Fetching all Rooftop price bands")
+        @rooftop_price_bands = Rooftop::Events::PriceBand.all.to_a
+      end
+
+
+
+      def self.run(starting_at=nil, opts={})
+        sync_pid = Process.get_pid(Rooftop::SpektrixSync::SyncTask::PIDPATH)
+
+        if sync_pid && Process.exists?(sync_pid.to_i)
+          raise 'Rooftop::SpektrixSync::SyncRunning'
+        end
+
+        # if we're here, we can create a new pidfile and start the sync
+        Process.create_pid(Rooftop::SpektrixSync::SyncTask::PIDPATH)
+        self.new(starting_at,opts).run
+
+        # remove the pid
+        Process.remove_pidfile(Rooftop::SpektrixSync::SyncTask::PIDPATH)
+      end
+
+      def self.run_events_import(starting_at=nil, event_id=nil)
+        opts = event_id.present? ? {spektrix_event_id: event_id} : {}
+        self.run(starting_at, opts)
+      end
+
+      def self.run_full_import(starting_at=nil)
+        self.run(starting_at, {
+          import_price_bands: true,
+          import_ticket_types: true,
+          import_prices: true,
+          import_events: true,
+          delete_orphan_events: false
+        })
+      end
+
+      def self.run_prices_import(starting_at=nil)
+        self.run(starting_at, {
+          import_price_bands: true,
+          import_ticket_types: true,
+          import_prices: true,
+          import_events: false,
+          delete_orphan_events: false
+        })
+      end
+
+
+      def run
+        begin
+          if @options[:import_price_bands]
+            fetch_rooftop_and_spektrix_data
+            create_or_update_price_bands
+          end
+          if @options[:import_ticket_types]
+            fetch_rooftop_and_spektrix_data
+            create_or_update_ticket_types
+          end
+          if @options[:import_prices]
+            fetch_rooftop_and_spektrix_data
+            create_or_update_prices
+          end
+          if @options[:import_events]
+            fetch_rooftop_and_spektrix_data
+            create_or_update_events
+          end
+          # TODO: the delete method is over-eager. Resolve the issue.
+          # if @options[:delete_orphan_events]
+          #   fetch_event_data
+          #   delete_orphan_spektrix_events
+          # end
+        rescue => e
+          @logger.error(e)
+        end
+
+      end
+
+      private
+
+      def create_or_update_events
+        begin
+          tries ||= 2
+          @spektrix_events.each_with_index do |event, i|
+            @logger.debug("Sync #{i+1} / #{@spektrix_events.length}: #{event.title}")
+            item = EventSync.new(event, self)
+            item.sync_to_rooftop
+          end
+        rescue => e
+          @logger.error(e.to_s)
+          retry unless (tries -= 1).zero?
+        end
+      end
+
+      # Mop up any Rooftop events which don't exist in spektrix, if they have spektrix ID
+      def delete_orphan_spektrix_events
+        @spektrix_event_ids = @spektrix_events.collect {|e| e.id.to_i}
+        @rooftop_event_ids = @rooftop_events.inject({}) do |hash, e|
+          hash[e.id] = e.meta_attributes[:spektrix_id].to_i
+          hash
+        end
+        @rooftop_event_ids.reject! {|k,v| v == 0} #remove events with no spektrix ID; we don't want to remove them.
+        spektrix_ids_to_delete = (@rooftop_event_ids.values - (@rooftop_event_ids.values & @spektrix_event_ids))
+        rooftop_ids_to_delete = @rooftop_event_ids.select {|k,v| spektrix_ids_to_delete.include?(v)}.keys
+        Rooftop::Events::Event.where(post__in: rooftop_ids_to_delete).each do |rooftop_event|
+          title = rooftop_event.title
+          if rooftop_event.destroy
+            @logger.debug("Removed Rooftop event #{title} which doesn't exist in Spektrix")
+          end
+        end
+      end
+
+      def create_or_update_price_bands
+        begin
+          rooftop_bands = Rooftop::Events::PriceBand.all.to_a
+          spektrix_bands = Spektrix::Tickets::Band.all.to_a
+          # create or update existing
+          spektrix_bands.each do |band|
+            @logger.debug("Updating band #{band.name}")
+            rooftop_band = rooftop_bands.find {|b| b.title == band.name} || Rooftop::Events::PriceBand.new
+            rooftop_band.title = band.name
+            rooftop_band.save!
+          end
+
+          #delete ones on rooftop which aren't in spektrix
+          rooftop_titles = rooftop_bands.collect(&:title)
+          spektrix_titles = spektrix_bands.collect(&:name)
+          (rooftop_titles - (rooftop_titles & spektrix_titles)).each do |title|
+            rooftop_bands.find {|b| b.title == title}.destroy
+          end
+        rescue => e
+          @logger.error(e.to_s)
+        end
+
+
+      end
+
+      def create_or_update_ticket_types
+        begin
+          rooftop_ticket_types = Rooftop::Events::TicketType.all.to_a
+          spektrix_ticket_types = Spektrix::Tickets::Type.all.to_a
+          # create or update exiting
+          spektrix_ticket_types.each do |type|
+            @logger.debug("Updating ticket type #{type.name}")
+            rooftop_ticket_type = rooftop_ticket_types.find {|t| t.title == type.name} || Rooftop::Events::TicketType.new
+            rooftop_ticket_type.title = type.name
+            rooftop_ticket_type.save!
+          end
+
+          #delete ones on rooftop which aren't in spektrix
+          rooftop_titles = rooftop_ticket_types.collect(&:title)
+          spektrix_titles = spektrix_ticket_types.collect(&:name)
+          (rooftop_titles - (rooftop_titles & spektrix_titles)).each do |title|
+            rooftop_ticket_types.find {|b| b.title == title}.destroy
+          end
+        rescue => e
+          @logger.error(e.to_s)
+        end
+      end
+
+      # This is where we generate a price list sync instance
+      def create_or_update_prices
+        PriceListSync.new(self).run
+        #In this circumstance, we need to assume some prices have changed, so we'll invalidate the
+        # instance variable which contains the collection of prices on both sides. This means that
+        # next time fetch_rooftop_and_spektrix_data is called, the latest will be pulled from the APIs.
+        @spektrix_price_lists = nil
+        @rooftop_price_lists = nil
+
+      end
+    end
+  end
+end

data/lib/rooftop/spektrix_sync/process.rb

@@ -0,0 +1,26 @@
+module Process
+  def exists?(pid)
+    Process.kill(0, pid)
+    true
+  rescue => e
+    false
+  end
+
+  def create_pid(path)
+    Pathname(path).write(Process.pid)
+  end
+
+  def get_pid(path)
+    File.read(path).to_i
+  rescue Errno::ENOENT
+    false
+  end
+
+  def remove_pidfile(path)
+    File.delete(path)
+  rescue Errno::ENOENT
+    false
+  end
+
+  module_function :exists?, :create_pid, :get_pid, :remove_pidfile
+end

data/lib/rooftop/spektrix_sync/railtie.rb

@@ -0,0 +1,10 @@
+module Rooftop
+  module SpektrixSync
+    class Railtie < ::Rails::Railtie
+
+      rake_tasks do
+        load "rooftop/spektrix_sync/tasks/import.rake"
+      end
+    end
+  end
+end

data/lib/rooftop/spektrix_sync/tasks/import.rake

@@ -0,0 +1,33 @@
+namespace :rooftop do
+  namespace :spektrix do
+
+    task :prepare, [:since, :logger_path] do |task, args|
+      logger_path = args[:logger_path] || STDOUT
+      Rooftop::SpektrixSync.logger = Logger.new(logger_path, 'daily')
+      @since = eval(args[:since]) rescue DateTime.now
+    end
+
+
+    desc "Synchronise events from Spektrix to Rooftop"
+    task :sync_events, [:since, :logger_path]  => [:environment, :prepare] do |task, args|
+      Rooftop::SpektrixSync::SyncTask.run_events_import(@since)
+    end
+
+    desc "Synchronise events and prices from Spektrix to Rooftop"
+    task :sync_all, [:since, :logger_path]  => [:environment, :prepare] do |task, args|
+      Rooftop::SpektrixSync::SyncTask.run_full_import(@since)
+    end
+
+    desc "Synchronise events and prices from Spektrix to Rooftop"
+    task :sync_prices, [:since, :logger_path]  => [:environment, :prepare] do |task, args|
+      Rooftop::SpektrixSync::SyncTask.run_prices_import(@since)
+    end
+
+    desc "Sync specific event"
+    task :sync_event, [:spektrix_event_id, :since, :logger_path] => [:environment, :prepare] do |task, args|
+      Rooftop::SpektrixSync::SyncTask.run_events_import(@since, args[:spektrix_event_id])
+    end
+
+
+  end
+end

data/lib/rooftop/spektrix_sync/version.rb

@@ -0,0 +1,5 @@
+module Rooftop
+  module SpektrixSync
+    VERSION = "0.0.2.15"
+  end
+end

data/lib/rooftop/spektrix_sync.rb

@@ -0,0 +1,22 @@
+require 'active_support'
+require 'colorize'
+
+require "rooftop/spektrix_sync/version"
+require 'require_all'
+require_rel 'spektrix_sync/lib'
+
+module Rooftop
+  module SpektrixSync
+
+    class << self
+      attr_accessor :logger, :configuration
+    end
+
+    if defined?(::Rails)
+      require 'rooftop/spektrix_sync/railtie'
+    end
+
+    require 'rooftop/spektrix_sync/process'
+
+  end
+end

data/rooftop-spektrix_sync.gemspec

@@ -0,0 +1,30 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'rooftop/spektrix_sync/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "rooftop-spektrix_sync"
+  spec.version       = Rooftop::SpektrixSync::VERSION
+  spec.authors       = ["Ed Jones"]
+  spec.email         = ["ed@errorstudio.co.uk"]
+  spec.summary       = %q{A set of tasks to sync events between Spektrix and Rooftop CMS}
+  spec.description   = %q{A set of tasks to sync events between Spektrix and Rooftop CMS}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "rake"
+
+  spec.add_dependency 'colorize'
+  spec.add_dependency 'activesupport'
+  spec.add_dependency 'require_all'
+  spec.add_dependency "rooftop-events"
+  spec.add_dependency 'rooftop', '~> 0.1.0'
+  spec.add_dependency "spektrix"
+end

metadata

@@ -0,0 +1,173 @@
+--- !ruby/object:Gem::Specification
+name: rooftop-spektrix_sync
+version: !ruby/object:Gem::Version
+  version: 0.0.2.15
+platform: ruby
+authors:
+- Ed Jones
+autorequire: 
+bindir: bin
+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.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: colorize
+  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: activesupport
+  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: 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-events
+  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
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+- !ruby/object:Gem::Dependency
+  name: spektrix
+  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: A set of tasks to sync events between Spektrix and Rooftop CMS
+email:
+- ed@errorstudio.co.uk
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".ruby-gemset"
+- ".ruby-version"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/rooftop/spektrix_sync.rb
+- lib/rooftop/spektrix_sync/lib/event_sync.rb
+- lib/rooftop/spektrix_sync/lib/instance_sync.rb
+- lib/rooftop/spektrix_sync/lib/price_list_sync.rb
+- lib/rooftop/spektrix_sync/lib/sync_task.rb
+- lib/rooftop/spektrix_sync/process.rb
+- lib/rooftop/spektrix_sync/railtie.rb
+- lib/rooftop/spektrix_sync/tasks/import.rake
+- lib/rooftop/spektrix_sync/version.rb
+- rooftop-spektrix_sync.gemspec
+homepage: ''
+licenses:
+- MIT
+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.4.5.1
+signing_key: 
+specification_version: 4
+summary: A set of tasks to sync events between Spektrix and Rooftop CMS
+test_files: []