timekit 0.1.0

data/lib/timekit/event/client.rb

@@ -0,0 +1,94 @@
+module Timekit
+  class Event
+    # Client class for the event resource
+    class Client < Timekit::Client
+      API_PATH = '/events'.freeze
+
+      def list(start_datetime, end_datetime)
+        params = {
+          start: start_datetime,
+          end: end_datetime
+        }
+
+        get(API_PATH, params)
+      end
+
+      def show(id)
+        get(API_PATH + '/' + id.to_s)
+      end
+
+      def create(
+        event_start,
+        event_end,
+        what,
+        where,
+        calendar_id,
+        participants = nil,
+        invite = nil,
+        description = nil,
+        sync_provider = nil,
+        my_rsvp = nil,
+        all_day = nil
+      )
+
+        params = {
+          start: event_start,
+          end: event_end,
+          what: what,
+          where: where,
+          calendar_id: calendar_id
+        }
+
+        optional_params = [
+          :participants,
+          :invite,
+          :description,
+          :my_rsvp,
+          :sync_provider,
+          :all_day
+        ]
+
+        optional_params.each do |name|
+          value = binding.local_variable_get(name)
+          params[name.to_sym] = value if [true, false].include?(value) ||
+                                         !value.nil?
+        end
+
+        post(API_PATH, params)
+      end
+
+      def update(
+        id,
+        event_start = nil,
+        event_end = nil,
+        what = nil,
+        where = nil,
+        participants = nil,
+        all_day = nil
+      )
+        params = {}
+        params[:start] = event_start if event_start
+        params[:end] = event_end if event_end
+
+        optional_params = [
+          :what,
+          :where,
+          :participants,
+          :all_day
+        ]
+
+        optional_params.each do |name|
+          value = binding.local_variable_get(name)
+          params[name.to_sym] = value if
+            [true, false].include?(value) || !value.nil?
+        end
+
+        put(API_PATH + '/' + id.to_s, params)
+      end
+
+      def delete(id)
+        super(API_PATH + '/' + id.to_s)
+      end
+    end
+  end
+end

data/lib/timekit/event.rb

@@ -0,0 +1,6 @@
+require_relative './event/client'
+
+module Timekit
+  class Event
+  end
+end

data/lib/timekit/filtercollection.rb

@@ -0,0 +1,87 @@
+module Timekit
+  class Filtercollection
+    DAYS = %w(
+      Monday
+      Tuesday
+      Wednesday
+      Thursday
+      Friday
+      Saturday
+      Sunday
+    ).freeze
+
+    def initialize
+      @and_conditions = []
+      @or_conditions = []
+      @after_conditions = []
+    end
+
+    def as_json
+      {
+        or: @or_conditions,
+        and: @and_conditions,
+        after: @after_conditions
+      }
+    end
+
+    def after_take_random(num)
+      @after_conditions << { take_random: { number: num } }
+    end
+
+    def after_take_first(num)
+      @after_conditions << { take_first: { number: num } }
+    end
+
+    def after_take_last(num)
+      @after_conditions << { take_last: { number: num } }
+    end
+
+    def and_only_during_business_hours(timezone = nil)
+      @and_conditions << { business_hours: timezone_param(timezone) }
+    end
+
+    def and_not_on_weekends(timezone = nil)
+      @and_conditions << { exclude_weekends: timezone_param(timezone) }
+    end
+
+    def and_on_day(day)
+      @and_conditions << specific_day(day)
+    end
+
+    def or_on_any_days(days)
+      days.each { |day| @or_conditions << specific_day(day) }
+    end
+
+    def or_between_times(timestamp1, timestamp2)
+      @or_conditions << {
+        between_timestamps: {
+          start: timestamp1,
+          end: timestamp2
+        }
+      }
+    end
+
+    private
+
+    def timezone_param(timezone)
+      timezone ? { timezone: timezone } : {}
+    end
+
+    def specific_day(day)
+      raise "Invalid day #{day}" unless DAYS.include?(day)
+      { specific_day: { day: day } }
+    end
+
+    # def specific_day_and_time(day, start_time, end_time, timezone)
+    #   raise "Invalid day #{day}" unless DAYS.include?(day)
+    #
+    #   {
+    #     specific_day_and_time: {
+    #       day: day,
+    #       start: start_time,
+    #       end: end_time
+    #     }.merge!(timezone_param(timezone))
+    #   }
+    # end
+  end
+end

