lex-aha 0.1.0

data/lib/legion/extensions/aha/ideas/runners/idea_portals.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/aha/helpers/client'
+
+module Legion
+  module Extensions
+    module Aha
+      module Ideas
+        module Runners
+          module IdeaPortals
+            extend Legion::Extensions::Aha::Helpers::Client
+
+            def list_idea_portals(**)
+              response = client(**).get('/idea_portals')
+              { result: response.body, status: response.status }
+            end
+
+            def list_idea_portals_in_product(product_id:, **)
+              response = client(**).get("/products/#{product_id}/idea_portals")
+              { result: response.body, status: response.status }
+            end
+
+            include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) &&
+                                                        Legion::Extensions::Helpers.const_defined?(:Lex)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/aha/ideas/runners/idea_subscriptions.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/aha/helpers/client'
+
+module Legion
+  module Extensions
+    module Aha
+      module Ideas
+        module Runners
+          module IdeaSubscriptions
+            extend Legion::Extensions::Aha::Helpers::Client
+
+            def list_subscriptions(idea_id:, **)
+              response = client(**).get("/ideas/#{idea_id}/subscriptions")
+              { result: response.body, status: response.status }
+            end
+
+            def get_subscription(idea_id:, id:, **)
+              response = client(**).get("/ideas/#{idea_id}/subscriptions/#{id}")
+              { result: response.body, status: response.status }
+            end
+
+            def create_subscription(idea_id:, subscription:, **)
+              response = client(**).post("/ideas/#{idea_id}/subscriptions", { subscription: subscription })
+              { result: response.body, status: response.status }
+            end
+
+            def delete_subscription(idea_id:, id:, **)
+              response = client(**).delete("/ideas/#{idea_id}/subscriptions/#{id}")
+              { result: response.body, status: response.status }
+            end
+
+            include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) &&
+                                                        Legion::Extensions::Helpers.const_defined?(:Lex)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/aha/ideas/runners/idea_users.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/aha/helpers/client'
+
+module Legion
+  module Extensions
+    module Aha
+      module Ideas
+        module Runners
+          module IdeaUsers
+            extend Legion::Extensions::Aha::Helpers::Client
+
+            def list_idea_users(**)
+              response = client(**).get('/idea_users')
+              { result: response.body, status: response.status }
+            end
+
+            def get_idea_user(id:, **)
+              response = client(**).get("/idea_users/#{id}")
+              { result: response.body, status: response.status }
+            end
+
+            def create_idea_user(idea_user:, **)
+              response = client(**).post('/idea_users', { idea_user: idea_user })
+              { result: response.body, status: response.status }
+            end
+
+            def update_idea_user(id:, idea_user:, **)
+              response = client(**).put("/idea_users/#{id}", { idea_user: idea_user })
+              { result: response.body, status: response.status }
+            end
+
+            def delete_idea_user(id:, **)
+              response = client(**).delete("/idea_users/#{id}")
+              { result: response.body, status: response.status }
+            end
+
+            include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) &&
+                                                        Legion::Extensions::Helpers.const_defined?(:Lex)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/aha/ideas/runners/idea_votes.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/aha/helpers/client'
+
+module Legion
+  module Extensions
+    module Aha
+      module Ideas
+        module Runners
+          module IdeaVotes
+            extend Legion::Extensions::Aha::Helpers::Client
+
+            def list_votes(idea_id:, **)
+              response = client(**).get("/ideas/#{idea_id}/endorsements")
+              { result: response.body, status: response.status }
+            end
+
+            def list_account_votes(**)
+              response = client(**).get('/ideas/endorsements')
+              { result: response.body, status: response.status }
+            end
+
+            def get_vote(idea_id:, id:, **)
+              response = client(**).get("/ideas/#{idea_id}/endorsements/#{id}")
+              { result: response.body, status: response.status }
+            end
+
+            def create_vote(idea_id:, endorsement:, **)
+              response = client(**).post("/ideas/#{idea_id}/endorsements", { endorsement: endorsement })
+              { result: response.body, status: response.status }
+            end
+
+            def update_vote(idea_id:, id:, endorsement:, **)
+              response = client(**).put("/ideas/#{idea_id}/endorsements/#{id}", { endorsement: endorsement })
+              { result: response.body, status: response.status }
+            end
+
+            def delete_vote(idea_id:, id:, **)
+              response = client(**).delete("/ideas/#{idea_id}/endorsements/#{id}")
+              { result: response.body, status: response.status }
+            end
+
+            include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) &&
+                                                        Legion::Extensions::Helpers.const_defined?(:Lex)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/aha/ideas/runners/ideas.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/aha/helpers/client'
+
+module Legion
+  module Extensions
+    module Aha
+      module Ideas
+        module Runners
+          module Ideas
+            extend Legion::Extensions::Aha::Helpers::Client
+
+            def list_ideas(**)
+              response = client(**).get('/ideas')
+              { result: response.body, status: response.status }
+            end
+
+            def list_ideas_in_product(product_id:, **)
+              response = client(**).get("/products/#{product_id}/ideas")
+              { result: response.body, status: response.status }
+            end
+
+            def get_idea(id:, **)
+              response = client(**).get("/ideas/#{id}")
+              { result: response.body, status: response.status }
+            end
+
+            def create_idea(product_id:, idea:, **)
+              response = client(**).post("/products/#{product_id}/ideas", { idea: idea })
+              { result: response.body, status: response.status }
+            end
+
+            def delete_idea(id:, **)
+              response = client(**).delete("/ideas/#{id}")
+              { result: response.body, status: response.status }
+            end
+
+            def promote_idea(id:, **)
+              response = client(**).put("/ideas/#{id}/promote")
+              { result: response.body, status: response.status }
+            end
+
+            def list_related_ideas(term:, **)
+              response = client(**).get("/ideas/related?term=#{term}")
+              { result: response.body, status: response.status }
+            end
+
+            include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) &&
+                                                        Legion::Extensions::Helpers.const_defined?(:Lex)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/aha/ideas.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/aha/ideas/runners/ideas'
+require 'legion/extensions/aha/ideas/runners/idea_comments'
+require 'legion/extensions/aha/ideas/runners/idea_portals'
+require 'legion/extensions/aha/ideas/runners/idea_organizations'
+require 'legion/extensions/aha/ideas/runners/idea_users'
+require 'legion/extensions/aha/ideas/runners/idea_votes'
+require 'legion/extensions/aha/ideas/runners/idea_subscriptions'
+require 'legion/extensions/aha/ideas/runners/idea_categories'
+require_relative 'ideas/client'
+
+module Legion
+  module Extensions
+    module Aha
+      module Ideas
+      end
+    end
+  end
+end

