keytechkit 0.3.16

data/lib/keytechKit/elements/data_dictionary/data_dictionary_handler.rb

@@ -0,0 +1,50 @@
+require 'keytechKit/elements/data_dictionary/data_dictionary_definition'
+
+module KeytechKit
+  class DataDictionaryHandler
+    include HTTParty
+
+    attr_accessor :keytechkit
+
+    def initialize(keytechkit, base_url, username, password)
+      self.class.base_uri(base_url)
+      @auth = { username: username, password: password }
+      @keytechkit = keytechkit
+    end
+
+    def getDefinition(datadictionary_id)
+      # /DataDictionaries/{ID}|{Name}
+      parameter = { basic_auth: @auth }
+
+      response = self.class.get("/datadictionaries/#{datadictionary_id}", parameter)
+      if response.success?
+        parse_dataDictionaryDefinition(response['AttributeDefinition'])
+      else
+        raise response.response
+      end
+    end
+
+    # Returns a hashed value with data
+    def getData(datadictionary_id)
+      # /DataDictionaries/{ID}|{Name}/data
+      parameter = { basic_auth: @auth }
+
+      response = self.class.get("/datadictionaries/#{datadictionary_id}/data", parameter)
+      if response.success?
+        response['Data']
+      else
+        raise response.response
+      end
+    end
+
+    private
+
+    def parse_dataDictionaryDefinition(definitionArray)
+      definition = []
+      definitionArray.each do |definitionData|
+        definition.push DataDictionaryDefinition.new(definitionData)
+      end
+      definition
+    end
+  end
+end

data/lib/keytechKit/elements/element.rb

@@ -0,0 +1,81 @@
+
+module KeytechKit
+  ##
+  # Represents a single element
+  class Element
+    attr_accessor :key # unique key of this element
+    attr_accessor :name
+
+    # a array of {key:, value:} pairs
+    attr_accessor :keyValueList
+
+    attr_accessor :createdByLong
+    attr_accessor :createdBy
+    attr_accessor :createdAt
+
+    attr_accessor :changedAt
+    attr_accessor :changedByLong
+    attr_accessor :changedBy
+
+    attr_accessor :displayname # localized DisplayName
+    attr_accessor :thumbnailHint
+    attr_accessor :hasVersions
+    attr_accessor :classDisplayName
+    attr_accessor :status
+    attr_accessor :version
+    attr_accessor :description
+
+    def initialize(data)
+      self.key = data['Key']
+      self.name = data['Name']
+      set_key_value_list(data['KeyValueList'])
+
+      self.displayname = data['DisplayName']
+      self.classDisplayName = data['ClassDisplayName']
+      self.version = data['Version']
+      self.status = data['Status']
+      self.description = data['Description']
+
+      self.changedBy = data['ChangedBy']
+      self.changedByLong = data['ChangedByLong']
+      self.changedAt = data['ChangedAt']
+
+      self.createdBy = data['CreatedBy']
+      self.createdByLong = data['CreatedByLong']
+      self.createdAt = data['CreatedAt']
+
+      self.thumbnailHint = data['ThumbnailHint']
+      self.hasVersions = data['HasVersions']
+    end
+
+    def to_hash
+      { Key: key, Name: name, keyValueList: keytechKeyValueObject }
+    end
+
+    # This is keytech - Style: key and value in different elements-
+    # No easy parsable hash!
+    # Sorry  it was me. I was young and needed the money ;-)
+    #  {
+    #   "Key": "au_do__categorylocalized",
+    #   "Value": "Blaue Kategorie"
+    # }
+    def keytechKeyValueObject
+      arrayOfKeyValuePairs = []
+      keyValueList.each do |key, value|
+        arrayOfKeyValuePairs.push ({ Key: key, Value: value })
+      end
+      arrayOfKeyValuePairs
+    end
+
+    private
+
+    def set_key_value_list(kv_data)
+      self.keyValueList = ({})
+      if kv_data
+        kv_data.each do |kvPair|
+          keyValueList[kvPair['Key'].to_s] = kvPair['Value']
+        end
+      end
+    end
+  end
+end

data/lib/keytechKit/elements/element_files/element_file.rb

@@ -0,0 +1,19 @@
+module KeytechKit
+  ##
+  # A single file representation
+  class ElementFile
+    attr_accessor :changedAt
+    attr_accessor :fileName
+    attr_accessor :fileSize
+    attr_accessor :fileStorageType
+    attr_accessor :fileId
+
+    def initialize(data)
+      self.changedAt = data['FileLastChangedAt']
+      self.fileSize = data['FileSize']
+      self.fileName = data['FileName']
+      self.fileId = data['FileID']
+      self.fileStorageType = data['FileStorageType']
+    end
+  end
+end

