operto 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 0cf8a26aabacf6a653ef155a836d95ef727b29794a0f1fbdf1365d2306ba0a4b
+  data.tar.gz: 300fc9d056683aa3d1cedc322b887b263b454c4449a84592875484624dafd320
+SHA512:
+  metadata.gz: 12713010ba3c3b7b909e1c54e959bf00411647352f959862446f54c40ad443461af683c141057f0cf59e192191cb8866ee04c82bba929ddad6b7857fa3c2ae4f
+  data.tar.gz: e609b53f901d429bc8957decbf04029e26b815e7ae266f1929d3d3000810026a10025111c9b2ab3854987d12aded73cdc23d1175a2253d15a10e4a9c12a7beaa

data/lib/operto/access_tokens/upsert.rb

@@ -0,0 +1,63 @@
+module Operto
+  module AccessTokens
+    # Ensures a live access token: reuse the stored one, else refresh, else log
+    # in fresh. All persistence/caching/expiry policy lives in the injected
+    # token store (Operto.config.token_store).
+    class Upsert
+      include Operto::Operation
+
+      OAUTH_ENDPOINT   = 'oauth/login'.freeze
+      REFRESH_ENDPOINT = 'oauth/refresh'.freeze
+
+      # @rbs () -> Dry::Monads::Result[untyped]
+      def call
+        token = store.active
+        return Success(token) if token
+
+        attempt_refresh || request_new_token
+      rescue StandardError => e
+        Failure(e)
+      end
+
+      private
+
+      def store
+        Operto.config.token_store
+      end
+
+      def attempt_refresh
+        token = store.refreshable
+        return unless token
+
+        response = Operto::Client.connection(skip_auth: true).get(REFRESH_ENDPOINT) do |req|
+          req.headers['Authorization'] = "VRS #{token.refresh_token}"
+        end
+
+        return unless Operto::Client.successful_response?(response)
+
+        Success(update_token(response.body, refresh_only: true))
+      end
+
+      def request_new_token
+        response = Operto::Client.connection(skip_auth: true).post(OAUTH_ENDPOINT) do |req|
+          req.body = { API_Key: Operto::Client.client_id, API_Value: Operto::Client.secret }
+        end
+
+        Operto::Client.handle_response(response) { |body| update_token(body) }
+      end
+
+      def update_token(body, refresh_only: false)
+        access = body[:Access_Token]
+        attributes = { access_token: access[:token], expires_at: access[:Expiry].to_i.seconds.from_now }
+
+        unless refresh_only
+          refresh = body[:Refresh_Token]
+          attributes[:refresh_token] = refresh[:token]
+          attributes[:refresh_expires_at] = refresh[:Expiry].to_i.seconds.from_now
+        end
+
+        store.save(**attributes)
+      end
+    end
+  end
+end

data/lib/operto/client.rb