data/lib/timekit/findtime/client.rb

@@ -0,0 +1,41 @@
+module Timekit
+  class Findtime
+    # Client class for the findtime resource
+    class Client < Timekit::Client
+      API_PATH = '/findtime'.freeze
+
+      def query(
+        emails = nil,
+        user_ids = nil,
+        calendar_ids = nil,
+        filters = {},
+        filtercollection_id = nil,
+        start = nil,
+        future = '2 days',
+        length = '1 hour',
+        sort = 'asc',
+        ignore_all_day_events = false,
+        all_solutions = false
+      )
+        params = {}
+
+        # All args are optional, so we can examine each arg and
+        # set it as a key in the params hash if a value exists for the arg
+        method(__method__).parameters.map do |_, name|
+          value = binding.local_variable_get(name)
+          params[name.to_sym] = value if [true, false].include?(value) ||
+                                         !value.nil?
+        end
+
+        raise 'Entity id required to find time'\
+          ' (email,user id,calendar id)' unless
+          params[:emails] || params[:user_ids] || params[:calendar_ids]
+
+        post(API_PATH, params)
+      end
+
+      def bulk_query(queries)
+      end
+    end
+  end
+end

data/lib/timekit/findtime/filtercollections/client.rb

@@ -0,0 +1,28 @@
+module Timekit
+  class Findtime
+    class Filtercollections
+      # Client class for the filtercollection resource
+      class Client < Timekit::Client
+        API_PATH = '/findtime/filtercollections'.freeze
+
+        def create(
+          and_conditions = nil,
+          or_conditions = nil,
+          after_conditions = nil
+        )
+          params = {
+            and: and_conditions,
+            or: or_conditions,
+            after: after_conditions
+          }
+
+          post(API_PATH, params)
+        end
+
+        def show(id)
+          get(API_PATH + '/' + id.to_s)
+        end
+      end
+    end
+  end
+end

data/lib/timekit/findtime.rb

@@ -0,0 +1,6 @@
+require_relative './findtime/client'
+
+module Timekit
+  class Findtime
+  end
+end

data/lib/timekit/request.rb

@@ -0,0 +1,39 @@
+require 'singleton'
+require 'rest-client'
+
+module Timekit
+  # class for executing http requests against timekit api
+  class Request
+    include Singleton
+
+    BASE_URL = 'https://api.timekit.io/v2'.freeze
+
+    [:get, :put, :post, :delete].each do |verb|
+      define_method(verb) do |path, params, headers|
+        request __method__, path, params, headers
+      end
+    end
+
+    private
+
+    def request(verb, path, params, headers)
+      headers = headers.merge!(http_headers)
+
+      # puts "Timekit::Request::request #{verb},"\
+      # " #{BASE_URL}#{path}, #{params}, #{headers}"
+      RestClient::Request.execute(
+        method: verb.downcase.to_sym,
+        url: "#{BASE_URL}#{path}",
+        payload: params ? params.to_json : nil,
+        headers: headers
+      )
+    end
+
+    def http_headers
+      {
+        content_type: 'application/json',
+        accept: 'application/json'
+      }
+    end
+  end
+end

data/lib/timekit/user/client.rb