data/lib/legion/extensions/aha/knowledge/client.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require_relative '../base_client'
+require_relative 'runners/knowledge_bases'
+require_relative 'runners/pages'
+require_relative 'runners/notes'
+
+module Legion
+  module Extensions
+    module Aha
+      module Knowledge
+        class Client < Legion::Extensions::Aha::BaseClient
+          include Runners::KnowledgeBases
+          include Runners::Pages
+          include Runners::Notes
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/aha/knowledge/runners/knowledge_bases.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/aha/helpers/client'
+
+module Legion
+  module Extensions
+    module Aha
+      module Knowledge
+        module Runners
+          module KnowledgeBases
+            extend Legion::Extensions::Aha::Helpers::Client
+
+            def list_knowledge_bases(product_id:, **)
+              response = client(**).get("/products/#{product_id}/knowledge_bases")
+              { result: response.body, status: response.status }
+            end
+
+            def get_knowledge_base(id:, **)
+              response = client(**).get("/knowledge_bases/#{id}")
+              { result: response.body, status: response.status }
+            end
+
+            include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) && Legion::Extensions::Helpers.const_defined?(:Lex)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/aha/knowledge/runners/notes.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/aha/helpers/client'
+
+module Legion
+  module Extensions
+    module Aha
+      module Knowledge
+        module Runners
+          module Notes
+            extend Legion::Extensions::Aha::Helpers::Client
+
+            def list_notes(product_id:, **)
+              response = client(**).get("/products/#{product_id}/pages")
+              { result: response.body, status: response.status }
+            end
+
+            def get_note(id:, **)
+              response = client(**).get("/pages/#{id}")
+              { result: response.body, status: response.status }
+            end
+
+            def create_note(product_id:, page:, **)
+              response = client(**).post("/products/#{product_id}/pages", { page: page })
+              { result: response.body, status: response.status }
+            end
+
+            def update_note(id:, page:, **)
+              response = client(**).put("/pages/#{id}", { page: page })
+              { result: response.body, status: response.status }
+            end
+
+            def delete_note(id:, **)
+              response = client(**).delete("/pages/#{id}")
+              { result: response.body, status: response.status }
+            end
+
+            include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) && Legion::Extensions::Helpers.const_defined?(:Lex)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/aha/knowledge/runners/pages.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/aha/helpers/client'
+
+module Legion
+  module Extensions
+    module Aha
+      module Knowledge
+        module Runners
+          module Pages
+            extend Legion::Extensions::Aha::Helpers::Client
+
+            def list_pages(knowledge_base_id:, **)
+              response = client(**).get("/knowledge_bases/#{knowledge_base_id}/pages")
+              { result: response.body, status: response.status }
+            end
+
+            def get_page(id:, **)
+              response = client(**).get("/pages/#{id}")
+              { result: response.body, status: response.status }
+            end
+
+            def create_page(knowledge_base_id:, page:, **)
+              response = client(**).post("/knowledge_bases/#{knowledge_base_id}/pages", { page: page })
+              { result: response.body, status: response.status }
+            end
+
+            def update_page(id:, page:, **)
+              response = client(**).put("/pages/#{id}", { page: page })
+              { result: response.body, status: response.status }
+            end
+
+            def delete_page(id:, **)
+              response = client(**).delete("/pages/#{id}")
+              { result: response.body, status: response.status }
+            end
+
+            include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) && Legion::Extensions::Helpers.const_defined?(:Lex)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/aha/knowledge.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/aha/knowledge/runners/knowledge_bases'
+require 'legion/extensions/aha/knowledge/runners/pages'
+require 'legion/extensions/aha/knowledge/runners/notes'
+require_relative 'knowledge/client'
+
+module Legion
+  module Extensions
+    module Aha
+      module Knowledge
+      end
+    end
+  end
+end