@@ -0,0 +1,81 @@
+module Operto
+  # The single HTTP gateway: Faraday connection, auth header, retry, and Operto's
+  # quirky response envelope (a 200 with ReasonCode >= 300 is a failure).
+  module Client
+    extend self
+    include Dry::Monads[:result]
+
+    RETRY_OPTIONS = {
+      max: 3,
+      interval: 1.0,
+      interval_randomness: 0.5,
+      backoff_factor: 2,
+      retry_statuses: [401, 429, 502, 503, 504],
+      exceptions: [*Faraday::Retry::Middleware::DEFAULT_EXCEPTIONS, Faraday::ConnectionFailed],
+      methods: [*Faraday::Retry::Middleware::IDEMPOTENT_METHODS, :patch, :post],
+      retry_block: ->(env:, **) { Operto.config.token_store.clear if env.status == 401 }
+    }.freeze
+
+    def connection(url: Operto.config.base_url, skip_auth: false)
+      Faraday.new(url:) do |builder|
+        builder.request :authorization, 'VRS', -> { auth_token } unless skip_auth
+
+        builder.request :json
+        builder.request :retry, RETRY_OPTIONS
+        builder.request :url_encoded
+        builder.response :json, parser_options: { symbolize_names: true, mode: :rails, decoder: [Oj, :load] }
+        builder.options[:timeout] = 20
+      end
+    end
+
+    def handle_response(response, &block)
+      return Failure(formatted_error(response)) unless successful_response?(response)
+
+      Success(block ? block.call(response_body(response)) : true)
+    end
+
+    def successful_response?(response)
+      body = response_body(response)
+      reason_code = body[:ReasonCode]
+
+      response.success? && (reason_code.nil? || reason_code.to_i < 300)
+    end
+
+    def formatted_error(response)
+      body = response_body(response)
+      reason_code = body[:ReasonCode] || response.status
+      reason_text = body[:ReasonText] || body[:Message] || response.body.to_s
+
+      Operto::Error.new("#{reason_code}: #{reason_text}")
+    end
+
+    def response_body(response)
+      body = response.body
+      return body if body.is_a?(Hash)
+
+      parsed_body_from_string(body)
+    end
+
+    def parsed_body_from_string(body)
+      string_body = body.to_s
+      return {} if string_body.empty?
+
+      parsed = Oj.load(string_body, symbol_keys: true)
+      parsed.is_a?(Hash) ? parsed : {}
+    rescue StandardError
+      {}
+    end
+
+    def auth_token
+      AccessTokens::Upsert.new.call!.value!.access_token
+    end
+
+    def client_id
+      Operto.config.client_id
+    end
+
+    def secret
+      Operto.config.secret
+    end
+  end
+end

data/lib/operto/config.rb

@@ -0,0 +1,13 @@
+module Operto
+  # Injected by the host app (see the Operto.configure initializer): the API
+  # credentials, a cache, and a token store. Keeping these out of the gem is
+  # what makes it host-agnostic.
+  class Config
+    attr_accessor :client_id, :secret, :token_store, :base_url
+
+    def initialize
+      @base_url = 'https://teams-api.operto.com/api/v1/'.freeze
+      @token_store = MemoryTokenStore.new
+    end
+  end
+end

data/lib/operto/error.rb

@@ -0,0 +1,6 @@
+module Operto
+  class Error < StandardError; end
+
+  # Raised by operations for malformed arguments before any network call.
+  class ArgumentError < Error; end
+end

data/lib/operto/filtered_pagination.rb

@@ -0,0 +1,35 @@
+module Operto
+  # Including class must define FILTER_MAPPINGS (Hash), DATE_KEYS (Array<Symbol>), DEFAULT_SORT (String).
+  module FilteredPagination
+    FILTER_MAPPINGS = {}.freeze
+    DATE_KEYS = [].freeze
+    DEFAULT_SORT = ''.freeze
+
+    private
+
+    def validate_arguments!(attributes)
+      argument! attributes: :invalid unless attributes.is_a?(Hash) && attributes.present? && attributes.values.none?(&:blank?)
+
+      invalid_keys = attributes.keys - self.class::FILTER_MAPPINGS.keys
+      argument! attributes: :invalid_keys if invalid_keys.any?
+    end
+
+    def build_query_params(attributes, skip, take)
+      params = {
+        per_page: take,
+        page: skip.div(take) + 1,
+        Sort: self.class::DEFAULT_SORT
+      }
+
+      attributes.each do |key, value|
+        params[self.class::FILTER_MAPPINGS[key]] = format_attribute_value(key, value)
+      end
+
+      params
+    end
+
+    def format_attribute_value(key, value)
+      self.class::DATE_KEYS.include?(key) ? value.strftime('%Y%m%d') : value
+    end
+  end
+end

data/lib/operto/homes/index.rb