data/lib/keytechKit/elements/element_files/element_file_handler.rb

@@ -0,0 +1,181 @@
+require 'keytechKit/tools'
+require 'keytechKit/elements/element_files/element_file'
+
+module KeytechKit
+  ##
+  # Element File handler
+  class ElementFileHandler
+    include HTTParty
+
+    def initialize(base_url, username, password)
+      self.class.base_uri(base_url)
+      @auth = { username: username, password: password }
+    end
+
+    # Returns true or false if a masterfile exist
+    def masterfile?(element_key)
+      if Tools.classType(element_key) == 'DO' # Only DO Types can have a file
+        file_list = load(element_key)
+        unless file_list.nil?
+          file_list.each do |file|
+            return true if file.fileStorageType.casecmp('master').zero?
+          end
+        end
+      end
+      false
+    end
+
+    # Returns information about masterfile
+    def masterfile_info(element_key)
+      if Tools.classType(element_key) == 'DO' # Only DO Types can have a file
+        file_list = load(element_key)
+        unless file_list.nil?
+          file_list.each do |file|
+            return file if file.fileStorageType.casecmp('master').zero?
+          end
+        end
+      end
+      false
+    end
+
+    # Returns the name of a masterfile if present
+    def masterfile_name(element_key)
+      file_list = load(element_key)
+      unless file_list.nil?
+        file_list.each do |file|
+          return file.fileName if file.fileStorageType.downcase! == 'master'
+        end
+      end
+      ''
+    end
+
+    # Loads the filelist
+    # Returns a full list of file data
+    def load(element_key)
+      parameter = { basic_auth: @auth }
+      response = self.class.get("/elements/#{element_key}/files", parameter)
+      parse_files(response['FileInfos']) if response.success?
+    end
+
+    # Loads the masterfile directly
+    def load_masterfile(element_key)
+      parameter = { basic_auth: @auth }
+      response = self.class.get("/elements/#{element_key}/files/masterfile", parameter)
+      return response if response.success?
+    end
+
+    # Masterfile is the main file attached to a document
+    #
+    def upload_masterfile(element_key, file, original_filename)
+      # file, elementkey , name??
+      content_length = file.size
+      content_type = 'application/octet-stream; charset=utf-8'
+      parameter = { basic_auth: @auth,
+                    headers: { 'Content-Type' => content_type,
+                               'Content-Length' => content_length.to_s,
+                               'storageType' => 'MASTER',
+                               'filename' => original_filename.to_s },
+                    body: file.read }
+      upload_file element_key, parameter
+    end
+
+    # The preview is a larger preview file. It must not have the same type as the masterfile,
+    # But should allow a sneak preview to its contents.
+    # e.g.: You have a large (200MB) CAD file, then der prebview may represent a
+    # 2D Drawing of the large fole.
+    # You can have more than one preview file
+    def upload_preview(element_key, file, original_filename)
+      # file, elementkey , name??
+      content_length = file.size
+      content_type = 'application/octet-stream; charset=utf-8'
+
+      parameter = { basic_auth: @auth,
+                    headers: { 'Content-Type' => content_type,
+                               'Content-Length' => content_length.to_s,
+                               'storageType' => 'PREVIEW',
+                               'filename' => original_filename.to_s },
+                    body: file.read }
+      upload_file element_key, parameter
+    end
+
+    # A Quickpreview is mostly a smaller image file. Best is to make a image_file
+    # from the quickpreview. Respect modern retina displays - so dont be shy
+    # to upload image files of at least 800x600 pixels in size
+    def upload_quickpreview(element_key, file, original_filename)
+      # file, elementkey , name??
+      content_length = file.size
+      content_type = 'application/octet-stream; charset=utf-8'
+
+      parameter = { basic_auth: @auth,
+                    headers: { 'Content-Type' => content_type,
+                               'Content-Length' => content_length.to_s,
+                               'storageType' => 'QUICKPREVIEW',
+                               'filename' => original_filename.to_s },
+                    body: file.read }
+      upload_file element_key, parameter
+    end
+
+    def remove_masterfile(element_key)
+      file_list = load(element_key)
+      if !file_list.nil?
+        file_list.each do |file|
+          return remove_file(element_key, file.fileId) if file.fileStorageType.casecmp('master').zero?
+        end
+      end
+      { success: true, message: "No file found" }
+    end
+
+    def remove_preview(element_key)
+      file_list = load(element_key)
+      if !file_list.nil?
+        file_list.each do |file|
+          return remove_file(element_key, file.fileId) if file.fileStorageType.casecmp('preview').zero?
+        end
+      end
+      { success: true, message: "No file found" }
+    end
+
+    def remove_quickpreview(element_key)
+      file_list = load(element_key)
+      if !file_list.nil?
+        file_list.each do |file|
+          return remove_file(element_key, file.fileId) if file.fileStorageType.casecmp('quickpreview').zero?
+        end
+      end
+      { success: true, message: "No file found" }
+    end
+
+    private
+
+    def remove_file(element_key, file_id)
+      parameter = { basic_auth: @auth }
+      response = self.class.delete("/elements/#{element_key}/files/#{file_id}", parameter)
+      if response.success?
+        { success: true }
+      else
+        { success: false, error: response.headers['x-errordescription'].to_s }
+      end
+    end
+
+    def upload_file(element_key, parameter)
+      response = self.class.post("/elements/#{element_key}/files", parameter)
+      parse_response(response)
+    end
+
+    def parse_response(response)
+      if response.success?
+        { success: true, location: response.headers['location'].to_s }
+      else
+        { success: false, error: response.headers['x-errordescription'].to_s }
+      end
+    end
+
+    def parse_files(files_result)
+      files = []
+      files_result.each do |file_data|
+        files.push ElementFile.new(file_data)
+      end
+      files
+    end
+  end
+end

