jirarest2 0.0.12 → 0.0.13

data/lib/jirarest2/issue.rb

@@ -27,10 +27,12 @@ class Issue
   end
   
   # Receive an issue and all it's fields from jira
+  # @todo This method does not work yet
   # @param [Connection] connection
   def receive(connection)
     uritail = "issue/#{@issueid}"
     result = connection.execute("Get",uritail,{"expand" => "metadata"}) # get the issue AND the metadata because we already know how to parse that.
+    return result
 # TODO Many and more fields
   end
 
@@ -61,5 +63,10 @@ class Issue
     set_assignee(connection, nil)
   end
 
+  # Interpret the result of createmeta for one issuetype
+  # @attr [Hash] issuetype one issutype resulting from createmeta
+  def createmeta(issuetype)
+    @name = issuetype
+  end
 
 end # Issue

data/lib/jirarest2/issuetype.rb

@@ -0,0 +1,256 @@
+#    Copyright (C) 2012 Cyril Bitterich
+#
+#    This program is free software: you can redistribute it and/or modify
+#    it under the terms of the GNU General Public License as published by
+#    the Free Software Foundation, either version 3 of the License, or
+#    (at your option) any later version.
+#
+#    This program is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#    GNU General Public License for more details.
+#
+#    You should have received a copy of the GNU General Public License
+#    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+
+require_relative "field"
+
+# Keep track of one Issuetype
+class Issuetype
+  # @return [String] The name of the issuetype
+  attr_reader :name
+  # @return [String] The description for this issuetype
+  attr_reader :description
+  # @return [Array<Hash>] All the fields in this issuetype
+  attr_reader :fields
+  # @return [Array] All the required fields in this issuetype
+  attr_reader :required_fields
+  
+  #Get the correct Fieldtype based on the schema from createmeta
+  # @attr [Hash] schema The type description we get
+  # @return [String] Name of the Fieldtype to use
+  # @todo timetracking will probably not work
+  # @todo attachment is not realy good either
+  # @todo hiddenjobswitch is unsure
+  # @todo jobcheckbox is unsure
+  # @todo check priority type
+  # @todo how to handle readonlyfield?
+  def decipher_schema(schema) 
+    case schema["type"]
+    when "number"
+      return "NumberField"
+    when "user"
+      return "UserField"
+    when "version"
+      return "VersionField"
+    when "project"
+      return "ProjectField"
+    when "issuetype"
+      return "HashField"
+    when "datetime"
+      return "DateTimeField"
+    when "date"
+      return "DateField"
+    when "priority"
+      return "HashField"
+    when "group"
+      return "UserField"
+    when "resolution"
+      return "HashField"
+    when "timetracking"
+      return "TimetrackingField"
+    when "array"
+      case schema["items"]
+      when "version"
+        return "MultiVersionField"
+      when "group"
+        return "MultiUserField"
+      when "attachment"
+        return "MultiStringField"
+      when "user"
+        return "MultiUserField"
+      when "component"
+        return "MultiHashField"
+      when "string"
+        return "MultiStringField" if schema["system"] && schema["system"] == "labels" # This is the only field with the "system" attribute
+        case schema["custom"] 
+        when /.*:multicheckboxes$/
+          return "MultiHashField"
+        when /.*:multiselect$/
+          return "MultiHashField"
+        when /.*:cascadingselect$/
+          return "CascadingField"
+        else
+          raise Jirarest2::CouldNotDetermineFieldtypeException schema
+        end
+      else
+        raise Jirarest2::CouldNotDetermineFieldtypeException schema
+      end
+    when "string"
+      return "TextField" if schema["system"]
+      schema["custom"] =~ /.*:(\w*)$/
+      case $1
+      when "url"
+        return "TextField"
+      when "textfield"
+        return "TextField"
+      when "textarea"
+        return "TextField"
+      when "radiobuttons"
+        return "HashField"
+      when "select"
+        return "HashField"
+      when "hiddenjobswitch"
+        return "TextField"
+      when "readonlyfield"
+        return "TextField"
+      when "jobcheckbox"
+        return "TextField"
+      else 
+        raise Jirarest2::CouldNotDetermineFieldtypeException schema
+      end
+    else
+      raise Jirarest2::CouldNotDetermineFieldtypeException schema
+    end
+
+  end # def decipher_schema
+
+  # Interpret the result of createmeta for one issuetype
+  # @attr [Hash] issuetype The JSON result for one issuetype
+  # @raise [Jirarest2::WrongIssuetypeException] Raised if the issuetype is not found in the answer
+  # @todo As the name and not the id of the field is used here some fields might get lost. There should be some way around while still enabling the use of names for external calls
+  def createmeta(issuetype)
+    if issuetype.nil? || issuetype["name"].nil? then
+      raise Jirarest2::WrongIssuetypeException
+    else
+      @name = issuetype["name"]
+    end
+    @description = issuetype["description"]
+    @fields = Hash.new
+    @required_fields = Array.new
+    @field_name_id = Hash.new
+    issuetype["fields"].each { |id,structure|
+      name = structure["name"]
+      required = structure["required"]
+      type = decipher_schema(structure["schema"])
+      field = Jirarest2Field::const_get(type).new(id,name,{:required => required, :createmeta => structure})
+      @fields[id]  = field
+      @field_name_id[name] = id
+      @required_fields << field if required
+    }
+  end
+
+  
+  # Interpret the result to the request for an existing issue
+  # @attr [Hash] json The hashed json body of the request
+  # @raise [Jirarest2::FieldsUnknownError] Raised if the fields to this issuetype is unknown
+  # @todo Is this not really Issue instead of Issuetype?
+  # @todo I need name of the issuetype if possible
+  def decode_issue(json)
+    if (@fields.nil? or @fields == {}) then 
+      # Prepare the fields
+      if json.has_key?("schema") then
+        createmeta(json["schema"])
+      elsif  json.has_key?("editmeta") then
+        createmeta(json["editmeta"])
+      else
+        # We need to know what to fill and how
+        raise Jirearesr2::FieldsUnknownError json["self"]
+      end
+    end
+    @issuekey = json["key"]
+    json["fields"].each{ |field_id,content|
+      @fields["field_id"].parse_value(content)
+    }
+  end # def decode_issue
+
+
+  #Set the value of a field
+  # @param [String] id The name of the field
+  # @param [String,Array] value The value of the field
+  # @param [Symbol] denom Field identifier to use (:name or :id)
+  def set_value(id,value,denom = :name)
+    field = get_field(id,denom)
+    field.value = value
+  end
+
+  # Get the value of a field
+  # @param [String] id The name of the field
+  # @return [String,Array] value The value of the field
+  # @param [Symbol] denom Field identifier to use (:name or :id)
+  def get_value(id,denom = :name)
+    field = get_field(id,denom)
+    return field.value
+  end
+
+  
+
+  #check if all the required fields have values
+  # The following fields are not seen as required in this method because JIRA (tm) sets it's own defaults: project, issuetype, reporter
+  # @param [Boolean] only_empty If set to true will only return those Names where the value is empty
+  # @return [Array] Names of all the required_fields that have no value assigned, empty if all fields have a value
+  def required_by_name(only_empty = false)
+    empty = Array.new
+    @required_fields.each{ |field|
+      empty << field.name if (field.value.nil? || ! only_empty ) && !field.name.nil? && field.id != "issuetype" && field.id != "reporter" 
+    }
+    return empty
+  end
+
+  #Build up a hash to give to jira to create a new ticket
+  # @return [Hash] Hash to be sent to the server
+  # @raise [Jirarest2::RequiredFieldNotSetException] Raised if a required field is not set
+  # @todo NOT finished
+  def new_ticket_hash
+    missing_fields = required_by_name(true)
+    if missing_fields == [] then
+      fields = Hash.new
+      @fields.each { |id,field| 
+        fields = fields.merge!(field.to_j) if ! field.to_j.nil? #Sending empty fields with a new ticket will not work
+      }
+      h = {"fields" => fields}
+      return h
+    else
+      raise Jirarest2::RequiredFieldNotSetException, missing_fields
+    end
+  end
+
+  # Return the fieldtype (Multitype as "array" nostly for backwards compability)
+  # @attr [String] fieldname The Name of the field
+  # @return [String] The fieldtype as String. MultiField types and CascadingField are returned as "array"
+  def fieldtype(fieldname)
+    ftype =  get_field(fieldname,:name).class.to_s
+    ftype =~ /^.*::(\w+)Field$/
+    ftshort = $1
+    case ftshort
+    when /Multi.*/
+      return "array"
+    when "Cascading"
+      return "array"
+    else
+      return ftshort
+    end
+  end
+  
+
+
+private
+  # Get the field based on the id and the denominator (:id or :name)
+  # @param [String] id The name of the field
+  # @param [Symbol] denom Field identifier to use (:name or :id)
+  def get_field(id,denom = :name)
+    working_id = id
+    if denom == :name then
+      working_id =  @field_name_id[id] 
+    end
+    field = @fields[working_id]
+    if field.nil? then # Try if it's has been the id all along
+      field = @fields[id]
+    end
+    raise Jirarest2::WrongFieldnameException, id if field.nil?
+    return field
+  end
+
+
+end # class Issuetype

