tessera 1.0.0

data/lib/tessera/api/ticket_create.rb

@@ -0,0 +1,36 @@
+##
+#
+#
+#
+module Tessera
+  module Api
+    class TicketCreate
+      def initialize(body_content)
+        @body = body.merge(body_content)
+      end
+
+      def self.call(body_content)
+        new(body_content).call
+      end
+
+      def call
+        response = Tessera::Request.new(:POST, 'Ticket', @body).send
+        JSON.parse(response.body)
+      end
+
+      def session_id
+        session = Session.create
+        # TODO: solve token creation failure with error
+        session.session_id
+      end
+
+      private
+
+      def body
+        {
+          SessionID: session_id
+        }
+      end
+    end
+  end
+end

data/lib/tessera/api/ticket_get.rb

@@ -0,0 +1,37 @@
+##
+#
+#
+#
+module Tessera
+  module Api
+    class TicketGet
+      def initialize(ticket_id)
+        @ticket_id = ticket_id
+      end
+
+      def self.call(ticket_id)
+        new(ticket_id).call
+      end
+
+      def call
+        response = Tessera::Request.new(:GET, "Ticket/#{@ticket_id}", body).send
+        JSON.parse(response.body)
+      end
+
+      def session_id
+        session = Session.create
+        # TODO: solve token creation failure with error
+        session.session_id
+      end
+
+      private
+
+      def body
+        {
+          TicketID: @ticket_id,
+          SessionID: session_id
+        }
+      end
+    end
+  end
+end

data/lib/tessera/api/ticket_list.rb

@@ -0,0 +1,37 @@
+##
+#
+#
+#
+module Tessera
+  module Api
+    class TicketList
+      def self.call(ticket_ids)
+        new(ticket_ids).call
+      end
+
+      def initialize(ticket_ids)
+        @ticket_ids = ticket_ids
+      end
+
+      def call
+        response = Tessera::Request.new(:GET, 'TicketList', body).send
+        JSON.parse(response.body)
+      end
+
+      def session_id
+        session = Session.create
+        # TODO: solve token creation failure with error
+        session.session_id
+      end
+
+      private
+
+      def body
+        {
+          TicketID: @ticket_ids,
+          SessionID: session_id
+        }
+      end
+    end
+  end
+end

data/lib/tessera/api/ticket_search.rb

@@ -0,0 +1,35 @@
+##
+# Class for searching through tickets
+#  as params hash any of these in official docs could be used:
+#  http://doc.otrs.com/doc/api/otrs/5.0/Perl/Kernel/GenericInterface/Operation/Ticket/TicketSearch.pm.html
+#
+module Tessera
+  module Api
+    class TicketSearch
+      def self.call(params = nil)
+        new(params).call
+      end
+
+      def initialize(params)
+        @params = params
+      end
+
+      def call
+        response = Tessera::Request.new(:GET, 'Ticket', body).send
+        JSON.parse(response.body)
+      end
+
+      def session_id
+        session = Session.create
+        # TODO: solve token creation failure with error
+        session.session_id
+      end
+
+      private
+
+      def body
+        @params.to_h.merge(SessionID: session_id)
+      end
+    end
+  end
+end

data/lib/tessera/configuration.rb

@@ -0,0 +1,46 @@
+##
+#
+# This is configuration class that allows you to set your config like so:
+#
+# Tessera.configure do |config|
+#   config.username = 'jon'
+#   config.password = 'SuperSecret'
+#   config.base_url = 'https://otrs.com/otrs/nph-genericinterface.pl/Webservice/rest/'
+# end
+#
+# or
+#
+# by simply assigning params by themself:
+#
+# config = Tessera::Configuration.new
+# config.username = 'jon'
+# config.password = 'SuperSecret'
+# config.base_url = 'https://otrs.com/otrs/nph-genericinterface.pl/Webservice/rest/'
+# Tessera.configuration = config
+#
+module Tessera
+  class Configuration
+    attr_writer :username, :password, :base_url
+
+    def initialize
+      @username = nil
+      @password = nil
+      @base_url = nil
+    end
+
+    def username
+      raise ConfigNotSet, 'username' unless @username
+      @username
+    end
+
+    def password
+      raise ConfigNotSet, 'password' unless @password
+      @password
+    end
+
+    def base_url
+      raise ConfigNotSet, 'base_url' unless @base_url
+      @base_url
+    end
+  end
+end

data/lib/tessera/model/base.rb

@@ -0,0 +1,28 @@
+module Tessera
+  module Model
+    class Base
+      attr_accessor :response, :errors, :code
+
+      def initialize(response)
+        @response = response
+        @code = @response.code
+        parse_errors if parsed_body
+        parse_attributes if parsed_body
+      end
+
+      protected
+
+      def parse_errors
+        @errors = parsed_body['Error']
+      end
+
+      def parsed_body
+        JSON.parse(@response.body) if @response.body
+      end
+
+      def parse_attributes
+        raise NotImplementedError, 'Model must implement attribute mapping'
+      end
+    end
+  end
+end

