lingotek-client 0.1.0

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/lib/VERSION

@@ -0,0 +1 @@
+0.1.0

data/lib/lingotek-client/api.rb

@@ -0,0 +1,58 @@
+require 'oauth'
+require 'rest-client'
+
+require_relative './schema'
+
+module LingotekClient
+  class Api
+
+    def initialize(url, key, secret, external_id)
+      @url = URI.parse(url)
+      @key = key
+      @secret = secret
+      @external_id = external_id
+      generate_token
+      RestClient.reset_before_execution_procs
+      RestClient.add_before_execution_proc do |req, params|
+        @access_token.sign! req
+      end
+    end
+
+    def method_missing(method, *args, &block)
+      inputs = args.first || {}
+
+      LingotekClient::Schema.validate!(method, inputs.keys )
+      # retrive the file params
+      file_upload_params = inputs.select { |k,v|  v.is_a? File }
+      inputs.delete_if { |k,v|  v.is_a? File }
+      post(method, inputs, file_upload_params)
+    end
+
+    def generate_token
+      consumer = OAuth::Consumer.new(@key, @secret, site: site, :request_token_path => "", :authorize_path => "", :access_token_path => "", :http_method => :post)
+      @access_token = OAuth::AccessToken.new(consumer)
+    end
+
+    private
+
+
+    def post(method, params = {}, file_upload_params = {})
+      params[:externalId] ||= @external_id
+      RestClient.post(url_path(method, params), file_upload_params)
+    end
+
+    def url_path(method, params)
+      "#{site}#{@url.path}#{method}?#{URI.encode_www_form(params)}"
+    end
+
+    def site
+      "#{@url.scheme}://#{@url.host}:#{@url.port}"
+    end
+
+  end
+end
+
+# client = LingotekClient::Api.new('http://10.0.11.152:8080/lingopoint/api/4/', 'test', 'test123', 'shane@lingotek.com')
+# puts client.listLanguageSkills
+# puts client.listAssignedProjects
+

data/lib/lingotek-client/api_schema.rb