data/lib/legion/extensions/aha/roadmaps/client.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require_relative '../base_client'
+require_relative 'runners/products'
+require_relative 'runners/releases'
+require_relative 'runners/release_phases'
+require_relative 'runners/roll_up_releases'
+require_relative 'runners/features'
+require_relative 'runners/epics'
+require_relative 'runners/requirements'
+require_relative 'runners/initiatives'
+require_relative 'runners/goals'
+require_relative 'runners/key_results'
+require_relative 'runners/strategy'
+require_relative 'runners/competitors'
+require_relative 'runners/personas'
+require_relative 'runners/capacity'
+
+module Legion
+  module Extensions
+    module Aha
+      module Roadmaps
+        class Client < Legion::Extensions::Aha::BaseClient
+          include Runners::Products
+          include Runners::Releases
+          include Runners::ReleasePhases
+          include Runners::RollUpReleases
+          include Runners::Features
+          include Runners::Epics
+          include Runners::Requirements
+          include Runners::Initiatives
+          include Runners::Goals
+          include Runners::KeyResults
+          include Runners::Strategy
+          include Runners::Competitors
+          include Runners::Personas
+          include Runners::Capacity
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/aha/roadmaps/runners/capacity.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/aha/helpers/client'
+
+module Legion
+  module Extensions
+    module Aha
+      module Roadmaps
+        module Runners
+          module Capacity
+            extend Legion::Extensions::Aha::Helpers::Client
+
+            def list_capacity_scenarios(**)
+              response = client(**).get('/capacity_scenarios')
+              { result: response.body, status: response.status }
+            end
+
+            def get_capacity_scenario(id:, **)
+              response = client(**).get("/capacity_scenarios/#{id}")
+              { result: response.body, status: response.status }
+            end
+
+            def list_capacity_investments(product_id:, **)
+              response = client(**).get("/products/#{product_id}/capacity_investments")
+              { result: response.body, status: response.status }
+            end
+
+            def get_capacity_investment(id:, **)
+              response = client(**).get("/capacity_investments/#{id}")
+              { result: response.body, status: response.status }
+            end
+
+            def create_capacity_investment_on_feature(feature_id:, capacity_investment:, **)
+              response = client(**).post("/features/#{feature_id}/capacity_investments", { capacity_investment: capacity_investment })
+              { result: response.body, status: response.status }
+            end
+
+            def list_estimate_values(capacity_investment_id:, **)
+              response = client(**).get("/capacity_investments/#{capacity_investment_id}/estimate_values")
+              { result: response.body, status: response.status }
+            end
+
+            def create_estimate_values(capacity_investment_id:, estimate_values:, **)
+              response = client(**).post("/capacity_investments/#{capacity_investment_id}/estimate_values", { estimate_values: estimate_values })
+              { result: response.body, status: response.status }
+            end
+
+            include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) && Legion::Extensions::Helpers.const_defined?(:Lex)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/aha/roadmaps/runners/competitors.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/aha/helpers/client'
+
+module Legion
+  module Extensions
+    module Aha
+      module Roadmaps
+        module Runners
+          module Competitors
+            extend Legion::Extensions::Aha::Helpers::Client
+
+            def list_competitors(product_id:, **)
+              response = client(**).get("/products/#{product_id}/competitors")
+              { result: response.body, status: response.status }
+            end
+
+            def get_competitor(id:, **)
+              response = client(**).get("/competitors/#{id}")
+              { result: response.body, status: response.status }
+            end
+
+            def create_competitor(product_id:, competitor:, **)
+              response = client(**).post("/products/#{product_id}/competitors", { competitor: competitor })
+              { result: response.body, status: response.status }
+            end
+
+            def update_competitor(product_id:, id:, competitor:, **)
+              response = client(**).put("/products/#{product_id}/competitors/#{id}", { competitor: competitor })
+              { result: response.body, status: response.status }
+            end
+
+            def delete_competitor(product_id:, id:, **)
+              response = client(**).delete("/products/#{product_id}/competitors/#{id}")
+              { result: response.body, status: response.status }
+            end
+
+            include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) && Legion::Extensions::Helpers.const_defined?(:Lex)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/aha/roadmaps/runners/epics.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/aha/helpers/client'
+
+module Legion
+  module Extensions
+    module Aha
+      module Roadmaps
+        module Runners
+          module Epics
+            extend Legion::Extensions::Aha::Helpers::Client
+
+            def list_epics(**)
+              response = client(**).get('/epics')
+              { result: response.body, status: response.status }
+            end
+
+            def list_epics_in_release(release_id:, **)
+              response = client(**).get("/releases/#{release_id}/epics")
+              { result: response.body, status: response.status }
+            end
+
+            def list_epics_in_product(product_id:, **)
+              response = client(**).get("/products/#{product_id}/epics")
+              { result: response.body, status: response.status }
+            end
+
+            def get_epic(id:, **)
+              response = client(**).get("/epics/#{id}")
+              { result: response.body, status: response.status }
+            end
+
+            def create_epic(release_id:, epic:, **)
+              response = client(**).post("/releases/#{release_id}/epics", { epic: epic })
+              { result: response.body, status: response.status }
+            end
+
+            def create_epic_in_product(product_id:, epic:, **)
+              response = client(**).post("/products/#{product_id}/epics", { epic: epic })
+              { result: response.body, status: response.status }
+            end
+
+            def update_epic(id:, epic:, **)
+              response = client(**).put("/epics/#{id}", { epic: epic })
+              { result: response.body, status: response.status }
+            end
+
+            def delete_epic(id:, **)
+              response = client(**).delete("/epics/#{id}")
+              { result: response.body, status: response.status }
+            end
+
+            include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) && Legion::Extensions::Helpers.const_defined?(:Lex)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/aha/roadmaps/runners/features.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/aha/helpers/client'
+
+module Legion
+  module Extensions
+    module Aha
+      module Roadmaps
+        module Runners
+          module Features
+            extend Legion::Extensions::Aha::Helpers::Client
+
+            def list_features(**)
+              response = client(**).get('/features')
+              { result: response.body, status: response.status }
+            end
+
+            def list_features_in_release(release_id:, **)
+              response = client(**).get("/releases/#{release_id}/features")
+              { result: response.body, status: response.status }
+            end
+
+            def list_features_in_product(product_id:, **)
+              response = client(**).get("/products/#{product_id}/features")
+              { result: response.body, status: response.status }
+            end
+
+            def list_features_in_epic(epic_id:, **)
+              response = client(**).get("/epics/#{epic_id}/features")
+              { result: response.body, status: response.status }
+            end
+
+            def get_feature(id:, **)
+              response = client(**).get("/features/#{id}")
+              { result: response.body, status: response.status }
+            end
+
+            def create_feature(release_id:, feature:, **)
+              response = client(**).post("/releases/#{release_id}/features", { feature: feature })
+              { result: response.body, status: response.status }
+            end
+
+            def delete_feature(id:, **)
+              response = client(**).delete("/features/#{id}")
+              { result: response.body, status: response.status }
+            end
+
+            def convert_to_epic(id:, **)
+              response = client(**).post("/features/#{id}/convert_to_epic")
+              { result: response.body, status: response.status }
+            end
+
+            include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) && Legion::Extensions::Helpers.const_defined?(:Lex)
+          end
+        end
+      end
+    end
+  end
+end