refworks 0.0.2

data/lib/refworks/authentication/ping/authentication_ping_request.rb

@@ -0,0 +1,21 @@
+class AuthenticationPingRequest < AuthenticationRequest
+  def self.call_method
+    'ping'
+  end
+
+  def self.generate_request_info(params)
+
+    # get common Authentication parameters
+    class_params = generate_class_params(params)
+
+    # query parameters for the ping call
+    method_params = { :method => call_method,
+    }
+
+    query_string_params = class_params.merge(method_params)
+
+    # return the request info
+    {:params => query_string_params}
+  end
+
+end

data/lib/refworks/authentication/ping/authentication_ping_response.rb

@@ -0,0 +1,3 @@
+class AuthenticationPingResponse < AuthenticationResponse
+
+end

data/lib/refworks/authentication/userexists/authentication_userexists_request.rb

@@ -0,0 +1,37 @@
+class AuthenticationUserexistsRequest < AuthenticationRequest
+  def self.call_method
+    'userexists'
+  end
+
+  def self.http_request_verb
+    'POST'
+  end
+
+  def self.generate_request_info(params)
+
+    # get common Authentication parameters
+    class_params = generate_class_params(params)
+
+    # query parameters for the ping call
+    method_params = { :method => call_method,
+    }
+
+    query_string_params = class_params.merge(method_params)
+
+    # Construct the XML payload for the userexists call.
+    login_name = params[:login_name]
+    password = params[:password]
+    group_code = params[:group_code]
+
+    message_body = <<-EOS
+      <RWRequest class="authentication" method="userexists">
+        <AcctInfo loginName="#{login_name}" groupCode="#{group_code}" password="#{password}"></AcctInfo>
+      </RWRequest>
+    EOS
+
+    # return the request info
+    {:params => query_string_params, :body => message_body, :headers => {'Content-type' => 'text/xml'}}
+  end
+
+
+end

data/lib/refworks/authentication/userexists/authentication_userexists_response.rb

@@ -0,0 +1,3 @@
+class AuthenticationUserexistsResponse < AuthenticationResponse
+
+end

data/lib/refworks/authors/all/authors_all_request.rb

@@ -0,0 +1,29 @@
+# The Author class all method call.
+# This call has no method-specific parameters.
+#
+# Users will not instantiate this class directly; the Refworks.request method will do so.
+# @api private
+class AuthorsAllRequest < AuthorsRequest
+  def self.call_method
+    'all'
+  end
+
+  # Assembles the information needed to construct the query string for this request
+  # @param [Hash] params This should be an empty hash.  This call has no method-specific parameters.
+  # @return [Hash] Returns hash of request parameters for this call.
+  def self.generate_request_info(params)
+
+    # get common Authors parameters
+    class_params = generate_class_params(params)
+
+    # query parameters for the all call
+    method_params = { :method => call_method,
+    }
+
+    query_string_params = class_params.merge(method_params)
+
+    # return the request info
+    {:params => query_string_params}
+  end
+
+end

data/lib/refworks/authors/all/authors_all_response.rb

@@ -0,0 +1,3 @@
+class AuthorsAllResponse < AuthorsResponse
+
+end

data/lib/refworks/authors/author.rb

@@ -0,0 +1,10 @@
+class Author
+
+  attr_reader :name, :nRefs
+
+  def initialize(rawauthor)
+    @name = rawauthor["__content__"]
+    @nRefs = rawauthor["nRefs"]
+  end
+
+end

data/lib/refworks/authors/authors_request.rb

@@ -0,0 +1,23 @@
+# The Author class base abstract request class.
+# Parameters common to all Author class calls are captured here.
+#
+# @abstract
+# @api private
+class AuthorsRequest < Request
+  def self.call_class
+    "authors"
+  end
+
+  # Handle parameters common to all Author calls.
+  # @param [Hash] params All Author class calls should include the params :pgsize and :pgnum in their method_params.
+  def self.generate_class_params(params)
+    class_name = call_class()
+
+    # query parameters common to all Authors calls
+    {
+        :class => class_name,
+        :pgsize => params[:pgsize] || 50,
+        :pgnum => params[:pgnum] || 1,
+    }
+  end
+end

data/lib/refworks/authors/authors_response.rb