@@ -0,0 +1,178 @@
+module APISchema
+  def schema
+    {
+      acceptExternalInvite: { required: [:invite_id], optional: []},
+      addCommunityDictionaryEntry: { required: [:type, :entry], optional: []},
+      addCompany: { required: [:companyName], optional: []},
+      addContact: { required: [:userEmail], optional: [:comment]},
+      addContentDocument: { required: [:projectId, :content, :documentName, :sourceLanguage, :tmVaultId, :format], optional: [:documentDesc, :note, :srxFileContents, :itsFileContents, :fprmFileContents, :secondaryFilter, :secondaryFprmFileContents, :placeholderMode, :priority]},
+      addDocument: { required: [:projectId, :file, :documentName, :format, :encoding, :sourceLanguage, :tmVaultId], optional: [:tmTarget, :zipFile, :note, :srxFile, :itsFile, :fprmFile, :secondaryFilter, :secondaryFprmFile, :placeholderMode, :priority]},
+      addDocumentURL: { required: [:projectId, :url, :sourceLanguage, :tmVaultId], optional: [:format, :target, :tmTarget, :template, :depth, :srxFile, :itsFile, :fprmFile, :secondaryFilter, :secondaryFprmFile, :placeholderMode, :priority]},
+      addDocumentWithTargets: { required: [:projectId, :file, :applyWorkflow, :documentName, :format, :encoding, :phaseTemplateId, :sourceLanguage, :tmVaultId], optional: [:targetLanguage, :targetAsJSON, :tmTarget, :zipFile]},
+      addGlossary: { required: [:glossaryName, :asTerminology], optional: []},
+      addLabel: { required: [:name], optional: [:status]},
+      addPhase: { required: [:translationTargetId, :phaseName], optional: [:phaseDescription, :isCommunityAccess, :isSelfAssigned]},
+      addPhaseTemplate: { required: [:phaseTemplateName], optional: [], is_deprecated: true},
+      addPhaseToTemplate: { required: [:phaseTemplateId, :phaseName], optional: [:phaseDescription, :isCommunityAccess, :isSelfAssigned], is_deprecated: true},
+      addPreference: { required: [:key], optional: [:value]},
+      addProject: { required: [:projectName], optional: [:projectDueDate, :companyId, :workflowId, :searchPublic]},
+      addProjectDictionary: { required: [:project_id, :dictionary_id], optional: []},
+      addProjectMT: { required: [:project_id, :mt_engine_name], optional: []},
+      addProjectTMVault: { required: [:tmVaultName, :project_id, :index_id], optional: [:isPublic]},
+      addSegmentLabelTemplate: { required: [:segmentLabelTemplateName], optional: [:segmentLabels]},
+      addSegmentLabelToTemplate: { required: [:segmentLabelTemplateName, :segmentLabels], optional: []},
+      addTeam: { required: [:name], optional: [:description, :image]},
+      addTeamLead: { required: [:teamId, :clientId], optional: []},
+      addTeamMember: { required: [:teamId, :clientId], optional: []},
+      addTMVault: { required: [:tmVaultName], optional: [:isPublic]},
+      addTranslationTarget: { required: [:documentId, :applyWorkflow, :targetLanguage], optional: []},
+      analyzeDocument: { required: [:documentId], optional: []},
+      analyzeProject: { required: [:projectId],  optional: [:documentId]},
+      applyPhaseTemplate: { required: [:translationTargetId, :phaseTemplateId], optional: [], is_deprecated: true},
+      applySegmentLabelTemplate: { required: [:documentId, :segmentLabelTemplateName], optional: []},
+      assignPhaseTranslator: { required: [:phaseId, :translatorUserId], optional: []},
+      assignProjectManager: { required: [:projectId], optional: [:managerLoginName, :managerUserId]},
+      assignSelf: { required: [:phaseId], optional: []},
+      backgroundJobProgress: { required: [:queueId], optional: [], is_deprecated: true},
+      declineExternalInvite: { required: [:invite_id, :phase], optional: []},
+      dismissPhaseTranslator: { required: [:phaseId, :translatorUserId], optional: []},
+      dismissProjectManager: { required: [:projectId, :managerUserId], optional: []},
+      documentSegments: { required: [:documentId], optional: []},
+      downloadDocument: { required: [:documentId, :targetLanguage], optional: [:useSource, :useAttributions]},
+      downloadDocumentAsCSV: { required: [:documentId, :targetLanguage], optional: []},
+      downloadDocumentAsSkeleton: { required: [:documentId], optional: []},
+      downloadDocumentAsTMX: { required: [:documentId], optional: [:targetLanguage]},
+      downloadDocumentAsXliff: { required: [:documentId], optional: [:targetLanguage]},
+      downloadDocumentContent: { required: [:documentId, :targetLanguage], optional: []},
+      downloadExport: { required: [:resourceType, :exportId], optional: []},
+      downloadGlossaryAsCSV: { required: [:glossaryId, :sourceLanguage], optional: [:targetLanguage], is_deprecated: true},
+      downloadGlossaryAsTBX: { required: [:glossaryId, :sourceLanguage], optional: [:targetLanguage], is_deprecated: true},
+      downloadTMVaultAsTMX: { required: [:tmVaultId, :sourceLanguage], optional: [:targetLanguage], is_deprecated: true},
+      downloadTMVaultAsXliff: { required: [:tmVaultId, :sourceLanguage], optional: [:targetLanguage], is_deprecated: true},
+      editClientCommunityPreference: { required: [:key, :value], optional: []},
+      editCompany: { required: [:companyId], optional: [:companyName]},
+      editContact: { required: [:contactId], optional: [:comment]},
+      editDocument: { required: [:documentId], optional: [:documentName, :tmVaultId]},
+      editDocumentSetting: { required: [:documentId, :type, :key, :value], optional: []},
+      editGlossary: { required: [:glossaryId], optional: [:glossaryName]},
+      editLabel: { required: [:id], optional: [:name, :status, :order, :offset, :move_to_label, :show_percent_complete]},
+      editPhase: { required: [:phaseId], optional: [:phaseName, :phaseDescription, :isCommunityAccess, :isSelfAssigned]},
+      editPhaseTemplate: { required: [:phaseTemplateId], optional: [:phaseTemplateName], is_deprecated: true},
+      editPreference: { required: [:key, :value], optional: []},
+      editProject: { required: [:projectId], optional: [:projectName, :projectDueDate, :companyId, :searchPublic]},
+      editProjectSetting: { required: [:projectId, :type, :key, :value], optional: []},
+      editSegmentLabelTemplate: { required: [:segmentLabelTemplateName], optional: []},
+      editTMVault: { required: [:tmVaultId], optional: [:tmVaultName, :isPublic]},
+      editTranslationTarget: { required: [:translationTargetId], optional: []},
+      exportResource: { required: [:resourceType, :resourceId, :format, :targetLanguages, :sourceLanguage], optional: []},
+      findLabel: { required: [:name, :limit], optional: []},
+      findTM: { required: [:tmVaultId, :sourceLang, :targetLang], optional: [:searchText, :startDate, :endDate]},
+      flushDocumentProgress: { required: [:documentId], optional: []},
+      getClientCommunityPreference: { required: [:key], optional: []},
+      getCMSKey: { required: [], optional: []},
+      getCommunityDictionary: { required: [:type], optional: []},
+      getCommunityPreference: { required: [:key, :type], optional: []},
+      getCompany: { required: [:companyId], optional: []},
+      getContact: { required: [:contactId], optional: []},
+      getDashboardLink: { required: [], optional: []},
+      getDocument: { required: [:documentId], optional: []},
+      getDocumentProgress: { required: [:documentId], optional: []},
+      getDocumentSetting: { required: [:documentId, :type, :key], optional: []},
+      getExternalInvites: { required: [:invite_id], optional: []},
+      getGlossary: { required: [:glossaryId], optional: []},
+      getLabel: { required: [], optional: [:id, :name]},
+      getPhase: { required: [:phaseId], optional: []},
+      getPhaseTemplate: { required: [:phaseTemplateId], optional: [], is_deprecated: true},
+      getPreference: { required: [:key], optional: []},
+      getPriorityJobWorkbenchLink: { required: [], optional: []},
+      getProject: { required: [:projectId], optional: []},
+      getProjectSetting: { required: [:projectId, :type, :key], optional: []},
+      getSegmentLabelTemplate: { required: [:segmentLabelTemplateName], optional: []},
+      getTMVault: { required: [:tmVaultId], optional: []},
+      getTranslationTarget: { required: [:translationTargetId], optional: []},
+      getUsers: { required: [:search, :limit, :community], optional: []},
+      getVaultLanguages: { required: [:tmVaultId], optional: []},
+      getWorkbenchLink: { required: [:documentId, :phaseId, :invite_id, :embedded], optional: [:redirectURL]},
+      ignoreSegment: { required: [:segmentId, :documentId], optional: []},
+      importCommunityDictionary: { required: [:type, :file, :delimiter], optional: []},
+      joinTeam: { required: [:teamId], optional: []},
+      leaveTeam: { required: [:teamId], optional: []},
+      listAssignedProjects: { required: [], optional: []},
+      listCommunities: { required: [], optional: []},
+      listCompanies: { required: [], optional: []},
+      listContacts: { required: [], optional: []},
+      listDefaultPhaseTemplates: { required: [], optional: [], is_deprecated: true},
+      listDocuments: { required: [:documentId], optional: []},
+      listDocumentSegmentLabels: { required: [:documentId], optional: []},
+      listDocumentSegments: { required: [:documentId], optional: []},
+      listDocumentTranslationSegments: { required: [:documentId, :targetLanguage], optional: []},
+      listGlossaries: { required: [], optional: []},
+      listJobs: { required: [], optional: []},
+      listLabels: { required: [], optional: []},
+      listLanguages: { required: [], optional: [:language]},
+      listLanguageSkills: { required: [], optional: []},
+      listLeaderboardRange: { required: [], optional: [:teamName, :startDate, :endDate]},
+      listLeaderboardResults: { required: [], optional: [:teamName, :maxResults]},
+      listPhases: { required: [:translationTargetId], optional: []},
+      listPhaseTemplates: { required: [], optional: [], is_deprecated: true},
+      listProjects: { required: [], optional: []},
+      listSegmentLabelTemplates: { required: [], optional: []},
+      listTeamMembers: { required: [:teamId], optional: []},
+      listTeams: { required: [], optional: []},
+      listTMDocuments: { required: [:tmVaultId], optional: []},
+      listTMVaults: { required: [], optional: []},
+      listTranslationTargets: { required: [:documentId], optional: []},
+      listUserStats: { required: [], optional: []},
+      listWorkflows: { required: [], optional: []},
+      machineTranslateDocument: { required: [:documentId, :engineId, :phaseId], optional: []},
+      markPhaseComplete: { required: [:phaseId], optional: []},
+      MTSegments: { required: [:documentId, :json], optional: []},
+      pollClientReport: { required: [:report_name], optional: []},
+      pollDocumentAnalysis: { required: [:documentId], optional: []},
+      pollDocumentImport: { required: [:documentId], optional: []},
+      pollGlossaryImport: { required: [:glossaryUploadId], optional: []},
+      pollProjectAnalysis: { required: [:projectId], optional: []},
+      pollTMVaultImport: { required: [:tmVaultUploadId], optional: []},
+      prefillDocument: { required: [:phaseId, :tmVaultId, :tmVaultThreshold, :lockTMVault, :lockTerminology, :overwrite, :completePhase], optional: []},
+      regardSegment: { required: [:segmentId, :documentId], optional: []},
+      removeClientCommunityPreference: { required: [:key], optional: []},
+      removeCommunityDictionaryEntry: { required: [:type, :entry], optional: []},
+      removeCompany: { required: [:companyId], optional: []},
+      removeContact: { required: [:contactId], optional: []},
+      removeDocument: { required: [:documentId], optional: []},
+      removeGlossary: { required: [:glossaryId], optional: []},
+      removeLabel: { required: [:id], optional: []},
+      removePhase: { required: [:phaseId], optional: []},
+      removePhaseFromTemplate: { required: [:phaseTemplateId, :phaseParameterSetId], optional: []},
+      removePhaseTemplate: { required: [:phaseTemplateId], optional: [], is_deprecated: true},
+      removePreference: { required: [:key], optional: []},
+      removeProject: { required: [:projectId], optional: []},
+      removeSegmentLabelFromTemplate: { required: [:segmentLabelTemplateName, :segmentLabels], optional: []},
+      removeSegmentLabelTemplate: { required: [:segmentLabelTemplateName], optional: []},
+      removeTeam: { required: [:teamId], optional: []},
+      removeTeamLead: { required: [:teamId, :clientId], optional: []},
+      removeTeamMember: { required: [:teamId, :clientId], optional: []},
+      removeTM: { required: [:tmVaultId, :tid], optional: []},
+      removeTMVault: { required: [:tmVaultId], optional: []},
+      removeTranslationTarget: { required: [:translationTargetId], optional: []},
+      removeUploadedTMFromVault: { required: [:id], optional: []},
+      saveLabelTemplate: { required: [:name], optional: [:labels]},
+      saveSegment: { required: [:sourceText, :targetText, :targetLanguage, :documentId, :overwrite], optional: []},
+      searchGlossary: { required: [:glossaryId, :text, :sourceLanguage, :targetLanguage], optional: [:count]},
+      setCommunityConcurrentUsers: { required: [:community, :users], optional: []},
+      setProfileAttributes: { required: [], optional: [:name, :email, :login_id, :phone, :company, :native_language, :location, :notes, :on_leaderboard, :oldpword, :newpword, :source, :old_source, :target, :old_target, :experience, :rate, :rush_rate, :currency, :per, :service_note, :notifications_project_complete, :notifications_assigned_document, :notifications_available_community_document, :notifications_phase_ready]},
+      translatorsForLanguage: { required: [:sourceLang, :targetLang], optional: []},
+      updateContentDocument: { required: [:documentId, :content], optional: [:srxFileContents, :itsFileContents, :fprmFileContents, :secondaryFprmFileContents]},
+      updateDocument: { required: [:documentId, :file], optional: []},
+      updateTM: { required: [:tmVaultId, :tid, :translation], optional: []},
+      uploadCSVToGlossary: { required: [:glossaryId, :file], optional: [:delimiter]},
+      uploadTBXToGlossary: { required: [:glossaryId, :file], optional: []},
+      uploadTMXToTMVault: { required: [:tmVaultId, :file, :name], optional: []},
+      uploadXliffToTMVault: { required: [:tmVaultId, :file, :name], optional: []},
+      uploadXLSToGlossary: { required: [:glossaryId, :file], optional: []},
+      userState: { required: [:clientId], optional: []},
+      allowLocalLogin: { required: [:password], optional: []},
+      validateCredentials: { required: [:password], optional: []},
+    }
+  end
+end