@@ -0,0 +1,40 @@
+module Timekit
+  class User
+    # Client class for the user resource
+    class Client < Timekit::Client
+      API_PATH = '/users'.freeze
+
+      def me
+        get(API_PATH + '/me')
+      end
+
+      def timezone(email)
+        get(API_PATH + '/timezone/' + email)
+      end
+
+      def update(
+        first_name = nil,
+        last_name = nil,
+        timezone = nil,
+        password = nil
+      )
+        params = {}
+
+        params[:first_name] = first_name if first_name
+        params[:last_name] = last_name if last_name
+        params[:timezone] = timezone if timezone
+        params[:password] = password if password
+
+        put(API_PATH + '/me', params)
+      end
+
+      def reset_password(email)
+        params = {
+          email: email
+        }
+
+        post(API_PATH + '/resetpassword', params)
+      end
+    end
+  end
+end

data/lib/timekit/user.rb

@@ -0,0 +1,45 @@
+require_relative './user/client'
+
+module Timekit
+  # this class is used for User creation
+  class User
+    # this hits a public endpoint, no authorization required
+    def self.create(
+      email,
+      timezone,
+      first_name,
+      last_name = nil,
+      password = nil
+    )
+
+      params = {
+        email: email,
+        timezone: timezone,
+        first_name: first_name
+      }
+      params[:last_name] = last_name if last_name
+      params[:password] = password if password
+
+      Timekit::Request.instance.send(
+        :post,
+        "#{Timekit.config[:api_endpoint]}#{Timekit::User::Client::API_PATH}",
+        params,
+        'Timekit-App' => Timekit.config[:app]
+      )
+    end
+
+    def self.auth(email, password)
+      params = {
+        email: email,
+        password: password
+      }
+
+      Timekit::Request.instance.send(
+        :post,
+        "#{Timekit.config[:api_endpoint]}/auth",
+        params,
+        'Timekit-App' => Timekit.config[:app]
+      )
+    end
+  end
+end

data/lib/timekit/version.rb

@@ -0,0 +1,45 @@
+module Timekit
+  module Version
+    module_function
+
+    # @return [Integer]
+    def major
+      0
+    end
+
+    # @return [Integer]
+    def minor
+      1
+    end
+
+    # @return [Integer]
+    def patch
+      0
+    end
+
+    # @return [Integer, NilClass]
+    def pre
+      nil
+    end
+
+    # @return [Hash]
+    def to_h
+      {
+        major: major,
+        minor: minor,
+        patch: patch,
+        pre: pre
+      }
+    end
+
+    # @return [Array]
+    def to_a
+      [major, minor, patch, pre].compact
+    end
+
+    # @return [String]
+    def to_s
+      to_a.join('.')
+    end
+  end
+end

data/lib/timekit/widget/client.rb

@@ -0,0 +1,54 @@
+module Timekit
+  class Widget
+    # Client class for the widget resource
+    class Client < Timekit::Client
+      API_PATH = '/widgets'.freeze
+
+      def list
+        get(API_PATH)
+      end
+
+      def embed(id)
+        get(API_PATH + '/embed/' + id.to_s)
+      end
+
+      def hosted(slug)
+        get(API_PATH + '/hosted/' + slug)
+      end
+
+      def update(
+        id,
+        config,
+        name = nil,
+        slug = nil
+      )
+        params = {
+          config: config
+        }
+
+        params[:name] = name if name
+        params[:slug] = slug if slug
+
+        put(API_PATH + '/' + id.to_s, params)
+      end
+
+      def create(
+        config,
+        name,
+        slug
+      )
+        params = {
+          config: config,
+          name: name,
+          slug: slug
+        }
+
+        post(API_PATH, params)
+      end
+
+      def delete(id)
+        super(API_PATH + '/' + id.to_s)
+      end
+    end
+  end
+end

data/lib/timekit/widget.rb

@@ -0,0 +1,6 @@
+require_relative './widget/client'
+
+module Timekit
+  class Widget
+  end
+end

data/lib/timekit.rb