data/lib/keytechKit/elements/element_handler.rb

@@ -0,0 +1,183 @@
+require 'keytechKit/elements/element'
+require 'keytechKit/elements/search_response_header'
+require 'keytechKit/elements/bom/bom_element_list'
+
+module KeytechKit
+  ##
+  # All operations for a element is here
+  class ElementHandler
+    include HTTParty
+
+    attr_accessor :keytechkit
+
+    def initialize(keytechkit, base_url, username, password)
+      self.class.base_uri(base_url)
+      @auth = { username: username, password: password }
+      @keytechkit = keytechkit
+    end
+
+    ##
+    # Find an existing element with +elementkey+ in form of classkey:<nummeric>
+    # e.g.: MISC_FILE:1234
+    # +options+ is one of attributes=ALL|NONE|EDITOR
+    # It returns nil if no element with this elementKey was found
+    def load(element_key, options = {})
+      parameter = { query: options }
+      parameter[:basic_auth] = @auth
+
+      response = self.class.get("/elements/#{element_key}", parameter)
+
+      if response.success?
+        searchResponseHeader = SearchResponseHeader.new(response)
+        searchResponseHeader.elementList.first
+        # TODO: Can we do better if element was not found?
+      end
+    end
+
+    # It returns a element prototype with the given elementKey
+    # you can check valid elementkeys with the classdefinition
+    def new_element(key)
+      Element.new('Key' => key)
+    end
+
+    # Saves a element to keytech web api and returns the saved element.
+    # If anything goes wrong - a http response is returned
+    def save(element)
+      elementHash = element.to_hash
+      parameter = { basic_auth: @auth,
+                    body: elementHash.to_json,
+                    headers: { 'Content-Type' => 'application/json; charset=utf-8
' } }
+      save_response = self.class.post('/elements', parameter)
+      if save_response.success?
+        Element.new(save_response.parsed_response)
+      else
+        puts "Could not save element: #{save_response.headers['x-errordescription']}"
+      end
+    end
+
+    # Saves a element to keytech web api and returns the saved element.
+    # If anything goes wrong - a http response is returned
+    def update(element)
+      elementHash = element.to_hash
+      parameter = { basic_auth: @auth,
+                    body: elementHash.to_json,
+                    headers: { 'Content-Type' => 'application/json; charset=utf-8
' } }
+      save_response = self.class.put("/elements/#{element.key}", parameter)
+      if save_response.success?
+        Element.new(save_response.parsed_response)
+      else
+        puts "Could not save element: #{save_response.headers['x-errordescription']}"
+      end
+    end
+
+    # Deletes an element with the key
+    # It returns the http response.
+    def delete(element_key)
+      parameter = { basic_auth: @auth }
+      response = self.class.delete("/elements/#{element_key}", parameter)
+      unless response.success?
+        puts "Could not save element: #{response.headers['x-errordescription']}"
+      end
+      response
+    end
+
+    # Loads the structure
+    # +options+ can have these values: size, page, attribute = ALL|NONE|GLOBALLISTER|SECONDARY|EXPLORER
+    # Returns a list of elements
+    # It returns nil if no element with this elementKey was found
+    def structure(element_key, options = {})
+      parameter = { query: options }
+      parameter[:basic_auth] = @auth
+      response = self.class.get("/elements/#{element_key}/structure", parameter)
+      if response.success?
+        searchResponseHeader = SearchResponseHeader.new(response)
+        return searchResponseHeader.elementList
+      end
+    end
+
+    # Loads the parent elements
+    # +options+ can have these values: size, page, attribute = ALL|NONE|GLOBALLISTER|SECONDARY|EXPLORER
+    # Returns a list of elements
+    # It returns nil if no element with this elementKey was found
+    def whereused(element_key, options = {})
+      parameter = { query: options }
+      parameter[:basic_auth] = @auth
+
+      response = self.class.get("/elements/#{element_key}/whereused", parameter)
+      if response.success?
+        searchResponseHeader = SearchResponseHeader.new(response)
+        return searchResponseHeader.elementList
+      end
+    end
+
+    # Loads the bill of meterial on articles
+    # +options+ can have these values: size, page, attribute = ALL|NONE|GLOBALLISTER|SECONDARY|EXPLORER
+    # Returns a list of elements
+    # It returns nil if no element with this elementKey was found
+    def billOfMaterial(element_key, options = {})
+      parameter = { query: options }
+      parameter[:basic_auth] = @auth
+
+      response = self.class.get("/elements/#{element_key}/bom", parameter)
+      if response.success?
+        bom_list = BomElementList.new(response)
+        return bom_list.bomElementList
+      end
+    end
+
+    # Loads the list of mails on folders,
+    # +options+ can have these values: size, page, attribute = ALL|NONE|GLOBALLISTER|SECONDARY|EXPLORER
+    # Returns a list of elements
+    # It returns nil if no element with this elementKey was found
+    def mails(element_key, options = {})
+      parameter = { query: options }
+      parameter[:basic_auth] = @auth
+
+      response = self.class.get("/elements/#{element_key}/mails", parameter)
+      return response['ElementList'] if response.success?
+    end
+
+    # It returns the notes of an element if anything are given
+    # Notes list can be empty
+    # It returns nil if no element with this elementKey was found
+    def notes(element_key)
+      parameter = { basic_auth: @auth }
+
+      response = self.class.get("/elements/#{element_key}/notes", parameter)
+      if response.success?
+        search_response_header = SearchResponseHeader.new(response)
+        search_response_header.elementList
+      end
+    end
+
+    # Returns Notes resource.
+    # Every Element can have zero, one or more notes.
+    # You can notes only access in context of its element which ownes the notes
+    def note_handler
+      @_note_handler = NoteHandler.new(keytechkit.base_url, keytechkit.username, keytechkit.password) if @_note_handler.nil?
+      @_note_handler
+    end
+
+    # Returns the file object.
+    # Every element can have a Masterfile and one or more preview files
+    def file_handler
+      @_element_file_handler = ElementFileHandler.new(keytechkit.base_url, keytechkit.username, keytechkit.password) if @_element_file_handler.nil?
+      @_element_file_handler
+    end
+
+    # Loads the preview image. This is a size limited image version of the files
+    # content. Text documents often show the first Page.
+    # Make no assumtions about the image size
+    def preview(element_key)
+      parameter = { basic_auth: @auth }
+      self.class.get("/elements/#{element_key}/preview", parameter)
+    end
+
+    # Loads a small thumbnail. Thumbnails are like file type icons.
+    # They normaly show the type of a document, not its content
+    def thumbnail(element_key)
+      parameter = { basic_auth: @auth }
+      self.class.get("/elements/#{element_key}/thumbnail", parameter)
+    end
+  end
+end

data/lib/keytechKit/elements/group_by.rb

@@ -0,0 +1,16 @@
+module KeytechKit
+  ##
+  # A key - values list that conatins a Name and a list of values
+  # 
+  class GroupBy
+    attr_accessor :attributeName
+    attr_accessor :attributeDisplayName
+    attr_accessor :values
+
+    def initialize(data)
+      self.attributeName = data['AttributeName']
+      self.attributeDisplayName = data['AttributeDisplayName']
+      self.values = data['Values']
+    end
+  end
+end

data/lib/keytechKit/elements/notes/note.rb

@@ -0,0 +1,31 @@
+module KeytechKit
+  ##
+  # A single note
+  class Note
+    attr_accessor :changedAt
+    attr_accessor :changedBy
+    attr_accessor :changedByLong
+    attr_accessor :createdAt
+    attr_accessor :createdBy
+    attr_accessor :createdByLong
+    attr_accessor :id
+    attr_accessor :noteType
+    attr_accessor :subject
+    attr_accessor :text
+
+    def initialize(data)
+      self.changedAt = data['ChangedAt']
+      self.changedBy = data['ChangedBy']
+      self.changedByLong = data['ChangedByLong']
+
+      self.createdAt = data['CreatedAt']
+      self.createdBy = data['CreatedBy']
+      self.createdByLong = data['CreatedByLong']
+
+      self.id = data['ID']
+      self.noteType = data['NoteType']
+      self.subject = data['Subject']
+      self.text = data['Text']
+    end
+  end
+end

data/lib/keytechKit/elements/notes/note_handler.rb

@@ -0,0 +1,35 @@
+require 'keytechKit/elements/notes/note'
+
+module KeytechKit
+  ##
+  # Notes
+  class NoteHandler
+    include HTTParty
+
+    def initialize(base_url, username, password)
+      self.class.base_uri(base_url)
+      @auth = { username: username, password: password }
+    end
+
+    def load(elementKey)
+      parameter = { basic_auth: @auth }
+
+      response = self.class.get("/elements/#{elementKey}/notes", parameter)
+      if response.success?
+        parse_notes(response['NotesList'])
+      else
+        raise response.response
+      end
+    end
+
+    private
+
+    def parse_notes(notesResult)
+      notes = []
+      notesResult.each do |notedata|
+        notes.push Note.new(notedata)
+      end
+      notes
+    end
+  end
+end

data/lib/keytechKit/elements/search_response_header.rb

@@ -0,0 +1,47 @@
+require 'keytechKit/elements/element'
+require 'keytechKit/elements/group_by'
+module KeytechKit
+  ##
+  # Represents the header from search results
+  #
+  class SearchResponseHeader
+    attr_accessor :pageNumber
+    attr_accessor :pageSize
+    attr_accessor :totalRecords
+    attr_accessor :elementList # list of elements
+    attr_accessor :groupBy
+
+    def initialize(response)
+      parseResponse(response)
+    end
+
+    private
+
+    def parseResponse(response)
+      @pageNumber = response['PageNumber']
+      @pageSize = response['PageSize']
+      @totalRecords = response['Totalrecords']
+      @elementList = parseElementList(response['ElementList'])
+      @groupBy = parseGroupBy(response['GroupBy'])
+    end
+
+    def parseGroupBy(groupByResults)
+      if groupByResults
+        groupByArray = []
+        groupByResults.each do |groupBy|
+          groupByArray.push GroupBy.new(groupBy)
+        end
+        groupByArray.first
+      end
+    end
+
+    def parseElementList(elementResults)
+      elements = []
+      elementResults.each do |elementData|
+        element = Element.new(elementData)
+        elements.push element
+      end
+      @elementList = elements
+    end
+  end
+end

data/lib/keytechKit/search.rb

@@ -0,0 +1,46 @@
+require 'keytechKit/elements/element'
+require 'keytechKit/elements/search_response_header'
+
+module KeytechKit
+  ##
+  # Can search the API by fulltext, fields, element types
+  # Can search by a predefined 'stored' query by its queryID
+  # Can sort the results
+  # Can group the results
+  class Search
+    include HTTParty
+
+    attr_accessor :response
+
+    def initialize(base_url, username, password)
+      self.class.base_uri(base_url)
+      @auth = { username: username, password: password }
+    end
+
+    # options = {};
+    #:q = searchtext - optional parameter: makes a fulltext search, (unusable on very large data)
+    #:size
+    #:page
+    #:attributes = "ALL","None","Lister", "Editor", "GlobalLister", "System", "Secondary", "Explorer"
+    #:reload = true
+    #:classes = "DEFAULT_DO","DEFAULT_FD", "DEFAULT_MI", "DEFAULT_MAIL","DEFAULT_TASK"
+    #:fields = [<attribute><operator><value>:] - as_do__created_by=jgrant:as_do_changed_by=pmiller - finds all elememnts cerated by jgrant and changed by pmiller
+    # Remember: dates must be send in epoch format! "/date(1464127200000)/"
+    def query(options = {})
+      parameter = { query: options }
+      parameter[:basic_auth] = @auth
+      response = self.class.get('/search', parameter)
+      if response.success?
+        parse_response(response)
+      else
+        puts "Could not execute query: #{parse_response.headers['x-errordescription']}"
+      end
+    end
+
+    private
+
+    def parse_response(response)
+      SearchResponseHeader.new(response)
+    end
+  end
+end