@@ -0,0 +1,32 @@
+class AuthorsResponse < Response
+
+  attr_reader :total, :authors
+
+  def initialize(raw_response)
+    super(raw_response)
+    if result_code != "200"
+      @total = "0"
+      return
+    end
+
+    # If results returned, process the authors and metadata
+
+    @total = self.parsed_response["refworks"]["RWResult"]["RWAuthor"]["total"]
+
+    author_list = self.parsed_response["refworks"]["RWResult"]["RWAuthor"]["Author"]
+
+    # here we parse out authors into an array of actual Author objects (even if only 1 ref returned)
+    @authors = Array.new
+
+    # The RefWorks API can return an array or a single element depending on how many authors were returned.
+    if author_list.class == Array
+      author_list.each do |rawauthor|
+        @authors << Author.new(rawauthor)
+      end
+    else
+      # here, "author_list" is just a hash representing a single author
+      # in other words, only one author was returned
+      @authors << Author.new(author_list)
+    end
+  end
+end

data/lib/refworks/authors/search/authors_search_request.rb

@@ -0,0 +1,23 @@
+class AuthorsSearchRequest < AuthorsRequest
+
+  def self.call_method
+    'search'
+  end
+
+  def self.generate_request_info(params)
+
+    # get common Authors parameters
+    class_params = generate_class_params(params)
+
+    # query parameters for the search call
+    method_params = { :method => call_method,
+                      :search => params[:search],
+    }
+
+    query_string_params = class_params.merge(method_params)
+
+    # return the request info
+    {:params => query_string_params}
+  end
+
+end

data/lib/refworks/authors/search/authors_search_response.rb

@@ -0,0 +1,3 @@
+class AuthorsSearchResponse < AuthorsResponse
+
+end

data/lib/refworks/descriptors/all/descriptors_all_request.rb

@@ -0,0 +1,21 @@
+class DescriptorsAllRequest < DescriptorsRequest
+  def self.call_method
+    'all'
+  end
+
+  def self.generate_request_info(params)
+
+    # get common Descriptors parameters
+    class_params = generate_class_params(params)
+
+    # query parameters for the all call
+    method_params = { :method => call_method,
+    }
+
+    query_string_params = class_params.merge(method_params)
+
+    # return the request info
+    {:params => query_string_params}
+  end
+
+end

data/lib/refworks/descriptors/all/descriptors_all_response.rb

@@ -0,0 +1,3 @@
+class DescriptorsAllResponse < DescriptorsResponse
+
+end

data/lib/refworks/descriptors/descriptor.rb

@@ -0,0 +1,8 @@
+class Descriptor
+  attr_reader :name, :nRefs
+
+  def initialize(rawdesc)
+    @name = rawdesc["__content__"]
+    @nRefs = rawdesc["nRefs"]
+  end
+end

data/lib/refworks/descriptors/descriptors_request.rb

@@ -0,0 +1,17 @@
+class DescriptorsRequest < Request
+  def self.call_class
+    "descriptors"
+  end
+
+  def self.generate_class_params(params)
+    # handle params common to all Descriptors calls
+    class_name = call_class()
+
+    # query parameters common to all Descriptors calls
+    {
+        :class => class_name,
+        :pgsize => params[:pgsize] || 50,
+        :pgnum => params[:pgnum] || 1,
+    }
+  end
+end

data/lib/refworks/descriptors/descriptors_response.rb

@@ -0,0 +1,31 @@
+class DescriptorsResponse < Response
+  attr_reader :total, :descriptors
+
+  def initialize(raw_response)
+    super(raw_response)
+    if result_code != "200"
+      @total = "0"
+      return
+    end
+
+    # If results returned, process the descriptors and metadata
+
+    @total = self.parsed_response["refworks"]["RWResult"]["RWDescriptor"]["total"]
+
+    desc_list = self.parsed_response["refworks"]["RWResult"]["RWDescriptor"]["Descriptor"]
+
+    # here we parse out into an array of actual Descriptor objects (even if only 1 ref returned)
+    @descriptors = Array.new
+
+    # The RefWorks API can return an array or a single element depending on how many descriptors were returned.
+    if desc_list.class == Array
+      desc_list.each do |rawdesc|
+        @descriptors << Descriptor.new(rawdesc)
+      end
+    else
+      # here, "descriptor_list" is just a hash representing a single descriptor
+      # in other words, only one was returned
+      @descriptors << Descriptor.new(desc_list)
+    end
+  end
+end