data/lib/tessera/model/session.rb

@@ -0,0 +1,11 @@
+module Tessera
+  module Model
+    class Session < Base
+      attr_accessor :session_id
+
+      def parse_attributes
+        @session_id = parsed_body['SessionID']
+      end
+    end
+  end
+end

data/lib/tessera/model/ticket.rb

@@ -0,0 +1,58 @@
+module Tessera
+  module Model
+    class Ticket < Base
+      attr_accessor :ticket_id, :lock_id, :real_till_time_not_used, :changed,
+                    :customer_user_id, :queue_id, :escalation_solution_time, :owner_id,
+                    :unlock_timeout, :priority_id, :escalation_time, :type, :queue,
+                    :escalation_response_time, :escalation_update_time, :customer_id,
+                    :age, :until_time, :responsible, :lock, :priority, :state_id,
+                    :created_by, :state, :type_id, :ticket_number, :group_id, :created,
+                    :service_id, :owner, :slaid, :state_type, :title, :responsible_id,
+                    :create_tim_nix, :changed_by, :archive_flag
+
+      # rubocop:disable Metrics/MethodLength
+      # rubocop:disable Metrics/AbcSize
+      def initialize(params)
+        @ticket_id = params['TicketID']
+        @lock_id = params['LockID']
+        @real_till_time_not_used = params['RealTillTimeNotUsed']
+        @changed = params['Changed']
+        @customer_user_id = params['CustomerUserID']
+        @queue_id = params['QueueID']
+        @escalation_solution_time = params['EscalationSolutionTime']
+        @owner_id = params['OwnerID']
+        @unlock_timeout = params['UnlockTimeout']
+        @priority_id = params['PriorityID']
+        @escalation_time = params['EscalationTime']
+        @type = params['Type']
+        @queue = params['Queue']
+        @escalation_response_time = params['EscalationResponseTime']
+        @escalation_update_time = params['EscalationUpdateTime']
+        @customer_id = params['CustomerID']
+        @age = params['Age']
+        @until_time = params['UntilTime']
+        @responsible = params['Responsible']
+        @lock = params['Lock']
+        @priority = params['Priority']
+        @state_id = params['StateID']
+        @created_by = params['CreateBy']
+        @state = params['State']
+        @type_id = params['TypeID']
+        @ticket_number = params['TicketNumber']
+        @group_id = params['GroupID']
+        @created = params['Created']
+        @service_id = params['ServiceID']
+        @owner = params['Owner']
+        @slaid = params['SLAID']
+        @state_type = params['StateType']
+        @title = params['Title']
+        @responsible_id = params['ResponsibleID']
+        @create_tim_nix = params['CreateTimeUnix']
+        @changed_by = params['ChnageBy']
+        @archive_flag = params['ArchiveFlag']
+      end
+      # rubocop:enable Metrics/AbcSize
+      # rubocop:enable Metrics/MethodLength
+    end
+  end
+end

data/lib/tessera/otrs/article.rb

@@ -0,0 +1,21 @@
+module Tessera
+  module Otrs
+    class Article < Base
+      attr_accessor :From, :To, :Subject, :Body, :ContentType, :CommunicationChannel,
+                    :ArticleSend
+
+      # rubocop:disable Metrics/ParameterLists
+      def initialize(from:, to: nil, subject:, body:, communication_channel: 'Email',
+                     article_send: 0)
+        @From = from
+        @To = to
+        @Subject = subject
+        @Body = body
+        @ContentType = 'text/plain; charset=utf8'
+        @CommunicationChannel = communication_channel
+        @ArticleSend = article_send
+      end
+      # rubocop:enable Metrics/ParameterLists
+    end
+  end
+end

data/lib/tessera/otrs/attachment.rb

@@ -0,0 +1,13 @@
+module Tessera
+  module Otrs
+    class Attachment < Base
+      attr_accessor :Content, :ContentType, :Filename
+
+      def initialize(tempfile:)
+        @Content = Base64.encode64(tempfile.read)
+        @ContentType = tempfile.content_type
+        @Filename = tempfile.original_filename
+      end
+    end
+  end
+end

data/lib/tessera/otrs/base.rb

@@ -0,0 +1,11 @@
+module Tessera
+  module Otrs
+    class Base
+      def to_hash
+        Hash[instance_variables.map do |v|
+          [v.to_s[1..-1].to_sym, instance_variable_get(v)]
+        end]
+      end
+    end
+  end
+end