data/lib/lingotek-client/schema.rb

@@ -0,0 +1,37 @@
+require 'json'
+require_relative './api_schema'
+
+module LingotekClient
+  class Schema
+    class << self
+      include APISchema
+
+      def validate!(method, inputs)
+        m = method.to_sym
+        validate_method!(m) && validate_required_input!(m, inputs) && validate_invalid_input!(m, inputs)
+      end
+
+      def valid_methods
+        schema.map{ |k,v| k }
+      end
+
+      def validate_method!(m)
+        throw Exception.new "'#{m}' invalid method" unless valid_methods.include?(m)
+        true
+      end
+
+      def validate_invalid_input!(m, inputs)
+        invalid_input = inputs - (schema[m][:required] + schema[m][:optional])
+        throw Exception.new "'#{invalid_input.join(',')}' invalid input" unless invalid_input.empty?
+        true
+      end
+
+      def validate_required_input!(m, inputs)
+        missing_required = schema[m][:required] - inputs.map{ |i| i.to_sym } 
+        throw Exception.new "'#{missing_required.join(',')}' required input" unless missing_required.empty?
+        true
+      end
+
+    end
+  end
+end

data/lib/lingotek-client/version.rb

@@ -0,0 +1,3 @@
+module LingotekClient
+  VERSION = File.read("#{File.dirname(__FILE__)}/../../VERSION").strip
+end

data/lib/lingotek-client.rb

@@ -0,0 +1,5 @@
+module LingotekClient
+end                               
+
+require "lingotek-client/version"
+require "lingotek-client/api"