apadmi_grout 1.0.0 → 2.0.0

data/lib/apadmi/grout/models/release_notes_config.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Apadmi
+  module Grout
+    # @param tasks [Array<Apadmi::Grout::Issue>]
+    # @param features [Array<Apadmi::Grout::Issue>] aka stories
+    # @param improvements [Array<Apadmi::Grout::Issue>]
+    # @param defects [Array<Apadmi::Grout::Issue>] aka bugs
+    # @param others [Array<Apadmi::Grout::Issue>] any other non-standard issue types
+    ClassifiedIssues = Struct.new(
+      :tasks,
+      :features,
+      :improvements,
+      :defects,
+      :others
+    ) do
+      # @return returns true if all categories are empty
+      def empty
+        tasks.empty? && features.empty? &&
+          improvements.empty? && defects.empty? && others.empty?
+      end
+    end
+
+    # @param title [String] The title of the document
+    # @param app_version [String] The app version pertaining to this release
+    # @param min_os_version [String] The min supported os version of this release
+    # @param date [String] Today's date
+    # @param moved_issues [Array<Apadmi::Grout::Issue>] Issues moved to a new state by this build job
+    # @param release_issues [Array<Apadmi::Grout::Issue>] Issues considered part of this release
+    # @param commit_hash [String] Commit hash from which release was built
+    # @param ci_build_number [String] CI build number which built the release
+    # @param ci_build_url [String] Link to CI build job
+    # @param templates [Apadmi::Grout::Templates] Mustache templates to use to generate the document
+    ReleaseNotesConfig = Struct.new(
+      :title,
+      :app_version,
+      :min_os_version,
+      :date,
+      :moved_issues,
+      :release_issues,
+      :commit_hash,
+      :ci_build_number,
+      :ci_build_url,
+      :templates
+    )
+  end
+end

data/lib/apadmi/grout/{release_notes/models → models}/release_notes_templates.rb

@@ -9,7 +9,7 @@ module Apadmi
 
 ### Version
 {{config.app_version}}
-{{config.hello}}
+
 ### Release date
 {{config.date}}
 