@@ -0,0 +1,54 @@
+module Operto
+  module Homes
+    class Index
+      include Operto::Operation
+
+      DEFAULT_PAGE_SIZE = 25
+
+      # @rbs (?skip: ::Integer, ?take: ::Integer) -> Dry::Monads::Result[::Hash[::Symbol, untyped]]
+      def call(skip: 0, take: DEFAULT_PAGE_SIZE)
+        query_params = build_query_params(skip, take)
+        response = Operto::Client.connection.get('properties', query_params)
+        Operto::Client.handle_response(response) { |body| format_results(body) }
+      rescue StandardError => e
+        Failure(e)
+      end
+
+      private
+
+      def build_query_params(skip, take)
+        page = skip.div(take) + 1
+
+        {
+          per_page: take,
+          page:
+        }
+      end
+
+      def format_results(body)
+        results = body.fetch(:data, []).map { |home| format_home(home) }
+
+        formatted = body.dup
+        formatted[:results] = results
+        formatted[:count] = body[:total_items] || results.size
+        formatted
+      end
+
+      def format_home(home)
+        normalized = home.transform_keys { |key| key.to_s.underscore.to_sym }
+
+        normalized.merge(
+          created_at: parse_date(normalized[:create_date])
+        )
+      end
+
+      def parse_date(value)
+        return if value.blank?
+
+        Date.strptime(value.to_s, '%Y%m%d')
+      rescue ArgumentError
+        value
+      end
+    end
+  end
+end

data/lib/operto/issue_types.rb

@@ -0,0 +1,11 @@
+module Operto
+  module IssueTypes
+    ISSUE_TYPES = {
+      0 => 'damage',
+      1 => 'maintenance',
+      2 => 'lost_and_found',
+      3 => 'supply_flag',
+      -1 => 'unclassified'
+    }.freeze
+  end
+end

data/lib/operto/issues/close.rb

@@ -0,0 +1,29 @@
+module Operto
+  module Issues
+    class Close
+      include Operto::Operation
+
+      # @rbs (issue_id: ::Integer | ::String) -> Dry::Monads::Result[::Hash[::Symbol, untyped]]
+      def call(issue_id:)
+        argument! issue_id: :required if issue_id.blank?
+
+        response = Operto::Client.connection.post('issues', close_body(issue_id))
+        Operto::Client.handle_response(response) { |body| { issue_id: body.dig(:Data, :IssueID) } }
+      rescue StandardError => e
+        Failure(e)
+      end
+
+      private
+
+      def close_body(issue_id)
+        {
+          request: {
+            IssueID: issue_id,
+            Update: true,
+            ClosedDate: Date.current.strftime('%Y%m%d')
+          }.to_json
+        }
+      end
+    end
+  end
+end

data/lib/operto/issues/index.rb

@@ -0,0 +1,71 @@
+module Operto
+  module Issues
+    class Index
+      include Operto::Operation
+
+      # @rbs (start_date: ::Date, ?skip: ::Integer, ?take: ::Integer) -> Dry::Monads::Result[::Hash[::Symbol, untyped]]
+      def call(start_date:, skip: 0, take: 50)
+        query_params = build_query_params(start_date, skip, take)
+        response = Operto::Client.connection.get('issues', query_params)
+        Operto::Client.handle_response(response) { |body| format_results(body) }
+      rescue StandardError => e
+        Failure(e)
+      end
+
+      private
+
+      def build_query_params(start_date, skip, take)
+        page = skip.div(take) + 1
+
+        {
+          per_page: take,
+          page:,
+          closed: 0,
+          CreateStartDate: start_date.strftime('%Y%m%d'),
+          Sort: 'IssueID desc'
+        }
+      end
+
+      def format_results(body)
+        results = body[:data].map { |issue| format_issue(issue) }
+
+        {
+          results:,
+          count: body[:total_items] || results.size
+        }
+      end
+
+      def format_issue(issue)
+        issue_type = deduce_issue_type(issue[:IssueType])
+
+        {
+          issue_id: issue[:IssueID],
+          status_id: issue[:StatusID],
+          issue_type:,
+          issue_type_name: issue_type.humanize,
+          urgent: issue[:Urgent],
+          issue: issue[:Issue],
+          notes: issue[:Notes],
+          staff_notes: issue[:StaffNotes],
+          property_id: issue[:PropertyID],
+          billable: issue[:Billable],
+          create_date: issue[:CreateDate]&.to_date,
+          submitted_by_servicer_id: issue[:SubmittedByServicerID],
+          images: extract_images(issue[:Images])
+        }
+      end
+
+      def deduce_issue_type(raw_type)
+        raw_type = -1 unless Operto::IssueTypes::ISSUE_TYPES.key?(raw_type)
+
+        Operto::IssueTypes::ISSUE_TYPES[raw_type]
+      end
+
+      def extract_images(images)
+        Array(images).map do |image|
+          { issue_image_id: image[:IssueImageID], image_url: image[:Image] }
+        end
+      end
+    end
+  end
+end