@@ -0,0 +1,65 @@
+require_relative './timekit/config'
+require_relative './timekit/client'
+require_relative './timekit/authorization'
+require_relative './timekit/user'
+require_relative './timekit/credential'
+require_relative './timekit/app'
+require_relative './timekit/calendar'
+require_relative './timekit/event'
+require_relative './timekit/request'
+require_relative './timekit/findtime'
+require_relative './timekit/filtercollection'
+require_relative './timekit/widget'
+require_relative './timekit/booking'
+
+# Timekit class is responsible for handling configurations
+# and provides helpers for instantiating clients for apis
+module Timekit
+  @config = Timekit::Config.new
+
+  def self.config
+    @config
+  end
+
+  def self.configure(configurations)
+    config[:app] = configurations[:app] if configurations[:app]
+
+    email = configurations[:email]
+    token = configurations[:api_token]
+    config[:credentials] = Timekit::Authorization.new(
+      email, token
+    ) if email && token
+  end
+
+  def self.calendar_client
+    Timekit::Calendar::Client.new(config[:app], config[:credentials])
+  end
+
+  def self.app_client
+    Timekit::App::Client.new(config[:app], config[:credentials])
+  end
+
+  def self.credential_client
+    Timekit::Credential::Client.new(config[:app], config[:credentials])
+  end
+
+  def self.event_client
+    Timekit::Event::Client.new(config[:app], config[:credentials])
+  end
+
+  def self.user_client
+    Timekit::User::Client.new(config[:app], config[:credentials])
+  end
+
+  def self.findtime_client
+    Timekit::Findtime::Client.new(config[:app], config[:credentials])
+  end
+
+  def self.widget_client
+    Timekit::Widget::Client.new(config[:app], config[:credentials])
+  end
+
+  def self.booking_client
+    Timekit::Booking::Client.new(config[:app], config[:credentials])
+  end
+end

data/timekit.gemspec

@@ -0,0 +1,22 @@
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'timekit/version'
+
+Gem::Specification.new do |s|
+  s.add_dependency 'rest-client', '~> 1.6'
+  s.name        = 'timekit'
+  s.version     = '0.1.0'
+  s.date        = '2016-06-02'
+  s.description = 'A gem to interact with the timekit.io api'
+  s.summary     = s.description
+  s.authors     = ['Michael Gauthier']
+  s.email       = 'michael.gauthier@gmail.com'
+  s.files       = ['lib/timekit.rb']
+  s.homepage    = 'http://rubygems.org/gems/timekit'
+  s.license     = 'MIT'
+  s.require_paths = %w(lib)
+  s.files = %w(
+    CHANGELOG.md CONTRIBUTING.md LICENSE.md README.md timekit.gemspec
+  ) + Dir['lib/**/*.rb']
+  s.version = Timekit::Version
+end

metadata

@@ -0,0 +1,87 @@
+--- !ruby/object:Gem::Specification
+name: timekit
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Michael Gauthier
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-06-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rest-client
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+description: A gem to interact with the timekit.io api
+email: michael.gauthier@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- CONTRIBUTING.md
+- LICENSE.md
+- README.md
+- lib/timekit.rb
+- lib/timekit/app.rb
+- lib/timekit/app/client.rb
+- lib/timekit/authorization.rb
+- lib/timekit/booking.rb
+- lib/timekit/booking/client.rb
+- lib/timekit/calendar.rb
+- lib/timekit/calendar/client.rb
+- lib/timekit/client.rb
+- lib/timekit/config.rb
+- lib/timekit/credential.rb
+- lib/timekit/credential/client.rb
+- lib/timekit/event.rb
+- lib/timekit/event/client.rb
+- lib/timekit/filtercollection.rb
+- lib/timekit/findtime.rb
+- lib/timekit/findtime/client.rb
+- lib/timekit/findtime/filtercollections/client.rb
+- lib/timekit/request.rb
+- lib/timekit/user.rb
+- lib/timekit/user/client.rb
+- lib/timekit/version.rb
+- lib/timekit/widget.rb
+- lib/timekit/widget/client.rb
+- timekit.gemspec
+homepage: http://rubygems.org/gems/timekit
+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 gem to interact with the timekit.io api
+test_files: []
+has_rdoc: