contentful-scheduler-custom 1.5.7.1.8 → 1.5.61

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d939b4d6d5a62754aae92c34d1ed0b83c3c9e2c6
-  data.tar.gz: b1b752511ae144121b9e675b36251e34b4aca598
+  metadata.gz: 769658f7e20d8100d0d242ecbc2750fe9d50fa63
+  data.tar.gz: 83e6f220e154493424b8a9665b88edbf9028b5da
 SHA512:
-  metadata.gz: 1e431980ca314537a273bd6577e9f4b3ec33d5da55903dc3924785f565ea87efcf99c931c068fd62aededd9f8d69d47fe933d04b7df70e97a20f67ec34c05f4a
-  data.tar.gz: 397bd38fcd6fdbd5c3930b072cfb173ef51fe13b7c80f8c0bcca3cc98d419bdf062f9f2b738113e434c23bbc158638b728cd930c88ec8239135bec25bd648e28
+  metadata.gz: 3acd663eef65d4e0636b4e737fe98dcd36e9fba98b5155ee7a3908cf41a76c22705db789b009cef6f25a7cedf6cf3c37bde9ac2866402606c35b94d10e4d59a6
+  data.tar.gz: faa09d1bc36c064a1510c1f23064aa8ffd4ec5b497305ac3170d89234bb2630d12f4ce8d556db278d67ec37c15a3b1b499736206210c9221a04278ff5fe9f4f5

data/.gitignore

@@ -9,3 +9,5 @@
 /tmp/
 .DS_Store
 dump.rdb
+/.idea/
+/example/.rakeTasks

data/.travis.yml

@@ -1,6 +1,6 @@
 language: ruby
 rvm:
+  - 2.2.3
   - 2.3.1
-  - 2.4.1
-  - 2.5.1
+  - 2.4.0
 before_install: gem install bundler -v 1.10.6

data/CHANGELOG.md

@@ -2,25 +2,14 @@
 
 ## Unreleased
 