data/lib/jirarest2/madbitconfig.rb

@@ -30,8 +30,9 @@ require "json"
   # The config file can either contain key = value pairs or JSON data
   # JSON and simple "key = value\n" lines work 
   # TODO make it work with "key = [value,value]\n" or even "key = value1 \n value2 \n ..."
-  # @param [String] configfile
+  # @param [String] config_file
   # @param [Boolean] whitespace Keep whitespace characters? 
+  # @raise [IOError] Raised if the file indicated by config_file is not found
   # @return [Hash] Hash configparameters
   def self.read_configfile(config_file,whitespace = false)
     if whitespace then    
@@ -82,6 +83,7 @@ require "json"
   # @param [String] config_file Name (and path) of the config file
   # @param [Hash] configoptions Hash of "option" => "value" pairs
   # @param [Symbol] save Determines if an existing file is to be kept. :force replaces an existing file
+  # @raise [FileExistsException] Raised if the file that is to be written already exists and the overwrite flag (save) is not set to :force
   def self.write_configfile(config_file, configoptions, save = :noforce)
     config_file = File.expand_path(config_file) # Be save
     

data/lib/jirarest2/newissue.rb

@@ -15,10 +15,10 @@
 #    along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 
-=begin
-# An Issue object contains all the data of an issue
-=end
-class NewIssue
+require_relative "issuetype"
+
+# class to handle new issues (building them up, changing fields, persistence)
+class NewIssue 
     
   # issue type of the issue 
   attr_reader :issuetype