data/lib/tessera/otrs/ticket.rb

@@ -0,0 +1,18 @@
+module Tessera
+  module Otrs
+    class Ticket < Base
+      attr_accessor :Title, :QueueID, :State, :PriorityID, :CustomerUser, :CustomerID
+
+      # rubocop:disable Metrics/ParameterLists
+      def initialize(title:, queue:, state:, priority:, customer_user:, customer_id:)
+        @Title = title
+        @QueueID = queue
+        @State = state
+        @PriorityID = priority
+        @CustomerUser = customer_user
+        @CustomerID = customer_id
+      end
+      # rubocop:enable Metrics/ParameterLists
+    end
+  end
+end

data/lib/tessera/request.rb

@@ -0,0 +1,57 @@
+##
+#
+# Request class
+#
+# Methods acepted:
+#   GET
+#   POST
+#   PATCH
+#
+# (basically it uses Net::HTTP, but other methods are not supported by API anyway...)
+#
+# Endpoint is based on you yaml setting
+# You can find a template in templates directory here in repository
+#
+# Body gets assembled in (put name of class here) class :) (not here yet) TODO
+#
+# return value is Net::HTTPResponse which has to be parsed TODO (put name of class here)
+#
+module Tessera
+  class Request
+    def initialize(method, endpoint, body)
+      @method = method
+      @endpoint = endpoint
+      @body = body
+    end
+
+    def send
+      net_http_send
+      # Response.new(net_http_send)
+    end
+
+    protected
+
+    def net_http_send
+      uri = URI("#{Tessera.configuration.base_url}#{@endpoint}")
+
+      request = net_http_class.new(uri)
+      headers.each { |k, v| request[k] = v }
+      request.body = @body.to_json
+
+      Net::HTTP.start(uri.hostname, uri.port, use_ssl: (uri.scheme == 'https')) do |http|
+        http.request(request)
+      end
+    end
+
+    def net_http_class
+      Kernel.const_get("Net::HTTP::#{@method.capitalize}")
+    end
+
+    def headers
+      {
+        'Accept-Encoding' => 'application/json',
+        'Content-Type' => 'application/json'
+      }
+    end
+  end
+end

data/lib/tessera/ticket.rb

@@ -0,0 +1,76 @@
+module Tessera
+  class Ticket
+    class << self
+      # rubocop:disable Metrics/AbcSize
+      # rubocop:disable Metrics/MethodLength
+      def find(ticket_id)
+        ticket = if ticket_id.is_a? Array
+                   ::Tessera::Api::TicketList.call(ticket_id)
+                 else
+                   ::Tessera::Api::TicketGet.call(ticket_id)
+                 end
+        if ticket['Error']
+          raise TicketNotFound.new(ticket['Error']['ErrorMessage'],
+                                   ticket['Error']['ErrorCode'])
+        elsif ticket['Ticket'] && ticket['Ticket'].count > 1
+          ticket['Ticket'].map do |ticket_json|
+            ::Tessera::Model::Ticket.new(ticket_json)
+          end
+        else
+          ::Tessera::Model::Ticket.new(ticket['Ticket'].first)
+        end
+      end
+      # rubocop:enable Metrics/MethodLength
+      # rubocop:enable Metrics/AbcSize
+
+      def where(params)
+        result = Tessera::Api::TicketSearch.call(params)
+        ticket_ids = result['TicketID'] ? result['TicketID'] : []
+        new(ticket_ids)
+      end
+
+      # rubocop:disable Metrics/AbcSize
+      # rubocop:disable Metrics/MethodLength
+      def create(params)
+        ticket = Tessera::Otrs::Ticket.new(params[:ticket]).to_hash
+        article = Tessera::Otrs::Article.new(params[:article]).to_hash
+        attachment = if params[:attachment]
+                       case params[:attachment].class
+                       when Hash
+                         Tessera::Otrs::Attachment.new(params[:attachment]).to_hash
+                       when Array
+                         params[:attachment].map do |a|
+                           Tessera::Otrs::Attachment.new(a).to_hash
+                         end
+                       end
+                     end
+        body = { Ticket: ticket }
+        body = body.merge(Article: article)
+        body = body.merge(Attachment: attachment) if attachment
+
+        Tessera::Api::TicketCreate.call(body)
+      end
+      # rubocop:enable Metrics/MethodLength
+      # rubocop:enable Metrics/AbcSize
+    end
+
+    def initialize(result)
+      @result = result
+    end
+
+    def count
+      @result.size
+    end
+
+    def ticket_ids
+      @result.map(&:to_i)
+    end
+
+    def tickets
+      return [] if @result.empty?
+      @tickets ||= @result.map do |id|
+        ::Tessera::Ticket.find(id)
+      end
+    end
+  end
+end