data/lib/refworks/descriptors/search/descriptors_search_request.rb

@@ -0,0 +1,24 @@
+class DescriptorsSearchRequest < DescriptorsRequest
+
+  def self.call_method
+    'search'
+  end
+
+  def self.generate_request_info(params)
+
+    # get common Descriptors parameters
+    class_params = generate_class_params(params)
+
+    # query parameters for the search call
+    method_params = { :method => call_method,
+                      :search => params[:search],
+    }
+
+    query_string_params = class_params.merge(method_params)
+
+    # return the request info
+    {:params => query_string_params}
+  end
+
+
+end

data/lib/refworks/descriptors/search/descriptors_search_response.rb

@@ -0,0 +1,3 @@
+class DescriptorsSearchResponse < DescriptorsResponse
+
+end

data/lib/refworks/folders/all/folders_all_request.rb

@@ -0,0 +1,20 @@
+class FoldersAllRequest < FoldersRequest
+  def self.call_method
+    'all'
+  end
+
+  def self.generate_request_info(params)
+
+    # get common Folders parameters
+    class_params = generate_class_params(params)
+
+    # query parameters for the all call
+    method_params = { :method => call_method,
+    }
+
+    query_string_params = class_params.merge(method_params)
+
+    # return the request info
+    {:params => query_string_params}
+  end
+end

data/lib/refworks/folders/all/folders_all_response.rb

@@ -0,0 +1,3 @@
+class FoldersAllResponse < FoldersResponse
+
+end

data/lib/refworks/folders/folder.rb

@@ -0,0 +1,10 @@
+class Folder
+  attr_reader :name, :nRefs, :type
+
+  def initialize(rawfolder)
+    @name = rawfolder["__content__"]
+    @nRefs = rawfolder["nRefs"]
+    @type = rawfolder["type"]
+  end
+
+end

data/lib/refworks/folders/folders_request.rb

@@ -0,0 +1,17 @@
+class FoldersRequest < Request
+  def self.call_class
+    "folders"
+  end
+
+  def self.generate_class_params(params)
+    # handle params common to all Folders calls
+    class_name = call_class()
+
+    # query parameters common to all Folders calls
+    {
+        :class => class_name,
+        :pgsize => params[:pgsize] || 50,
+        :pgnum => params[:pgnum] || 1,
+    }
+  end
+end

data/lib/refworks/folders/folders_response.rb

@@ -0,0 +1,32 @@
+class FoldersResponse < Response
+
+  attr_reader :total, :folders
+
+  def initialize(raw_response)
+    super(raw_response)
+    if result_code != "200"
+      @total = "0"
+      return
+    end
+
+    # If results returned, process the folders and metadata
+
+    @total = self.parsed_response["refworks"]["RWResult"]["RWFolders"]["total"]
+
+    folder_list = self.parsed_response["refworks"]["RWResult"]["RWFolders"]["Folders"]
+
+    # here we parse out folders into an array of actual Author objects (even if only 1 ref returned)
+    @folders = Array.new
+
+    # The RefWorks API can return an array or a single element depending on how many folders were returned.
+    if folder_list.class == Array
+      folder_list.each do |rawfolder|
+        @folders << Folder.new(rawfolder)
+      end
+    else
+      # here, "folder_list" is just a hash representing a single folder
+      # in other words, only one folder was returned
+      @folders << Folder.new(folder_list)
+    end
+  end
+end

data/lib/refworks/folders/search/folders_search_request.rb

@@ -0,0 +1,21 @@
+class FoldersSearchRequest < FoldersRequest
+  def self.call_method
+    'search'
+  end
+
+  def self.generate_request_info(params)
+
+    # get common Folders parameters
+    class_params = generate_class_params(params)
+
+    # query parameters for the search call
+    method_params = { :method => call_method,
+                      :search => params[:search],
+    }
+
+    query_string_params = class_params.merge(method_params)
+
+    # return the request info
+    {:params => query_string_params}
+  end
+end