-## 0.5.0
-### Added
-* Added support for scheduled unpublishing. [#10](https://github.com/contentful/contentful-scheduler.rb/issues/10)
-
-## 0.4.0
-### Fixed
-* Fixed User Agent Header to comply with specification.
-
-### Added
-* Added authentication mechanisms. [#9](https://github.com/contentful/contentful-scheduler.rb/issues/9)
-
-## 0.3.0
-### Added
-* Added possibility to republish already published content. [#5](https://github.com/contentful/contentful-scheduler.rb/issues/5)
+## 1.4.0
+* Contentful Scheduler now supports future publishing for any existing enteries and
+publishing ContentBlocks first before publishing the page.
 
 ## 0.2.1
 
 ### Fixed
-* Fixed time parsing.
+* Fix time parsing.
 
 ## 0.2.0
 

data/README.md

@@ -7,18 +7,17 @@ Scheduling Server for Contentful entries.
 
 ## What does `contentful-scheduler` do?
 The aim of `contentful-scheduler` is to have developers setting up their Contentful
-entries for scheduled publishing and unpublishing.
+entries for scheduled publishing.
 
 ## How does it work
-`contentful-scheduler` provides a web endpoint to receive webhook calls from Contentful.
-
-Every time the endpoint recieves a call it looks for the value of the field defined in the configuration.
-If the value is a time in the future it will schedule the entry for publishing or unpublishing at the specified time.
-
+`contentful-scheduler` provides a web endpoint to receive webhook calls from Contentful,
+every time the endpoint recieves a call it looks for the value of the field defined in the configuration,
+if the value is a time in the future it will schedule the entry for publishing at the specified time.
 A background worker based on the popular `resque` gem will then proceed to actually make the publish call
-against the Content Management API at the due time. For this the Entries you wish to publish or unpublish require a
-customizable Date field, which we advice to call `publishDate` for the publishing action and `unpublishDate` for the unpublishing action,
-this field can be configured inside your `Rakefile` and is specific per-space.
+against the Content Management API at the due time. For this the Entries you wish to publish require a
+customizable Date field, which we advice to call `publishDate`, this field can be configured inside your
+`Rakefile` and is specific per-space(supports multiple spaces), also please make sure contentBlocks are valid
+as per logic contentBlocks are published first then the page is published, so if there is any contentBlocks missing publishing won't work.
 
 You can add multiple spaces to your configuration, making it useful if you have a milti-space setup.
 
@@ -31,7 +30,7 @@ You can add multiple spaces to your configuration, making it useful if you have
 Add this line to your application's Gemfile:
 
 ```ruby
-gem 'contentful-scheduler'
+gem 'contentful-scheduler-custom'
 ```
 
 And then execute:
@@ -40,7 +39,7 @@ And then execute:
 
 Or install it yourself as:
 
-    $ gem install contentful-scheduler
+    $ gem install contentful-scheduler-custom
 
 ## Usage
 
@@ -56,7 +55,7 @@ If you want to roll out your own, you need to follow the next steps:
 ```ruby
 source 'https://rubygems.org'
 
-gem 'contentful-scheduler', '~> 0.1'
+gem 'contentful-scheduler-custom', '~>1.4'
 gem 'contentful-management', '~> 1.0'
 gem 'resque', '~> 1.0'
 gem 'resque-scheduler', '~> 4.0'
@@ -91,11 +90,15 @@ config = {
   spaces: {
     'YOUR_SPACE_ID' => {
       publish_field: 'publishDate', # It specifies the field ID for your Publish Date in your Content Type
-      unpublish_field: 'unpublishDate', # Optional - It specifies the field ID for your Unpublish Date in your Content Type
-      management_token: 'YOUR_TOKEN',
-      auth: { # This is optional
-        # ... content in this section will be explained in a separate section ...
-      }
+      management_token: 'YOUR_TOKEN'
+    },
+    'YOUR_SPACE_ID' => {
+      publish_field: 'publishDate', # It specifies the field ID for your Publish Date in your Content Type
+      management_token: 'YOUR_TOKEN'
+     },
+    'YOUR_SPACE_ID' => {
+      publish_field: 'publishDate', # It specifies the field ID for your Publish Date in your Content Type
+      management_token: 'YOUR_TOKEN'
     }
   },
 }
@@ -156,114 +159,85 @@ Under the space settings menu choose webhook and add a new webhook pointing to `
 
 Keep in mind that if you modify the defaults, the URL should be changed to the values specified in the configuration.
 
-## Authentication
+## Running in Heroku
 
-You may want to provide an additional layer of security to your scheduler server, therefore an additional option to add space based authentication is provided.
+Heroku offers various Redis plugins, select the one of your liking, add the credentials into your configuration, and proceed to
+`git heroku push master`.
 
-There are two available authentication methods. Static string matching and lambda validations, which will be explained in the next section.
+This will get your application set up and running. It will require 4 dynos, so a free plan isn't enough for it to run.
 
-Any of both mechanisms require you to add additional headers to your webhook set up, which can be done through the [Contentful Web App](https://app.contentful.com),
-or through the [CMA](https://www.contentful.com/developers/docs/references/content-management-api/#/reference/webhooks/webhook/create-update-a-webhook/console/ruby).
+To run the `monitor` process, you'll require to run it from a different application pointing to the same Redis instance.
 
-### Authentication via static token matching
+Make sure to change the `Procfile`'s `web` process to the following:
 
-The simplest authentication mechanism, is to provide a static set of valid strings that are considered valid when found in a determined header.
+```
+web: PORT=$PORT bundle exec env rake contentful:scheduler
+```
 
-For example:
+That will allow Heroku to set it's own Port according to their policy.
 
-```ruby
-config = {
-  # ... the rest of the config ...
-  spaces: {
-    'my_space' => {
-      # ... the rest of the space specific configuration ...
-      auth: {
-        key: 'X-Webhook-Server-Auth-Header',
-        valid_tokens: ['some_valid_static_token']
-      }
-    }
-  }
-}
-```
+The URL for the webhook then will be on port 80, so you should change it to: `http://YOUR_APPLICATION/scheduler`.
 
-The above example, whenever your webhook sends the `X-Webhook-Server-Auth-Header` with a value of `some_valid_static_token`,
-it will accept the request and queue your webhook for processing.
+## Running in Production Mode
 
-You can provide multiple or a single token. If a single token is provided, it's not necessary to include it in an array.
+After verifying that application is working fine in development mode(run "foreman start" for development mode)
 
-### Authentication via lambda
+Run the following commands
 
-A more complicated solution, but far more secure, is the ability to execute a lambda as the validator function.
-This allows you define a function for authentication. This function can call an external authentication service,
-make checks against a database or do internal processing.
+1. sudo foreman export -p5000 --app stp --user username_to_start_from systemd /etc/systemd/system/
 
-The function must return a truthy/falsey value in order for the authentication to be successful/unsuccessful.
+Output will be like this:
 
-For example, we validate that the token provided is either `foo` or `bar`:
+[foreman export] cleaning up directory: /etc/systemd/system//graphical.target.wants
+[foreman export] writing: stp-web@.service
+[foreman export] creating: stp-web.target.wants
+[foreman export] symlinking: stp-web.target.wants/stp-web@5000.service -> ../stp-web@.service
+[foreman export] writing: stp-web.target
+[foreman export] writing: stp-celery@.service
+[foreman export] creating: stp-celery.target.wants
+[foreman export] symlinking: stp-celery.target.wants/stp-celery@5100.service -> ../stp-celery@.service
+[foreman export] writing: stp-celery.target
+[foreman export] writing: stp.target
 
-```ruby
-config = {
-  # ... the rest of the config ...
-  spaces: {
-    'my_space' => {
-      # ... the rest of the space specific configuration ...
-      auth: {
-        key: 'X-Webhook-Server-Auth-Header',
-        validation: -> (value) { /^(foo|bar)$/ =~ value }
-      }
-    }
-  }
-}
-```
+2. cat /etc/systemd/system/stp-web@.service | head -n 10
 
-Or a more complicated example, checking if the header is a valid OAuth token, and then making a request to our OAuth database.
-For this example we'll consider you have a table called `tokens` and are using [DataMapper](https://datamapper.org) as a ORM,
-and have a `valid?` method checking if the token is not expired.
+Output will be like this:
 
-```ruby
-config = {
-  # ... the rest of the config ...
-  spaces: {
-    'my_space' => {
-      # ... the rest of the space specific configuration ...
-      auth: {
-        key: 'X-Webhook-Server-Auth-Header',
-        validation: proc do |value|
-          return false unless /^Bearer \w+/ =~ value
+[Unit]
+PartOf=stp-web.target
 
-          token = Token.first(token: value.gsub('Bearer ', ''))
+[Service]
+User=username_to_start_from 
+WorkingDirectory=/srv/stp/
+Environment=PORT=%i
+... HERE OTHER DIRICTIVES FROM YOUR .env file ...
+Environment=DEBUG=0
+...
 
-          return false if token.nil?
 
-          token.valid?
-        end
-      }
-    }
-  }
-}
-```
+3. Start only gunicorn on port 5700:
 
-If you have multiple spaces and all share the same auth strategy, you can extract the authentication method to a variable,
-and assign it to all the applicable spaces in order to reduce the code duplication.
+   systemctl start stp-web@5700.service
 
-## Running in Heroku
+4. Start whole target:
 
-Heroku offers various Redis plugins, select the one of your liking, add the credentials into your configuration, and proceed to
-`git heroku push master`.
+   systemctl start stp.target
 
-This will get your application set up and running. It will require 4 dynos, so a free plan isn't enough for it to run.
+5. Enable whole target (start on OS boot):
 
-To run the `monitor` process, you'll require to run it from a different application pointing to the same Redis instance.
+   systemctl enable stp.target
 
-Make sure to change the `Procfile`'s `web` process to the following:
+6. Restarting daemon
 
-```
-web: PORT=$PORT bundle exec env rake contentful:scheduler
-```
+   sudo systemctl daemon-reload
+   
+   sudo systemctl restart stp.target
+   
+7. Optional 
 
-That will allow Heroku to set it's own Port according to their policy.
+   You can also simply define port when call foreman export -pXXXX, but it should be multiple of 1000,
+   e.g. 1000, 2000, 3000, 45000 etc.
 
-The URL for the webhook then will be on port 80, so you should change it to: `http://YOUR_APPLICATION/scheduler`.
 
 ## Contributing
 

data/contentful-scheduler.gemspec

@@ -22,8 +22,8 @@ Gem::Specification.new do |spec|
   spec.add_runtime_dependency "contentful-webhook-listener", "~> 0.2"
   spec.add_runtime_dependency "contentful-management", "~> 1.8"
   spec.add_runtime_dependency "resque", "~> 1.27.4"
-  spec.add_runtime_dependency "resque-scheduler", "~> 4.3.1"
-  spec.add_runtime_dependency "redis", "~> 4.0.1"
+  spec.add_runtime_dependency "resque-scheduler", "~> 4.2.1"
+  spec.add_runtime_dependency "redis", "~> 3.0"
   spec.add_runtime_dependency "chronic", "~> 0.10"
 
   spec.add_development_dependency "bundler", "~> 1.10"

data/example/Dockerfile

@@ -0,0 +1,25 @@
+FROM ruby:2.5
+MAINTAINER Bugs Bunny <bbunny@rubyplus.com>
+
+
+
+# Install gems
+ENV APP_HOME /app
+ENV HOME /root
+RUN mkdir $APP_HOME
+RUN chmod -R 777 /app
+RUN chmod -R 777 /root
+
+
+WORKDIR $APP_HOME
+COPY Gemfile* $APP_HOME/
+RUN bundle install
+
+# Upload source
+COPY . $APP_HOME
+
+# Start server
+ENV PORT 8080
+EXPOSE 8080
+USER 1001
+CMD ["foreman", "start"]

data/example/Gemfile

@@ -1,7 +1,8 @@
 source 'https://rubygems.org'
 
-gem 'contentful-scheduler-custom', '~> 1.5.7.1.3'
+gem 'contentful-scheduler-custom', '~>1.4'
 gem 'contentful-management', '~> 1.0'
 gem 'resque', '~> 1.0'
-gem 'resque-scheduler', '~> 4.0'
+gem 'resque-scheduler', '4.2.1'
 gem 'rake'
+gem 'foreman', '~> 0.84.0'

data/example/Procfile

@@ -1,4 +1,4 @@
-web: env bundle exec rake contentful:scheduler
+web: PORT=$PORT bundle exec env rake contentful:scheduler
 monitor: env bundle exec rackup
 resque: env bundle exec rake resque:work
-resque_scheduler: env bundle exec rake resque:scheduler
+resque_scheduler: env bundle exec rake resque:scheduler

data/example/Rakefile

@@ -1,23 +1,22 @@
 require 'contentful/scheduler'
-require 'logger' # Optional
 
 $stdout.sync = true
 
 config = {
   logger: Logger.new(STDOUT), # Defaults to NullLogger
-  port: 32123, # Defaults to 32123
+  port: 8080, # Defaults to 8081
   endpoint: '/scheduler', # Defaults to /scheduler
   redis: {
-    host: 'YOUR_REDIS_HOST',
-    port: 'YOUR_REDIS_PORT',
-    password: 'YOUR_REDIS_PASSWORD'
+    host: 'scheduler-redis-db',
+    port: '6379',
+    password: 'password'
   },
   spaces: {
-    'YOUR_SPACE_ID' => {
+    'qbra4qai2ti2' => {
       publish_field: 'publishDate', # It specifies the field ID for your Publish Date in your Content Type
-      management_token: 'YOUR_TOKEN'
+      management_token: 'CFPAT-45f0c4258aa9b32e8a8b6ccebf64136386b31f3ec435cc17f540368d5416de02'
     }
-  }
+  },
 }
 
 namespace :contentful do

data/example/config.ru

@@ -3,9 +3,9 @@ require 'resque/server'
 require 'resque/scheduler/server'
 
 config = {
-  host: 'YOUR_REDIS_HOST',
-  port: 'YOUR_REDIS_PORT',
-  password: 'YOUR_REDIS_PASSWORD'
+  host: 'scheduler-redis-db',
+  port: '6379',
+  password: 'password'
 }
 Resque.redis = config
 

data/lib/contentful/scheduler/controller.rb

@@ -1,5 +1,4 @@
 require 'contentful/webhook/listener'
-require_relative 'auth'
 require_relative 'queue'
 
 module Contentful
@@ -8,11 +7,6 @@ module Contentful
       def create
         return unless webhook.entry?
 
-        if !Auth.new(webhook).auth
-          logger.warn "Skipping - Authentication failed for Space: #{webhook.space_id} - Entry: #{webhook.id}"
-          return
-        end
-
         logger.info "Queueing - Space: #{webhook.space_id} - Entry: #{webhook.id}"
 
         Queue.instance(logger).update_or_create(webhook)
@@ -24,11 +18,6 @@ module Contentful
       def delete
         return unless webhook.entry?
 
-        if !Auth.new(webhook).auth
-          logger.warn "Skipping - Authentication failed for Space: #{webhook.space_id} - Entry: #{webhook.id}"
-          return
-        end
-
         logger.info "Unqueueing - Space: #{webhook.space_id} - Entry: #{webhook.id}"
 
         Queue.instance(logger).remove(webhook)

data/lib/contentful/scheduler/queue.rb

@@ -1,6 +1,6 @@
-require_relative "tasks"
 require 'chronic'
 require 'contentful/webhook/listener'
+require_relative "tasks"
 
 module Contentful
   module Scheduler
@@ -15,16 +15,17 @@ module Contentful
 
       def update_or_create(webhook)
         if publishable?(webhook)
-          successPublish = update_or_create_for_publish(webhook)
+          success = update_or_create_for_publish(webhook)
           updateContentBlocks(webhook, 'publish')
-          log_event_success(webhook, successPublish, 'publish', 'added to')
+          log_event_success(webhook, success, 'publish', 'added to')
         end
 
         if unpublishable?(webhook)
-          successUnpublish = update_or_create_for_unpublish(webhook)
+          success = update_or_create_for_unpublish(webhook)
           updateContentBlocks(webhook, 'unpublish')
-          log_event_success(webhook, successUnpublish, 'unpublish', 'added to')
+          log_event_success(webhook, success, 'unpublish', 'added to')
         end
+
       end
 
       def update_or_create_for_publish(webhook)
@@ -74,45 +75,60 @@ module Contentful
         log_event_success(webhook, success, 'publish', 'removed from')
       end
 
-      def remove_unpublish(webhook)
-        return unless unpublishable?(webhook)
-        return unless in_unpublish_queue?(webhook)
-
-        success = Resque.remove_delayed(
-          ::Contentful::Scheduler::Tasks::Unpublish,
-          webhook.space_id,
-          webhook.id,
-          ::Contentful::Scheduler.config[:management_token]
-        )
-
-        removeContentBlocks(webhook, 'unpublish')
-
-        log_event_success(webhook, success, 'unpublish', 'removed from')
+      def updateContentBlocks(webhook, type)
+        if isContentBlockAvailable(webhook)
+          webhook.fields['contentBlocks']['fi-FI'].each do |sys|
+            success = Resque.enqueue_at(
+              publish_date(webhook),
+              getScheduleType(type),
+              webhook.space_id,
+              sys['sys']['id'],
+              ::Contentful::Scheduler.config[:spaces][webhook.space_id][:management_token]
+            )
+            if success
+              logger.info "Webhook Content block {id: #{sys['sys']['id']}, space_id: #{webhook.space_id}} successfully added to " + type + " queue"
+            else
+              logger.warn "Webhook Content block {id: #{sys['sys']['id']}, space_id: #{webhook.space_id}} couldn't be added to " + type + " queue"
+            end
+          end
+        end
       end
 
-      def log_event_success(webhook, success, event_kind, action)
-        if success
-          logger.info "Webhook {id: #{webhook.id}, space_id: #{webhook.space_id}} successfully #{action} the #{event_kind} queue"
+      def getScheduleType(type)
+        if type == 'unpublish'
+          return ::Contentful::Scheduler::Tasks::Unpublish
         else
-          logger.warn "Webhook {id: #{webhook.id}, space_id: #{webhook.space_id}} couldn't be #{action} the #{event_kind} queue"
+          return ::Contentful::Scheduler::Tasks::Publish
         end
       end
 
-      def publishable?(webhook)
-        return false unless spaces.key?(webhook.space_id)
-
-        if webhook_publish_field?(webhook)
-          return !webhook_publish_field(webhook).nil? && publish_is_future?(webhook)
+      def removeContentBlocks(webhook, type)
+        if isContentBlockAvailable(webhook)
+          webhook.fields['contentBlocks']['fi-FI'].each do |sys|
+            success = Resque.remove_delayed(
+              getScheduleType(type),
+              webhook.space_id,
+              sys['sys']['id'],
+              ::Contentful::Scheduler.config[:management_token]
+            )
+            if success
+              logger.info "Webhook Content Block {id: #{sys['sys']['id']}, space_id: #{webhook.space_id}} successfully removed from " + type + " queue"
+            else
+              logger.warn "Webhook Content Block {id: #{sys['sys']['id']}, space_id: #{webhook.space_id}} couldn't be removed from " + type + " queue"
+            end
+          end
         end
+      end
 
-        false
+      def isContentBlockAvailable(webhook)
+        return !webhook.fields['contentBlocks'].nil?
       end
 
-      def unpublishable?(webhook)
+      def publishable?(webhook)
         return false unless spaces.key?(webhook.space_id)
 
-        if webhook_unpublish_field?(webhook)
-          return !webhook_unpublish_field(webhook).nil? && unpublish_is_future?(webhook)
+        if webhook_publish_field?(webhook)
+          return !webhook_publish_field(webhook).nil? && publish_is_future?(webhook)
         end
 
         false
@@ -122,22 +138,52 @@ module Contentful
         publish_date(webhook) > Time.now.utc
       end
 
-      def unpublish_is_future?(webhook)
-        unpublish_date(webhook) > Time.now.utc
-      end
-
       def in_publish_queue?(webhook)
         Resque.peek(::Contentful::Scheduler::Tasks::Publish, 0, -1).any? do |job|
           job['args'][0] == webhook.space_id && job['args'][1] == webhook.id
         end
       end
 
+      def remove_unpublish(webhook)
+        logger.info "In unpublish remove block" + unpublishable?(webhook) + in_unpublish_queue?(webhook)
+        return unless unpublishable?(webhook)
+        return unless in_unpublish_queue?(webhook)
+
+
+        success = Resque.remove_delayed(
+          ::Contentful::Scheduler::Tasks::Unpublish,
+          webhook.space_id,
+          webhook.id,
+          ::Contentful::Scheduler.config[:management_token]
+        )
+
+        logger.info "before unpublish content block remove block"
+
+        removeContentBlocks(webhook, 'unpublish')
+
+        log_event_success(webhook, success, 'unpublish', 'removed from')
+      end
+
       def in_unpublish_queue?(webhook)
         Resque.peek(::Contentful::Scheduler::Tasks::Unpublish, 0, -1).any? do |job|
           job['args'][0] == webhook.space_id && job['args'][1] == webhook.id
         end
       end
 
+      def unpublish_is_future?(webhook)
+        unpublish_date(webhook) > Time.now.utc
+      end
+
+      def unpublishable?(webhook)
+        return false unless spaces.key?(webhook.space_id)
+
+        if webhook_unpublish_field?(webhook)
+          return !webhook_unpublish_field(webhook).nil? && unpublish_is_future?(webhook)
+        end
+
+        false
+      end
+
       def publish_date(webhook)
         date_field = webhook_publish_field(webhook)
         date_field = date_field[date_field.keys[0]] if date_field.is_a? Hash
@@ -150,75 +196,16 @@ module Contentful
         Chronic.parse(date_field).utc
       end
 
-      def updateContentBlocks(webhook, type)
-        if isContentBlockAvailable(webhook, type)
-          webhook.fields['contentBlocks']['fi-FI'].each do |sys|
-            success = Resque.enqueue_at(
-              getPublishOrUnpublishDate(webhook, type),
-              getScheduleType(type),
-              webhook.space_id,
-              sys['sys']['id'],
-              ::Contentful::Scheduler.config[:spaces][webhook.space_id][:management_token]
-            )
-            if success
-              logger.info "Webhook Content block {id: #{sys['sys']['id']}, space_id: #{webhook.space_id}} successfully added to " + type + " queue"
-            else
-              logger.warn "Webhook Content block {id: #{sys['sys']['id']}, space_id: #{webhook.space_id}} couldn't be added to " + type + " queue"
-            end
-          end
-        end
-      end
-
-      def removeContentBlocks(webhook, type)
-        if isContentBlockAvailable(webhook, type)
-          webhook.fields['contentBlocks']['fi-FI'].each do |sys|
-            success = Resque.remove_delayed(
-              getScheduleType(type),
-              webhook.space_id,
-              sys['sys']['id'],
-              ::Contentful::Scheduler.config[:management_token]
-            )
-            if success
-              logger.info "Webhook Content Block {id: #{sys['sys']['id']}, space_id: #{webhook.space_id}} successfully removed from " + type + " queue"
-            else
-              logger.warn "Webhook Content Block {id: #{sys['sys']['id']}, space_id: #{webhook.space_id}} couldn't be removed from " + type + " queue"
-            end
-          end
-        end
-      end
-
-      def isContentBlockAvailable(webhook, type)
-        logger.info "Content type is ==>> #{ type }"
-        logger.info "Content Fields are ===>>> #{webhook.fields['contentBlocks']}"
-        return !webhook.fields['contentBlocks'].nil?
-      end
-
-      def getScheduleType(type)
-        if type == 'publish'
-          ::Contentful::Scheduler::Tasks::Publish
-        else
-          ::Contentful::Scheduler::Tasks::Unpublish
-        end
-      end
-
-      def getPublishOrUnpublishDate(webhook, type)
-        if type == 'publish'
-          publish_date(webhook)
-        else
-          unpublish_date(webhook)
-        end
-      end
-
       def spaces
         config[:spaces]
       end
 
       def webhook_publish_field?(webhook)
-        webhook.fields.key?(spaces.fetch(webhook.space_id, {})[:publish_field]) if webhook.respond_to?(:fields)
+        webhook.fields.key?(spaces.fetch(webhook.space_id, {})[:publish_field])
       end
 
       def webhook_unpublish_field?(webhook)
-        webhook.fields.key?(spaces.fetch(webhook.space_id, {})[:unpublish_field]) if webhook.respond_to?(:fields)
+        webhook.fields.key?(spaces.fetch(webhook.space_id, {})[:unpublish_field])
       end
 
       def webhook_publish_field(webhook)
@@ -229,6 +216,14 @@ module Contentful
         webhook.fields[spaces[webhook.space_id][:unpublish_field]]
       end
 
+      def log_event_success(webhook, success, event_kind, action)
+        if success
+          logger.info "Webhook {id: #{webhook.id}, space_id: #{webhook.space_id}} successfully #{action} the #{event_kind} queue"
+        else
+          logger.warn "Webhook {id: #{webhook.id}, space_id: #{webhook.space_id}} couldn't be #{action} the #{event_kind} queue"
+        end
+      end
+
       private
 
       def initialize(logger)

data/lib/contentful/scheduler/tasks/publish.rb

@@ -10,7 +10,7 @@ module Contentful
           client = ::Contentful::Management::Client.new(
             token,
             raise_errors: true,
-            application_name: 'contentful.scheduler',
+            application_name: 'contentful-scheduler',
             application_version: Contentful::Scheduler::VERSION
           )
           client.entries.find(space_id, entry_id).publish

data/lib/contentful/scheduler/tasks/unpublish.rb

@@ -10,7 +10,7 @@ module Contentful
           client = ::Contentful::Management::Client.new(
             token,
             raise_errors: true,
-            application_name: 'contentful.scheduler',
+            application_name: 'contentful-scheduler',
             application_version: Contentful::Scheduler::VERSION
           )
           client.entries.find(space_id, entry_id).unpublish
@@ -18,4 +18,4 @@ module Contentful
       end
     end
   end
-end
+end

data/lib/contentful/scheduler/version.rb

@@ -1,5 +1,5 @@
 module Contentful
   module Scheduler
-    VERSION = "1.5.7.1.8"
+    VERSION = "1.5.61"
   end
 end

data/spec/contentful/scheduler/controller_spec.rb

@@ -9,10 +9,6 @@ describe Contentful::Scheduler::Controller do
   let(:queue) { ::Contentful::Scheduler::Queue.instance }
   subject { described_class.new server, logger, timeout }
 
-  before :each do
-    Contentful::Scheduler.config = base_config
-  end
-
   describe 'events' do
     [:create, :save, :auto_save, :unarchive].each do |event|
       it "creates or updates webhook metadata in publish queue on #{event}" do
@@ -46,19 +42,5 @@ describe Contentful::Scheduler::Controller do
         end
       end
     end
-
-    describe 'auth' do
-      context 'on auth failure' do
-        let(:body) { {sys: { id: 'invalid_auth', space: { sys: { id: 'valid_token_string' } } }, fields: {} } }
-
-        it 'will stop the queueing process' do
-          expect(queue).not_to receive(:update_or_create)
-
-          headers['X-Contentful-Topic'] = "ContentfulManagement.Entry.save"
-          request = RequestDummy.new(headers, body)
-          subject.respond(request, MockResponse.new).join
-        end
-      end
-    end
   end
 end

data/spec/contentful/scheduler/queue_spec.rb

@@ -260,4 +260,4 @@ describe Contentful::Scheduler::Queue do
       end
     end
   end
-end
+end

data/spec/contentful/scheduler/tasks/publish_spec.rb

@@ -29,7 +29,7 @@ describe Contentful::Scheduler::Tasks::Publish do
       expect(::Contentful::Management::Client).to receive(:new).with(
         'foo',
         raise_errors: true,
-        application_name: 'contentful.scheduler',
+        application_name: 'contentful-scheduler',
         application_version: Contentful::Scheduler::VERSION
       ) { mock_client }
       expect(mock_client).to receive(:entries) { mock_entries }
@@ -39,4 +39,4 @@ describe Contentful::Scheduler::Tasks::Publish do
       described_class.perform('foo', 'bar', ::Contentful::Scheduler.config[:spaces]['foo'][:management_token])
     end
   end
-end
+end

data/spec/contentful/scheduler/tasks/unpublish_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 class MockEntry
-  def unpublish
+  def publish
   end
 end
 
@@ -21,22 +21,22 @@ describe Contentful::Scheduler::Tasks::Unpublish do
   let(:mock_entry) { MockEntry.new }
 
   before :each do
-    ::Contentful::Scheduler.config = base_config
+    ::Contentful::Scheduler.class_variable_set(:@@config, {management_token: 'foobar'})
   end
 
   describe 'class methods' do
     it '::perform' do
       expect(::Contentful::Management::Client).to receive(:new).with(
-        'foo',
+        'foobar',
         raise_errors: true,
-        application_name: 'contentful.scheduler',
+        application_name: 'contentful-scheduler',
         application_version: Contentful::Scheduler::VERSION
       ) { mock_client }
       expect(mock_client).to receive(:entries) { mock_entries }
       expect(mock_entries).to receive(:find).with('foo', 'bar') { mock_entry }
       expect(mock_entry).to receive(:unpublish)
 
-      described_class.perform('foo', 'bar', ::Contentful::Scheduler.config[:spaces]['foo'][:management_token])
+      described_class.perform('foo', 'bar', ::Contentful::Scheduler.config[:management_token])
     end
   end
 end

data/spec/spec_helper.rb

@@ -120,4 +120,4 @@ end
 RSpec.configure do |config|
   config.filter_run :focus => true
   config.run_all_when_everything_filtered = true
-end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: contentful-scheduler-custom
 version: !ruby/object:Gem::Version
-  version: 1.5.7.1.8
+  version: 1.5.61
 platform: ruby
 authors:
 - Contentful GmbH (David Litvak Bruno0
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-08-10 00:00:00.000000000 Z
+date: 2018-07-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: contentful-webhook-listener
@@ -58,28 +58,28 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 4.3.1
+        version: 4.2.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 4.3.1
+        version: 4.2.1
 - !ruby/object:Gem::Dependency
   name: redis
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 4.0.1
+        version: '3.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 4.0.1
+        version: '3.0'
 - !ruby/object:Gem::Dependency
   name: chronic
   requirement: !ruby/object:Gem::Requirement
@@ -196,19 +196,18 @@ files:
 - README.md
 - Rakefile
 - contentful-scheduler.gemspec
+- example/Dockerfile
 - example/Gemfile
 - example/Procfile
 - example/Rakefile
 - example/config.ru
 - lib/contentful/scheduler.rb
-- lib/contentful/scheduler/auth.rb
 - lib/contentful/scheduler/controller.rb
 - lib/contentful/scheduler/queue.rb
 - lib/contentful/scheduler/tasks.rb
 - lib/contentful/scheduler/tasks/publish.rb
 - lib/contentful/scheduler/tasks/unpublish.rb
 - lib/contentful/scheduler/version.rb
-- spec/contentful/scheduler/auth_spec.rb
 - spec/contentful/scheduler/controller_spec.rb
 - spec/contentful/scheduler/queue_spec.rb
 - spec/contentful/scheduler/tasks/publish_spec.rb
@@ -240,7 +239,6 @@ signing_key:
 specification_version: 4
 summary: Customizable Scheduler for Contentful Entries.
 test_files:
-- spec/contentful/scheduler/auth_spec.rb
 - spec/contentful/scheduler/controller_spec.rb
 - spec/contentful/scheduler/queue_spec.rb
 - spec/contentful/scheduler/tasks/publish_spec.rb

data/lib/contentful/scheduler/auth.rb

@@ -1,64 +0,0 @@
-module Contentful
-  module Scheduler
-    class Auth
-      attr_reader :webhook
-
-      def initialize(webhook)
-        @webhook = webhook
-      end
-
-      def auth
-        return true if auth_config.nil?
-
-        return verify_key_value_config if key_value_config?
-        return verify_lambda_config if lambda_config?
-
-        false
-      end
-
-      private
-
-      def key_value_config?
-        auth_config.key?(:key) && auth_config.key?(:valid_tokens)
-      end
-
-      def verify_key_value_config
-        value = webhook.raw_headers[auth_config[:key]]
-
-        return false if value.nil?
-
-        valid_tokens = auth_config[:valid_tokens]
-
-        return valid_tokens.include?(value) if valid_tokens.is_a?(::Array)
-        valid_tokens == value
-      end
-
-      def lambda_config?
-        auth_config.key?(:key) && auth_config.key?(:validation)
-      end
-
-      def verify_lambda_config
-        value = webhook.raw_headers[auth_config[:key]]
-
-        return false if value.nil?
-
-        validation = auth_config[:validation]
-
-        return false unless validation.is_a?(::Proc)
-
-        validation[value]
-      end
-
-      def auth_config
-        ::Contentful::Scheduler.config
-          .fetch(:spaces, {})
-          .fetch(space_id, {})
-          .fetch(:auth, nil)
-      end
-
-      def space_id
-        webhook.space_id
-      end
-    end
-  end
-end

data/spec/contentful/scheduler/auth_spec.rb

@@ -1,67 +0,0 @@
-require 'spec_helper'
-
-describe Contentful::Scheduler::Auth do
-  before :each do
-    Contentful::Scheduler.config = base_config
-  end
-
-  describe 'auth' do
-    context 'when no auth is provided' do
-      it 'always returns true' do
-        webhook = WebhookDouble.new('id', 'no_auth')
-        expect(described_class.new(webhook).auth).to be_truthy
-      end
-    end
-
-    context 'when providing token array auth' do
-      it 'false when key not found' do
-        webhook = WebhookDouble.new('id', 'valid_token_array')
-        expect(described_class.new(webhook).auth).to be_falsey
-      end
-
-      it 'false when key found but value not matched' do
-        webhook = WebhookDouble.new('id', 'valid_token_array', {}, {}, {'auth' => 'not_valid'})
-        expect(described_class.new(webhook).auth).to be_falsey
-      end
-
-      it 'true when key found and value matched' do
-        webhook = WebhookDouble.new('id', 'valid_token_array', {}, {}, {'auth' => 'test_1'})
-        expect(described_class.new(webhook).auth).to be_truthy
-      end
-    end
-
-    context 'when providing token string auth' do
-      it 'false when key not found' do
-        webhook = WebhookDouble.new('id', 'valid_token_string')
-        expect(described_class.new(webhook).auth).to be_falsey
-      end
-
-      it 'false when key found but value not matched' do
-        webhook = WebhookDouble.new('id', 'valid_token_string', {}, {}, {'auth' => 'not_valid'})
-        expect(described_class.new(webhook).auth).to be_falsey
-      end
-
-      it 'true when key found and value matched' do
-        webhook = WebhookDouble.new('id', 'valid_token_string', {}, {}, {'auth' => 'test_2'})
-        expect(described_class.new(webhook).auth).to be_truthy
-      end
-    end
-
-    context 'when providing lambda auth' do
-      it 'false when key not found' do
-        webhook = WebhookDouble.new('id', 'lambda_auth')
-        expect(described_class.new(webhook).auth).to be_falsey
-      end
-
-      it 'false when key found but value not matched' do
-        webhook = WebhookDouble.new('id', 'lambda_auth', {}, {}, {'auth' => 'not_valid'})
-        expect(described_class.new(webhook).auth).to be_falsey
-      end
-
-      it 'true when key found and value matched' do
-        webhook = WebhookDouble.new('id', 'lambda_auth', {}, {}, {'auth' => 'test'})
-        expect(described_class.new(webhook).auth).to be_truthy
-      end
-    end
-  end
-end