data/lib/operto/memory_token_store.rb

@@ -0,0 +1,31 @@
+module Operto
+  # The default token store: keeps the token in memory for the life of the
+  # process. Fine for a single long-running process (the token simply re-issues
+  # after a restart); provide a shared/persistent store for multi-process
+  # deployments.
+  class MemoryTokenStore
+    Token = Struct.new(:access_token, :refresh_token, :refresh_expires_at, :expires_at, keyword_init: true) do
+      def expired?
+        expires_at.nil? || expires_at < Time.now
+      end
+    end
+
+    REFRESH_BUFFER = 120
+
+    def active
+      @token if @token && !@token.expired?
+    end
+
+    def refreshable
+      @token if @token&.refresh_expires_at && @token.refresh_expires_at > Time.now + REFRESH_BUFFER
+    end
+
+    def save(access_token:, expires_at:, refresh_token: nil, refresh_expires_at: nil)
+      @token = Token.new(access_token:, expires_at:, refresh_token:, refresh_expires_at:)
+    end
+
+    def clear
+      @token = nil
+    end
+  end
+end

data/lib/operto/operation.rb

@@ -0,0 +1,31 @@
+module Operto
+  # Shared monadic contract for the client operations: #call returns a Result,
+  # #call! unwraps it and raises the underlying failure.
+  module Operation
+    def self.included(base)
+      base.include Dry::Monads[:result]
+    end
+
+    def call!(...)
+      result = call(...)
+      raise result.failure if result.failure?
+
+      result
+    end
+
+    private
+
+    def argument!(**attrs)
+      key, reason = attrs.first
+      raise Operto::ArgumentError, "#{key}: #{reason}"
+    end
+
+    def required_attribute!(key)
+      raise Operto::ArgumentError, "#{key}: required"
+    end
+
+    def invalid_attribute!(key, type:)
+      raise Operto::ArgumentError, "#{key}: expected #{type}"
+    end
+  end
+end

data/lib/operto/staff/index.rb

@@ -0,0 +1,59 @@
+module Operto
+  module Staff
+    class Index
+      include Operto::Operation
+
+      DEFAULT_PAGE_SIZE = 100
+
+      # @rbs (?skip: ::Integer, ?take: ::Integer) -> Dry::Monads::Result[::Hash[::Symbol, untyped]]
+      def call(skip: 0, take: DEFAULT_PAGE_SIZE)
+        query_params = build_query_params(skip, take)
+        response = Operto::Client.connection.get('staff', query_params)
+        Operto::Client.handle_response(response) { |body| format_results(body) }
+      rescue StandardError => e
+        Failure(e)
+      end
+
+      private
+
+      def build_query_params(skip, take)
+        page = skip.div(take) + 1
+
+        {
+          per_page: take,
+          page:
+        }
+      end
+
+      def format_results(body)
+        results = body.fetch(:data, []).map { |staff| format_staff(staff) }
+
+        {
+          results:,
+          count: body[:total_items] || results.size
+        }
+      end
+
+      def format_staff(staff)
+        {
+          staff_id: staff[:StaffID],
+          name: staff[:Name],
+          abbreviation: staff[:Abbreviation],
+          email: staff[:Email]&.downcase,
+          phone: staff[:Phone],
+          country_id: staff[:CountryID],
+          active: staff[:Active],
+          created_at: parse_date(staff[:CreateDate])
+        }
+      end
+
+      def parse_date(value)
+        return if value.blank?
+
+        Date.parse(value.to_s)
+      rescue ArgumentError
+        value
+      end
+    end
+  end
+end