@@ -30,35 +30,35 @@ Commit Hash: {{config.commit_hash}}
         %{### New functionality
 {{# classified_issues.features.first}}
 {{# classified_issues.features}}
-* [{{ key }} - {{ summary }}]({{ base_url }}{{ key }})
+* [{{ key }} - {{ summary }}]({{ url }})
 {{/ classified_issues.features}}
 
 {{/ classified_issues.features.first}}
 {{# classified_issues.improvements.first}}
 ### Improvements
   {{# classified_issues.improvements}}
-* [{{ key }} - {{ summary }}]({{ base_url }}{{ key }})
+* [{{ key }} - {{ summary }}]({{ url }})
   {{/ classified_issues.improvements}}
 
 {{/ classified_issues.improvements.first}}
 {{# classified_issues.tasks.first}}
 ### Completed Tasks
   {{# classified_issues.tasks}}
-* [{{ key }} - {{ summary }}]({{ base_url }}{{ key }})
+* [{{ key }} - {{ summary }}]({{ url }})
   {{/ classified_issues.tasks}}
 
 {{/ classified_issues.tasks.first}}
 {{# classified_issues.defects.first}}
 ### Fixed defects
   {{# classified_issues.defects}}
-* [{{ key }} - {{ summary }}]({{ base_url }}{{ key }})
+* [{{ key }} - {{ summary }}]({{ url }})
   {{/ classified_issues.defects}}
 
 {{/ classified_issues.defects.first}}
 {{# classified_issues.others.first}}
 ### Other issue types
   {{# classified_issues.others}}
-* [{{ key }} - {{ summary }}]({{ base_url }}{{ key }})
+* [{{issue_type}} - {{ key }} - {{ summary }}]({{ url }})
   {{/ classified_issues.others}}
 
 {{/ classified_issues.others.first}}}

data/lib/apadmi/grout/service/board_service/ado_board_service.rb

@@ -0,0 +1,199 @@
+# frozen_string_literal: true
+
+require_relative "./board_service"
+
+module Apadmi
+  module Grout
+    # Provides a layer of abstraction on top of the ADO api
+    class AdoBoardService < BoardService
+      API_VERSION_PARAM = "api-version=6.0"
+
+      # @param [Apadmi::Grout::NetworkService] network_service
+      # @param [Apadmi::Grout::AdoConfig] ado_config
+      # @param [Logger] logger
+      def initialize(network_service, ado_config, logger)
+        @network_service = network_service
+        @ado_config = ado_config
+        @logger = logger
+      end
+
+      # @param [String[]] keys
+      # @return [Array<Apadmi::Grout::Issue>]
+      def find_issues_by_keys(keys)
+        return [] if keys.length <= 0
+
+        keys = keys.map { |k| sanitise_key(k) } # Allows supporting raw keys, and keys prefixed with a hash which is common ADO practice
+
+        res = @network_service.do_get("/wit/workitems?ids=#{keys.join(",")}&api-version=7.1-preview.2")
+        parsed = JSON.parse(res.body)
+        items = parsed["value"]
+
+        return if items.nil? || items.empty?
+
+        items.map { |i| Apadmi::Grout::Issue.from_ado_hash(i) }
+      end
+
+      # @param component [String] Included to be consistent with JIRA, this will boil down to a tag in ADO
+      # @param status [String]
+      # @param ticket_types [String[]]
+      # @param options [Apadmi::Grout::AdoFindTicketsOptions] Additional options to filter by
+
+      # @return [Array<Apadmi::Grout::Issue>]
+      def search_unblocked_issues(component, status, ticket_types = [], options = nil)
+        tags = (options&.required_tags || []).push(*component).filter { |it| !it.blank? }
+        not_tags = (options&.not_tags || []).filter { |it| !it.blank? }
+
+        raise "Tags can either be required or not required, not both" unless (tags & not_tags).empty?
+
+        tags_filter = tags.map { |tag| " AND [System.Tags] CONTAINS '#{tag}' " }.join(" ")
+        not_tags_filter = not_tags.map { |tag| " AND [System.Tags] NOT CONTAINS '#{tag}'" }.join(" ")
+
+        status_filter = ("AND [System.State]='#{status}' " unless status.blank?) || ""
+        type_filter = ("AND [System.WorkItemType] IN (#{ticket_types.map { |t| "'#{t}'" }.join(", ")})" unless ticket_types.empty?) || ""
+        wiql = %(
+          Select [System.Id]
+          From WorkItems
+          Where [System.Id] >= 1
+          #{status_filter}
+          #{tags_filter}
+          #{not_tags_filter}
+          #{type_filter}
+        )
+
+        get_issues_by_wiql(wiql)
+      end
+
+      # @param [String] key
+      # @param [String] comment
+      def flag_ticket(key, comment)
+        key = sanitise_key(key)
+
+        add_tag(key, @ado_config.flag_tag)
+        add_comment(key, comment) unless comment.blank?
+      end
+
+      # @param [String] key
+      def un_flag_ticket(key)
+        key = sanitise_key(key)
+
+        remove_tag(key, @ado_config.flag_tag)
+      end
+
+      # @param [String] key
+      # @param [String] comment
+      def add_comment(key, comment)
+        key = sanitise_key(key)
+
+        payload = {
+          "text" => comment
+        }
+        @network_service.do_post("/wit/workitems/#{key}/comments?#{API_VERSION_PARAM}-preview.3", payload.to_json)
+      end
+
+      # @param [String] key
+      # @param [String] tag
+      def add_tag(key, tag)
+        payload = [{
+          "op" => "add",
+          "path" => "/fields/System.Tags",
+          "value" => tag
+        }]
+        @network_service.do_patch("/wit/workitems/#{key}?#{API_VERSION_PARAM}", payload.to_json)
+      end
+
+      # @param [String] key
+      # @param [String] tag
+      def remove_tag(key, tag)
+        current_tags = get_work_item(key)["fields"]["System.Tags"].split("; ")
+        new_tags = current_tags.filter { |t| t != tag }
+
+        payload = [{
+          "op" => "replace",
+          "path" => "/fields/System.Tags",
+          "value" => new_tags.join("; ")
+        }]
+        @network_service.do_patch("/wit/workitems/#{key}?#{API_VERSION_PARAM}", payload.to_json)
+      end
+
+      # @param [String] key
+      def flagged?(key)
+        current_tags = get_work_item(key)["fields"]["System.Tags"].split("; ")
+        current_tags.include?(@ado_config.flag_tag)
+      end
+
+      # @param [String] key
+      # @return [RawWorkItemHash]
+      def get_work_item(key)
+        key = sanitise_key(key)
+
+        res = @network_service.do_get("/wit/workitems/#{key}?#{API_VERSION_PARAM}")
+        JSON.parse(res.body)
+      end
+
+      # @param [String] key
+      # @param [Array<String>] versions
+      def assign_fixversions(key, versions)
+        key = sanitise_key(key)
+
+        payload = [{
+          "op" => "replace",
+          "path" => "/fields/Microsoft.VSTS.Build.IntegrationBuild",
+          "value" => versions.join("; ")
+        }]
+        @network_service.do_patch("/wit/workitems/#{key}?#{API_VERSION_PARAM}", payload.to_json)
+      end
+
+      # @param [String] key
+      # @return [Array<String>] fix versions
+      def get_ticket_fixversions(key)
+        key = sanitise_key(key)
+
+        get_work_item(key)["fields"]["Microsoft.VSTS.Build.IntegrationBuild"].split("; ")
+      end
+
+      # @param [Apadmi::Grout::Issue] issue
+      # @param [String] state_name
+      def transition_issue(issue, state_name)
+        key = sanitise_key(issue.key)
+
+        payload = [{
+          "op" => "add",
+          "path" => "/fields/System.State",
+          "value" => state_name
+        }]
+        @network_service.do_patch("/wit/workitems/#{key}?#{API_VERSION_PARAM}", payload.to_json)
+      end
+
+      # @param [String] key
+      # @return [String]
+      def get_ticket_status(key)
+        key = sanitise_key(key)
+
+        get_work_item(key)["fields"]["System.State"]
+      end
+
+      private
+
+      def sanitise_key(key)
+        key = key.to_s.strip.delete_prefix "#"
+        raise "Invalid key" if key.blank?
+
+        key
+      end
+
+      # @param wiql_query [String]
+      # @return [Array<Apadmi::Grout::Issue>]
+      def get_issues_by_wiql(wiql_query)
+        @logger.message("Executing wiql")
+        @logger.message(wiql_query)
+
+        payload = { "query" => wiql_query }
+        res = @network_service.do_post("/wit/wiql?#{API_VERSION_PARAM}", payload.to_json)
+        parsed = JSON.parse(res.body)
+        items = parsed["workItems"] || []
+        ids = items.map { |item| item["id"] } || []
+        find_issues_by_keys(ids)
+      end
+    end
+  end
+end

data/lib/apadmi/grout/service/board_service/board_service.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Apadmi
+  module Grout
+    # A generic board service to be implemented by whatever
+    # board providers we have e.g. JIRA and ADO
+    class BoardService
+      # @param [String[]] keys
+      # @return [Array<Apadmi::Grout::Issue>]
+      def find_issues_by_keys(_keys)
+        raise "Unimplemented :("
+      end
+
+      # @param [String] _component
+      # @param [String] _status
+      # @param [String[]] _ticket_types
+      # @param [Apadmi::Grout::JiraFindTicketsOptions|Apadmi::Grout::JiraFindTicketsOptions] _options
+      # @return [Array<Apadmi::Grout::Issue>]
+      def search_unblocked_issues(_component, _status, _ticket_types = [], _options = nil)
+        raise "Unimplemented :("
+      end
+
+      # @param [String] _key
+      # @param [String] _comment
+      def flag_ticket(_key, _comment)
+        raise "Unimplemented :("
+      end
+
+      # @param [String] _key
+      def un_flag_ticket(_key)
+        raise "Unimplemented :("
+      end
+
+      # @param [String] _key
+      # @return bool
+      def flagged?(_key)
+        raise "Unimplemented :("
+      end
+
+      # @param [String] _key
+      # @param [Array<String>] _version_strings
+      def assign_fixversions(_key, _version_strings)
+        raise "Unimplemented :("
+      end
+
+      # @param [String] _key
+      # @return [Array<String>]
+      def get_ticket_fixversions(_key)
+        raise "Unimplemented :("
+      end
+
+      # @param [Apadmi::Grout::Issue] _issue
+      # @param [String] _state_name
+      def transition_issue(_issue, _state_name)
+        raise "Unimplemented :("
+      end
+    end
+  end
+end

data/lib/apadmi/grout/{jira/wrapper/jira_wrapper.rb → service/board_service/jira_board_service.rb}

@@ -1,23 +1,18 @@
 # frozen_string_literal: true
 
-# Build tools
 require "jira-ruby"
-require "faraday"
 
 module Apadmi
   module Grout
     # Provides a layer of abstraction on top of the Jira api
-    class JiraWrapper
-      APPLICATION_JSON = "application/json"
-      CONTENT_TYPE = "Content-Type"
-      private_constant :CONTENT_TYPE, :APPLICATION_JSON
-
+    class JiraBoardService < BoardService
       # @param [String] username
       # @param [String] token
       # @param [String] base_url
       # @param [String] context_path
       # @param [String] project
-      def initialize(username, token, base_url, context_path, project)
+      # @param [Apadmi::Grout::NetworkService] network_service
+      def initialize(username, token, base_url, context_path, project, network_service)
         @options = {
           username: username,
           password: token,
@@ -26,52 +21,64 @@ module Apadmi
           auth_type: :basic
         }
         @project = project
+        @network_service = network_service
         @jira_client = JIRA::Client.new(@options)
       end
 
-      # @return returns the ticket prefix for the given project
-      def issue_id_prefix
-        @project
-      end
-
       # @param [String[]] keys
-      # @return [Array<JIRA::Resource::Issue>]
+      # @return [Array<Apadmi::Grout::Issue>]
       def find_issues_by_keys(keys)
         return [] if keys.length <= 0
 
         jql_search = "project = '#{@project}' AND issue IN (#{keys.join(", ")})"
-        @jira_client.Issue.jql(jql_search, { max_results: 1000 }).uniq
+        issues = @jira_client.Issue.jql(jql_search, { max_results: 1000 }).uniq
+        convert(issues)
       end
 
       # @param [String] component
       # @param [String] status
       # @param [String[]] ticket_types
-      # @return [Array<JIRA::Resource::Issue>]
-      def search_unblocked_issues(component, status, ticket_types = [])
+      # @param [Apadmi::Grout::JiraFindTicketsOptions] options
+      # @return [Array<Apadmi::Grout::Issue>]
+      def search_unblocked_issues(component, status, ticket_types = [], options = nil)
+        allow_no_sprint = options&.include_no_sprint_tickets || false
         component_filter = (" AND component = '#{component}' " unless component.empty?) || ""
         status_filter = (" AND status = '#{status}' " unless status.empty?) || ""
         type_filter = ("AND (#{ticket_types.map { |type| "type = #{type}" }.join("OR ")})" unless ticket_types.empty?) || ""
+        empty_sprint_condition = ("OR sprint is EMPTY" if allow_no_sprint) || ""
 
         jql_search = %{
           project = '#{@project}'
           #{status_filter} #{component_filter} #{type_filter}
-          AND sprint in openSprints() AND (labels not in(Blocked) or labels is EMPTY) AND Flagged is EMPTY
+          AND (sprint in openSprints() #{empty_sprint_condition}) AND (labels not in(Blocked) or labels is EMPTY)
+          AND Flagged is EMPTY
         }
 
-        @jira_client.Issue.jql(jql_search, { max_results: 1000 }).uniq
+        issues = @jira_client.Issue.jql(jql_search, { max_results: 1000 }).uniq
+        convert(issues)
+      end
+
+      # @param [Apadmi::Grout::Issue] issue
+      # @param [String] state_name
+      def transition_issue(issue, state_name)
+        transitions = @jira_client.Transition.all(issue: issue.raw_object)
+        transition = transitions.find { |elem| elem.name.downcase == state_name.downcase }
+
+        trans = issue.raw_object.transitions.build
+        trans.save!("transition" => { "id" => transition.id })
       end
 
       # @param [String] key
       # @param [String] comment
       def flag_ticket(key, comment)
         payload = "{\"flag\":true,\"issueKeys\":[\"#{key}\"],\"commentVisibility\":\"\",\"comment\":\"#{comment}\"}"
-        do_post("#{@options[:site]}/rest/greenhopper/1.0/xboard/issue/flag/flag.json", payload)
+        @network_service.do_post("/rest/greenhopper/1.0/xboard/issue/flag/flag.json", payload)
       end
 
       # @param [String] key
       def un_flag_ticket(key)
         payload = "{\"flag\":false,\"issueKeys\":[\"#{key}\"],\"commentVisibility\":\"\",\"comment\":\"Unflagged by CI\"}"
-        do_post("#{@options[:site]}/rest/greenhopper/1.0/xboard/issue/flag/flag.json", payload)
+        @network_service.do_post("/rest/greenhopper/1.0/xboard/issue/flag/flag.json", payload)
       end
 
       # @param [String] key
@@ -86,7 +93,7 @@ module Apadmi
       # @param [String] comment
       def add_comment(key, comment)
         payload = "{\"issueKeys\":[\"#{key}\"],\"commentVisibility\":\"\",\"comment\":\"#{comment}\"}"
-        do_post("#{@options[:site]}/rest/greenhopper/1.0/xboard/issue/flag/flag.json", payload)
+        @network_service.do_post("/rest/greenhopper/1.0/xboard/issue/flag/flag.json", payload)
       end
 
       # @param [String] key
@@ -101,14 +108,14 @@ module Apadmi
       # @param [String] key
       # @param [String] comment_id
       def remove_comment(key, comment_id)
-        do_delete("#{@options[:site]}/rest/api/2/issue/#{key}/comment/#{comment_id}")
+        @network_service.do_delete("/rest/api/2/issue/#{key}/comment/#{comment_id}")
       end
 
       # @param [String] component_key
-      # @return [Array<JIRA::Resource::Issue>]
+      # @return [Array<Apadmi::Grout::Issue>]
       def get_tickets_by_component(component_key)
         jql_search = "project = '#{@project}' AND component IN ('#{component_key}')"
-        @jira_client.Issue.jql(jql_search, { max_results: 1000 }).uniq
+        convert(@jira_client.Issue.jql(jql_search, { max_results: 1000 }).uniq)
       end
 
       # @param [String] key
@@ -117,33 +124,18 @@ module Apadmi
         @jira_client.Transition.all(issue: issue)
       end
 
-      # @param [String] ticket
-      # @param [String] state_name
-      def transition_ticket(ticket, state_name)
-        issue = @jira_client.Issue.find(ticket)
-        transition_issue(issue, state_name)
-      end
-
-      # @param [JIRA::Resource::Issue] issue
-      # @param [String] state_name
-      def transition_issue(issue, state_name)
-        transitions = @jira_client.Transition.all(issue: issue)
-        transition = transitions.find { |elem| elem.name == state_name }
-
-        trans = issue.transitions.build
-        trans.save!("transition" => { "id" => transition.id })
-      end
-
       # @param [String] key
+      # @return [String]
       def get_ticket_status(key)
         issue = @jira_client.Issue.find(key)
-        issue.status
+        issue.status.name
       end
 
-      # @param [JIRA::Resource::Issue] issue
+      # @param [Apadmi::Grout::Issue] issue
       # @return [Array<PullRequest>]
       def get_ticket_prs(issue)
-        response = do_get("#{@options[:site]}/rest/dev-status/latest/issue/details?issueId=#{issue.id}&applicationType=bitbucket&dataType=pullrequest")
+        query_string = "issueId=#{issue.raw_object.id}&applicationType=bitbucket&dataType=pullrequest"
+        response = @network_service.do_get("/rest/dev-status/latest/issue/details?#{query_string}")
 
         return [] if JSON.parse(response.body)["detail"].empty?
 
@@ -154,11 +146,11 @@ module Apadmi
 
       # @param [String] keys
       # @param [String] component
-      # @return [Array<JIRA::Resource::Issue>]
+      # @return [Array<Apadmi::Grout::Issue>]
       def get_ticket_subtask(keys, component = nil)
         jql_search = "project = '#{@project}' AND parent IN #{keys.to_s.gsub("[", "(").gsub("]", ")")}"\
                       + (component.nil? ? "" : " AND component IN ('#{component}')")
-        @jira_client.Issue.jql(jql_search, { max_results: 1000 }).uniq
+        convert(@jira_client.Issue.jql(jql_search, { max_results: 1000 }).uniq)
       end
 
       # @param [String] release_date
@@ -179,7 +171,7 @@ module Apadmi
       def delete_version(version_id, move_version_id)
         payload = "{\"moveFixIssuesTo\": #{move_version_id}, \"moveAffectedIssuesTo\": #{move_version_id}, "\
                   "\"customFieldReplacementList\": []}"
-        do_post("#{@options[:site]}/rest/api/2/version/#{version_id}/removeAndSwap", payload)
+        @network_service.do_post("/rest/api/2/version/#{version_id}/removeAndSwap", payload)
       end
 
       # @return [Array<JIRA::Resource::Version>]
@@ -187,75 +179,44 @@ module Apadmi
         @jira_client.Project.find(@project).versions
       end
 
-      # @param [String] ticket
-      # @param [Array<JIRA::Resource::Version>] versions
-      def assign_fixversions(ticket, versions)
+      # @param [String] key
+      # @param [Array<String>] version_strings
+      def assign_fixversions(key, version_strings)
+        versions = create_or_get_versions(version_strings)
         fixversions = versions.map { |v| "{\"id\": \"#{v.id}\"}" }.join(", ")
         payload = "{\"fields\" : {\"fixVersions\": [#{fixversions}] }}"
-        do_put("#{@options[:site]}/rest/api/2/issue/#{ticket}", payload)
-      end
-
-      # @param [String] ticket
-      # @return [Array<Version>]
-      def get_ticket_fixversions(ticket)
-        response = do_get("#{@options[:site]}/rest/api/2/issue/#{ticket}")
-        JSON.parse(response.body)["fields"]["fixVersions"].map do |version|
-          Version.new(version)
-        end
-      end
-
-      # @param [Faraday::Response] response
-      def throw_if_error(response)
-        raise "Network call failed #{response.status} #{response.body}" unless (200..210).include?(response.status)
+        @network_service.do_put("/rest/api/2/issue/#{key}", payload)
       end
 
-      # @param [String] uri
-      # @return [Faraday::Response]
-      def do_get(uri)
-        conn = setup_con
-        response = conn.get(uri, CONTENT_TYPE => APPLICATION_JSON)
-        throw_if_error(response)
-        response
-      end
-
-      # @param [String] uri
-      # @param [String] payload
-      # @return [Faraday::Response]
-      def do_put(uri, payload)
-        conn = setup_con
-        response = conn.put(uri, payload, CONTENT_TYPE => APPLICATION_JSON)
-        throw_if_error(response)
-        response
+      # @param [String] key
+      # @return [Array<String>]
+      def get_ticket_fixversions(key)
+        response = @network_service.do_get("/rest/api/2/issue/#{key}")
+        JSON.parse(response.body)["fields"]["fixVersions"].map { |v| v["name"] } || []
       end
 
-      # @param [String] uri
-      # @param [String] payload
-      # @return [Faraday::Response]
-      def do_post(uri, payload)
-        conn = setup_con
-        response = conn.post(uri, payload, CONTENT_TYPE => APPLICATION_JSON)
-        throw_if_error(response)
-        response
-      end
+      private
 
-      # @param [String] uri
-      # @return [Faraday::Response]
-      def do_delete(uri)
-        conn = setup_con
-        response = conn.delete(uri, CONTENT_TYPE => APPLICATION_JSON)
-        throw_if_error(response)
-        response
+      # @param [Array<String>] version_strings
+      # @return [Array<JIRA::Resource::Version>]
+      def create_or_get_versions(version_strings)
+        all = all_versions
+        version_strings.map do |version|
+          existing_version = all.find { |v| v.name == version }
+          if !existing_version.nil?
+            existing_version
+          else
+            date = Time.now.strftime("%Y-%m-%d")
+            create_version(date, version)
+          end
+        end
       end
 
-      # @return [Faraday::Connection]
-      def setup_con
-        auth_str = "#{@options[:username]}:#{@options[:password]}"
-        conn = Faraday.new # create a new Connection with base URL
-        conn.headers["Authorization"] = "Basic #{Base64.strict_encode64(auth_str)}"
-        conn
+      # @param [Array<JIRA::Resource::Issue>]
+      # @return [Array<Apadmi::Grout::Issue>]
+      def convert(issues)
+        Apadmi::Grout::Issue.from_jira_issues(issues, @options[:site])
       end
-
-      private :setup_con, :do_delete, :do_get, :do_post, :do_put
     end
   end
 end