@@ -30,197 +30,61 @@ class NewIssue
   # @param [String] project Key of the JIRA(tm) project the issue belongs to
   # @param [String] type Issuetype the issue belongs to
   # @param [Connection] connection
+  # @raise [Jirarest2::WrongProjectException] Raised of the project type is not found in the answer
   def initialize (project,type,connection)
     query = {:projectKeys => project, :issuetypeNames => type, :expand => "projects.issuetypes.fields" }
     answer = connection.execute("Get","issue/createmeta/",query)
     jhash = answer.result
-    parse_json(jhash)
-    raise Jirarest2::WrongProjectException, project if @project == ""
-    raise Jirarest2::WrongIssuetypeException, type if @issuetype == ""
-  end
-
-  # produces an instance-variable @issuefields that can be 
-  # @param [Hash] jhash Hashed version of the json-snippet JIRA(tm) returns
-  def parse_json (jhash)
-    @issuefields = Hash.new
-    @project = ""
-    @issuetype = ""
-    jhash["projects"].each { |value|
-      @project = value["key"]
-      value["issuetypes"].each { |value1|
-        @issuetype = value1["name"]
-        value1["fields"].delete("project") #The project key is duplicate and will make our live harder afterwards. It is marked as required but nothing happens if this key is not set.
-        value1["fields"].each { |key,value2|
-          fields = Hash.new
-          fields["id"] = key
-          if value2["name"] then
-            name = value2["name"]
-          else
-            name = key
-          end
-          # If the allowed reponses are limited we want to know them.
-          if value2["allowedValues"] then
-            # With custom fields the identifier is "value" with the built in ones it's "name"
-            identifier = "name"
-            if value2["schema"]["custom"] then
-              identifier = "value"
-            end
-            allowedValues = Array.new
-            value2["allowedValues"].each { |value3|
-              allowedValues << value3[identifier]
-            } # value3
-            fields["allowedValuesIdentifier"] = identifier
-            fields["allowedValues"] = allowedValues
-          end
-          fields["required"] = value2["required"] 
-          fields["type"] = value2["schema"]["type"]
-          @issuefields[name] = fields if name != "Issue Type" # "Issue Type" is not really a required field as we have to assign it at another place anyway
-        } # value1
-      } # value
-    } # jhash
-  end
-  
-  # @param [String] field Name of the field
-  # @return [String] type of the Field 
-  def fieldtype(field)
-    # If the fieldname is wrong we want to tell this and stop execution (or maybe let the caller fix it)
-    if @issuefields[field].nil? then
-      raise Jirarest2::WrongFieldnameException, field
-    else
-      return @issuefields[field]["type"]
+    begin
+      @project = jhash["projects"][0]["key"]
+    rescue NoMethodError
+      raise Jirarest2::WrongProjectException, project 
     end
+    @issue = Issuetype.new
+    @issue.createmeta(jhash["projects"][0]["issuetypes"][0])
+    @issuetype = @issue.name
   end
-  
+
   # @return [Array] Names of required fields
   def get_requireds
-    names = Array.new
-    @issuefields.each {|key,value|
-      if value["required"] then
-        names << key
-      end
-    }
-    return names
+    return @issue.required_by_name
   end
 
   # @return [Array] Names of all fields
   def get_fieldnames
     names = Array.new