data/lib/operto/staff_task_times/index.rb

@@ -0,0 +1,51 @@
+module Operto
+  module StaffTaskTimes
+    class Index
+      include Operto::Operation
+      include FilteredPagination
+
+      FILTER_MAPPINGS = {
+        task_id: 'TaskID',
+        staff_id: 'StaffID',
+        property_id: 'PropertyID',
+        start_date: 'StartDate',
+        end_date: 'EndDate'
+      }.freeze
+
+      DATE_KEYS = %i[start_date end_date].freeze
+      DEFAULT_SORT = 'StaffTaskTimeID desc'.freeze
+
+      # @rbs (?attributes: ::Hash[::Symbol, untyped], ?skip: ::Integer, ?take: ::Integer) -> Dry::Monads::Result[::Hash[::Symbol, untyped]]
+      def call(attributes: {}, skip: 0, take: 50)
+        validate_arguments!(attributes)
+
+        query_params = build_query_params(attributes, skip, take)
+        response = Operto::Client.connection.get('stafftasktimes', query_params)
+
+        Operto::Client.handle_response(response) { |body| format_results(body) }
+      rescue StandardError => e
+        Failure(e)
+      end
+
+      private
+
+      def format_results(body)
+        results = body[:data].map do |entry|
+          {
+            staff_task_time_id: entry[:StaffTaskTimeID],
+            staff_id: entry[:StaffID],
+            task_id: entry[:TaskID],
+            clock_in: entry[:ClockIn]&.to_datetime,
+            clock_out: entry[:ClockOut]&.to_datetime,
+            note: entry[:Note]
+          }
+        end
+
+        {
+          results:,
+          count: body[:total_items] || results.size
+        }
+      end
+    end
+  end
+end

data/lib/operto/staff_tasks/create.rb

@@ -0,0 +1,33 @@
+module Operto
+  module StaffTasks
+    class Create
+      include Operto::Operation
+
+      # @rbs (task_id: ::String, staff_id: ::String, property_id: ::String) -> Dry::Monads::Result[::Hash[::Symbol, untyped]]
+      def call(task_id:, staff_id:, property_id:)
+        validate_arguments!(task_id, staff_id, property_id)
+
+        response = Operto::Client.connection.post('stafftasks', request_attributes(task_id, staff_id, property_id))
+        Operto::Client.handle_response(response) { |body| { staff_task_id: body[:StaffTaskID] } }
+      rescue StandardError => e
+        Failure(e)
+      end
+
+      private
+
+      def validate_arguments!(task_id, staff_id, property_id)
+        argument! task_id: :required if task_id.blank?
+        argument! staff_id: :required if staff_id.blank?
+        argument! property_id: :required if property_id.blank?
+      end
+
+      def request_attributes(task_id, staff_id, property_id)
+        {
+          TaskID: task_id,
+          StaffID: staff_id,
+          PropertyID: property_id
+        }
+      end
+    end
+  end
+end

data/lib/operto/staff_tasks/destroy.rb

@@ -0,0 +1,23 @@
+module Operto
+  module StaffTasks
+    class Destroy
+      include Operto::Operation
+
+      # @rbs (staff_task_id: ::String) -> Dry::Monads::Result[bool]
+      def call(staff_task_id:)
+        validate_arguments!(staff_task_id)
+
+        response = Operto::Client.connection.delete("stafftasks/#{staff_task_id}")
+        Operto::Client.handle_response(response)
+      rescue StandardError => e
+        Failure(e)
+      end
+
+      private
+
+      def validate_arguments!(staff_task_id)
+        argument! staff_task_id: :required if staff_task_id.blank?
+      end
+    end
+  end
+end

data/lib/operto/tasks/create.rb

@@ -0,0 +1,34 @@
+module Operto
+  module Tasks
+    class Create
+      include Operto::Operation
+      include Shared
+
+      # @rbs (attributes: ::Hash[::Symbol, untyped]) -> Dry::Monads::Result[::Hash[::Symbol, untyped]]
+      def call(attributes:)
+        validate_arguments!(attributes)
+
+        request_attributes = prepare_attributes(attributes)
+        response = Operto::Client.connection.post('tasks', request_attributes)
+
+        handle_task_response(response)
+      rescue StandardError => e
+        Failure(e)
+      end
+
+      private
+
+      def validate_arguments!(attributes)
+        argument! attributes: :invalid unless attributes.is_a?(Hash) && attributes.present?
+
+        required_keys.each do |key|
+          required_attribute!(key) if attributes[key].blank?
+        end
+      end
+
+      def required_keys
+        %i[house_id name start_date end_date rule_id]
+      end
+    end
+  end
+end

data/lib/operto/tasks/index.rb

@@ -0,0 +1,70 @@
+module Operto
+  module Tasks
+    class Index
+      include Operto::Operation
+      include FilteredPagination
+
+      FILTER_MAPPINGS = {
+        property_id: 'PropertyID',
+        task_rule_id: 'TaskRuleID',
+        approved_start_date: 'ApprovedStartDate',
+        approved_end_date: 'ApprovedEndDate',
+        completed_start_date: 'CompletedStartDate',
+        completed_end_date: 'CompletedEndDate',
+        task_start_date: 'TaskStartDate',
+        task_end_date: 'TaskEndDate'
+      }.freeze
+
+      DATE_KEYS = %i[
+        approved_start_date approved_end_date
+        completed_start_date completed_end_date
+        task_start_date task_end_date
+      ].freeze
+
+      DEFAULT_SORT = 'TaskID desc'.freeze
+
+      # @rbs (?attributes: ::Hash[::Symbol, untyped], ?skip: ::Integer, ?take: ::Integer) -> Dry::Monads::Result[::Hash[::Symbol, untyped]]
+      def call(attributes: {}, skip: 0, take: 50)
+        validate_arguments!(attributes)
+
+        query_params = build_query_params(attributes, skip, take)
+        response = Operto::Client.connection.get('tasks', query_params)
+        Operto::Client.handle_response(response) { |body| format_results(body) }
+      rescue StandardError => e
+        Failure(e)
+      end
+
+      private
+
+      def format_results(body)
+        results = body[:data].map do |task|
+          {
+            task_id: task[:TaskID],
+            property_id: task[:PropertyID],
+            approved_at: task[:ApprovedDate]&.to_datetime,
+            completed_at: task[:CompleteConfirmedDate]&.to_datetime,
+            staff: extract_staff(task[:Staff])
+          }
+        end
+
+        {
+          results:,
+          count: body[:total_items] || results.size
+        }
+      end
+
+      def extract_staff(staff_array)
+        return [] if staff_array.blank?
+
+        staff_array.map do |staff|
+          {
+            staff_id: staff[:StaffID],
+            name: staff[:Name],
+            email: staff[:Email]&.downcase,
+            active: staff[:Active]
+          }
+        end
+      end
+    end
+  end
+end

data/lib/operto/tasks/shared.rb

@@ -0,0 +1,44 @@
+module Operto
+  module Tasks
+    module Shared
+      private
+
+      def prepare_attributes(attrs)
+        base_attrs = {
+          PropertyID: attrs[:house_id],
+          TaskRuleID: attrs[:rule_id],
+          TaskName: attrs[:name],
+          TaskDescription: attrs[:description].presence || '-'
+        }.compact_blank
+
+        base_attrs.merge(datetime_attributes(attrs))
+      end
+
+      def datetime_attributes(attrs)
+        h = {}
+
+        start_date = parse_datetime(attrs[:start_date])
+        h[:TaskDate] = h[:TaskStartDate] = as_date(start_date)
+        h[:TaskTime] = h[:TaskStartTime] = start_date.hour
+
+        complete_by = parse_datetime(attrs[:end_date])
+        h[:TaskCompleteByDate] = as_date(complete_by)
+        h[:TaskCompleteByTime] = complete_by.hour
+
+        h
+      end
+
+      def parse_datetime(value)
+        Time.zone.parse(value.to_s)
+      end
+
+      def as_date(value)
+        value.strftime('%Y-%m-%d')
+      end
+
+      def handle_task_response(response)
+        Operto::Client.handle_response(response) { |body| { task_id: body[:TaskID] } }
+      end
+    end
+  end
+end