-    @issuefields.each {|key,value|
-        names << key
+    @issue.fields.each {|id,field|
+      names << field.name
     }
     return names
   end
 
-  # @param [String] name Name of a field
-  # @return [String] id of the field
-  protected
-  def get_id(name)
-    return @issuefields["name"]["id"]
-  end
-
-=begin
-# query=
-# {"fields"=>
-#  { "project"=>{"key"=>"MFTP"}, 
-#    "environment"=>"REST ye merry gentlemen.", 
-#    "My own text"=>"Creating of an issue using project keys and issue type names using the REST API",
-#    "issuetype"=> {"name"=>"My own type"}
-#  }
-# }
-=end
-
+  # take this classes representation of an issue and make it presentable to JIRA(tm)
   # @return [Hash] Hash to be sent to JIRA(tm) in a JSON representation
-  public
+  # @deprecated @see Issuetype#new_ticket_hash does the same now
   def jirahash
-    h = Hash.new
-    issuetype = {"issuetype" => {"name" => @issuetype}}
-    project = {"key" => @project}
-    fields = Hash.new
-    fields["project"] = project
-    # here we need to enter the relevant fields and their values
-    @issuefields.each { |key,value|
-      if key !=  "project" then
-        id = value["id"]
-        if ! value["value"].nil? then
-          fields[id] = value["value"]
-        end
-      end
-    }
-    fields = fields.merge!(issuetype)
-    h = {"fields" => fields}
-    return h
+    return @issue.new_ticket_hash
   end
 
-  # check if the value is allowed for this field
-  # @param [String] key Name of the field
-  # @param [String] value Value to be checked
-  # @return [Boolean, Jirarest2::ValueNotAllowedException]
-  protected
-  def value_allowed?(key,value)
-    if @issuefields[key]["allowedValues"].include?(value) 
-      return true
-    else
-#      puts "Value #{value} not allowed for field #{key}."
-      raise Jirarest2::ValueNotAllowedException.new(key, @issuefields[key]["allowedValues"]), value
-    end
-  end
-
-
-  # Special setter for fields that have a limited numer of allowed values.
-  #
-  # This setter might be included in set_field at a later date.
-  # @param [String] key Name of the field
-  # @param [String] value Value to be checked
-  def set_allowed_value(key,value)
-    if @issuefields[key]["type"] == "array" && value.instance_of?(Array)  then
-      array = Array.new
-      value.each {|item|
-        if value_allowed?(key,item) then
-          array << {@issuefields[key]["allowedValuesIdentifier"] => item}
-        end
-      }
-      @issuefields[key]["value"] = array
-    else
-      if value_allowed?(key,value) then
-        @issuefields[key]["value"] = {@issuefields[key]["allowedValuesIdentifier"] => value}
-      end
-    end
-  end
-
-
-  # TODO We are not yet able to work with "Cascading Select" fields ( "custom": "com.atlassian.jira.plugin.system.customfieldtypes:cascadingselect")
   # @param [String] key Name of the field
   # @param [String] value Value the field should be set to, this is either a String or an Array (don't know if numbers work too)
-  public
+  # @raise [Jirarest2::WrongFieldnameException] Raised if the name of the field is not found
+  # @todo check if the allowed Values are working now too and if they might throw an exception
   def set_field(key, value)
-    if  @issuefields.include?(key) then
-      if @issuefields[key].include?("allowedValues") then
-        set_allowed_value(key,value)
-      else
-        @issuefields[key]["value"] = value
-      end
-    else
-      raise Jirarest2::WrongFieldnameException, key
-      puts "Unknown Field: #{key}"
-    end
+    @issue.set_value(key,value,:name)
   end
 
   # @param [String] field Name of the field
   # @return [String] value of the field
   def get_field(field)
-    @issuefields[field]["value"]
+    @issue.get_value(field,:name)
   end
 
   # persitence of this Issue object instance
   # @param [Connection] connection
   # @return [Jirarest2::Result]
   def persist(connection)
-    get_requireds.each { |fieldname| 
-      if @issuefields[fieldname]["value"].nil? then
-        raise Jirarest2::RequiredFieldNotSetException, fieldname
-      end
-    }
-    hash = jirahash
+    hash = @issue.new_ticket_hash
     ret = connection.execute("Post","issue/",hash) 
     if ret.code == "201" then # Ticket sucessfully created
       @issuekey = ret.result["key"]
@@ -228,8 +92,6 @@ class NewIssue
     return ret
   end
 
-
-
   # Set the watchers for this Ticket
   # @param [Connection] connection
   # @param [Array] watchers Watchers to be added
@@ -243,5 +105,11 @@ class NewIssue
     return success
   end
 
+  # Return the fieldtype (Multitype as "array" nostly for backwards compability)
+  # @attr [String] fieldname The Name of the field
+  # @return [String] The fieldtype as String. MultiField types and CascadingField are returned as "array"
+  def fieldtype(fieldname)
+    return @issue.fieldtype(fieldname)
+  end
   
 end # class