data/lib/operto/tasks/update.rb

@@ -0,0 +1,27 @@
+module Operto
+  module Tasks
+    class Update
+      include Operto::Operation
+      include Shared
+
+      # @rbs (task_id: ::String, attributes: ::Hash[::Symbol, untyped]) -> Dry::Monads::Result[::Hash[::Symbol, untyped]]
+      def call(task_id:, attributes:)
+        validate_arguments!(task_id, attributes)
+
+        request_attributes = prepare_attributes(attributes).compact_blank
+        response = Operto::Client.connection.put("tasks/#{task_id}", request_attributes)
+
+        handle_task_response(response)
+      rescue StandardError => e
+        Failure(e)
+      end
+
+      private
+
+      def validate_arguments!(task_id, attributes)
+        argument! task_id: :required if task_id.blank?
+        argument! attributes: :invalid if attributes.blank?
+      end
+    end
+  end
+end

data/lib/operto/version.rb

@@ -0,0 +1,3 @@
+module Operto
+  VERSION = '0.1.0'.freeze
+end

data/lib/operto.rb

@@ -0,0 +1,41 @@
+require 'active_support'
+require 'active_support/core_ext'
+require 'dry/monads'
+require 'faraday'
+require 'faraday/retry'
+require 'oj'
+
+require_relative 'operto/version'
+require_relative 'operto/error'
+require_relative 'operto/memory_token_store'
+require_relative 'operto/config'
+require_relative 'operto/operation'
+require_relative 'operto/client'
+require_relative 'operto/issue_types'
+require_relative 'operto/filtered_pagination'
+require_relative 'operto/access_tokens/upsert'
+require_relative 'operto/tasks/shared'
+require_relative 'operto/tasks/create'
+require_relative 'operto/tasks/update'
+require_relative 'operto/tasks/index'
+require_relative 'operto/staff_tasks/create'
+require_relative 'operto/staff_tasks/destroy'
+require_relative 'operto/staff_task_times/index'
+require_relative 'operto/issues/index'
+require_relative 'operto/issues/close'
+require_relative 'operto/homes/index'
+require_relative 'operto/staff/index'
+
+module Operto
+  class << self
+    # @rbs () { (Config) -> void } -> void
+    def configure
+      yield(config)
+    end
+
+    # @rbs () -> Config
+    def config
+      @config ||= Config.new
+    end
+  end
+end

metadata

@@ -0,0 +1,129 @@
+--- !ruby/object:Gem::Specification
+name: operto
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Guestit
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !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: dry-monads
+  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: faraday
+  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: faraday-retry
+  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: oj
+  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: HTTP client and operations for the Operto Teams API, decoupled from the
+  host application.
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/operto.rb
+- lib/operto/access_tokens/upsert.rb
+- lib/operto/client.rb
+- lib/operto/config.rb
+- lib/operto/error.rb
+- lib/operto/filtered_pagination.rb
+- lib/operto/homes/index.rb
+- lib/operto/issue_types.rb
+- lib/operto/issues/close.rb
+- lib/operto/issues/index.rb
+- lib/operto/memory_token_store.rb
+- lib/operto/operation.rb
+- lib/operto/staff/index.rb
+- lib/operto/staff_task_times/index.rb
+- lib/operto/staff_tasks/create.rb
+- lib/operto/staff_tasks/destroy.rb
+- lib/operto/tasks/create.rb
+- lib/operto/tasks/index.rb
+- lib/operto/tasks/shared.rb
+- lib/operto/tasks/update.rb
+- lib/operto/version.rb
+licenses: []
+metadata:
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '4.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.15
+specification_version: 4
+summary: Client for the Operto Teams API
+test_files: []