bas 1.2.1 → 1.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3574c150bdecb2fd88551db1b4add9bd5d0458d6b44eec87bd2c3efd44ff8a83
-  data.tar.gz: ffeac8bae610aec6449161f9c267385e84921141d953f98175a05c6186f2e641
+  metadata.gz: 4ab201fef0200fb13b92ff49a3925c0fc2a10efd26a473d987cc9eef4ddbeae6
+  data.tar.gz: 93724237d9d6865c369e46f528a2a92dc63b7dd4239d5b0d37725cdb57d96ff9
 SHA512:
-  metadata.gz: 8588edfeb8aec0ec204a040e79bd801d1563bf45b94b7ccd50c89ed160a2a2334f4285cd54d5c001228a9de5d14d02a64800c36b10b54f31d01ed1c877c0ae34
-  data.tar.gz: 921b8280f7c071a8aaa7752b99b0fffabb0e1e434f6b051433a44d49f2c137e5092889250f7301e41b678ca763e9f445237a4252bb22a0731920f4731536006e
+  metadata.gz: a958b5d144da8fa1e162d5d44a18dd30472d2cd7bbd9c6d3fe6991d860a2b5199b9c68aff3b190fbdc48cc275b686c6707b304b39552a6776945e391b4bcb5b1
+  data.tar.gz: 30d014adce784050342b51663a583ee7474e2f00b28ef60210254c5f3fdf43d614607bff763325d93016d5b6bd320a5cdb9363a86b03082d37e28d896248979a

data/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+# 1.4.0 (26.07.2024)
+- [Add bots to synchronize issues with notion work items](https://github.com/kommitters/bas/issues/87)
+- [Update fetch pto from notion bot](https://github.com/kommitters/bas/issues/75)
+
+# 1.3.0 (18.07.2024)
+- [Add bots to check webs availability](https://github.com/kommitters/bas/issues/83)
+
 # 1.2.1 (16.07.2024)
 - [Update format message for the digital ocean alert bots use case](https://github.com/kommitters/bas/pull/84)
 

data/lib/bas/bot/create_work_item.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+require "json"
+
+require_relative "./base"
+require_relative "../read/postgres"
+require_relative "../utils/notion/request"
+require_relative "../utils/notion/types"
+require_relative "../write/postgres"
+
+module Bot
+  ##
+  # The Bot::CreateWorkItem class serves as a bot implementation to create "work items" on a
+  # notion database using information of a GitHub issue.
+  #
+  # <br>
+  # <b>Example</b>
+  #
+  #   options = {
+  #     read_options: {
+  #       connection: {
+  #         host: "localhost",
+  #         port: 5432,
+  #         dbname: "bas",
+  #         user: "postgres",
+  #         password: "postgres"
+  #       },
+  #       db_table: "github_issues",
+  #       tag: "CreateWorkItemRequest"
+  #     },
+  #     process_options: {
+  #       database_id: "notion database id",
+  #       secret: "notion secret",
+  #       domain: "domain association",
+  #       status: "default status",
+  #       work_item_type: "work_item_type",
+  #       project: "project id"
+  #     },
+  #     write_options: {
+  #       connection: {
+  #         host: "localhost",
+  #         port: 5432,
+  #         dbname: "bas",
+  #         user: "postgres",
+  #         password: "postgres"
+  #       },
+  #       db_table: "github_issues",
+  #       tag: "CreateWorkItem"
+  #     }
+  #   }
+  #
+  #   bot = Bot::VerifyIssueExistanceInNotion.new(options)
+  #   bot.execute
+  #
+  class CreateWorkItem < Bot::Base
+    include Utils::Notion::Types
+
+    UPDATE_REQUEST = "UpdateWorkItemRequest"
+
+    # read function to execute the PostgresDB Read component
+    #
+    def read
+      reader = Read::Postgres.new(read_options.merge(conditions))
+
+      reader.execute
+    end
+
+    # process function to execute the Notion utility to create work items on a notion
+    # database
+    #
+    def process
+      return { success: { created: nil } } if unprocessable_response
+
+      response = Utils::Notion::Request.execute(params)
+
+      if response.code == 200
+        { success: { issue: read_response.data["issue"], notion_wi: response["id"] } }
+      else
+        { error: { message: response.parsed_response, status_code: response.code } }
+      end
+    end
+
+    # write function to execute the PostgresDB write component
+    #
+    def write
+      options = write_options.merge({ tag: })
+
+      write = Write::Postgres.new(options, process_response)
+
+      write.execute
+    end
+
+    private
+
+    def conditions
+      {
+        where: "archived=$1 AND tag=$2 AND stage=$3 ORDER BY inserted_at ASC",
+        params: [false, read_options[:tag], "unprocessed"]
+      }
+    end
+
+    def params
+      {
+        endpoint: "pages",
+        secret: process_options[:secret],
+        method: "post",
+        body:
+      }
+    end
+
+    def body
+      {
+        parent: { database_id: process_options[:database_id] },
+        properties:
+      }
+    end
+
+    def properties # rubocop:disable Metrics/AbcSize
+      {
+        "Responsible domain": select(process_options[:domain]),
+        "Github Issue id": rich_text(read_response.data["issue"]["id"].to_s),
+        "Status": status(process_options[:status]),
+        "Detail": title(read_response.data["issue"]["title"])
+      }.merge(work_item_type)
+    end
+
+    def work_item_type
+      case process_options[:work_item_type]
+      when "activity" then { "Activity": relation(process_options[:activity]) }
+      when "project" then { "Project": relation(process_options[:project]) }
+      else {}
+      end
+    end
+
+    def tag
+      return write_options[:tag] if process_response[:success].nil? || process_response[:success][:notion_wi].nil?
+
+      UPDATE_REQUEST
+    end
+  end
+end

data/lib/bas/bot/fetch_domain_services_from_notion.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require_relative "./base"
+require_relative "../read/default"
+require_relative "../utils/notion/request"
+require_relative "../write/postgres"
+
+module Bot
+  ##
+  # The Bot::FetchDomainServicesFromNotion class serves as a bot implementation to read
+  # web domains from a notion database and write them on a PostgresDB table with a specific format.
+  #
+  # <br>
+  # <b>Example</b>
+  #
+  #   options = {
+  #     process_options: {
+  #       database_id: "notion database id",
+  #       secret: "notion secret"
+  #     },
+  #     write_options: {
+  #       connection: {
+  #         host: "localhost",
+  #         port: 5432,
+  #         dbname: "bas",
+  #         user: "postgres",
+  #         password: "postgres"
+  #       },
+  #       db_table: "web_availability",
+  #       tag: "FetchDomainServicesFromNotion"
+  #     }
+  #   }
+  #
+  #   bot = Bot::FetchDomainServicesFromNotion.new(options)
+  #   bot.execute
+  #
+  class FetchDomainServicesFromNotion < Bot::Base
+    def read
+      reader = Read::Default.new
+
+      reader.execute
+    end
+
+    # Process function to execute the Notion utility to fetch web domains from a notion database
+    #
+    def process
+      response = Utils::Notion::Request.execute(params)
+
+      if response.code == 200
+        urls_list = normalize_response(response.parsed_response["results"])
+
+        { success: { urls: urls_list } }
+      else
+        { error: { message: response.parsed_response, status_code: response.code } }
+      end
+    end
+
+    # Write function to execute the PostgresDB write component
+    #
+    def write
+      write = Write::Postgres.new(write_options, process_response)
+
+      write.execute
+    end
+
+    private
+
+    def params
+      {
+        endpoint: "databases/#{process_options[:database_id]}/query",
+        secret: process_options[:secret],
+        method: "post",
+        body: {}
+      }
+    end
+
+    def normalize_response(results)
+      return [] if results.nil?
+
+      results.map do |value|
+        properties = value["properties"]
+
+        {
+          "url" => extract_rich_text_field_value(properties["domain"])
+        }
+      end
+    end
+
+    def extract_rich_text_field_value(data)
+      data["rich_text"][0]["plain_text"]
+    end
+  end
+end

data/lib/bas/bot/fetch_github_issues.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+require_relative "./base"
+require_relative "../read/default"
+require_relative "../utils/github/octokit_client"
+require_relative "../write/postgres"
+
+module Bot
+  ##
+  # The Bot::FetchGithubIssues class serves as a bot implementation to fetch GitHub issues from a
+  # repository and write them on a PostgresDB table with a specific format.
+  #
+  # <br>
+  # <b>Example</b>
+  #
+  #   options = {
+  #     read_options: {
+  #       connection: {
+  #         host: "localhost",
+  #         port: 5432,
+  #         dbname: "bas",
+  #         user: "postgres",
+  #         password: "postgres"
+  #       },
+  #       db_table: "github_issues",
+  #       tag: "FetchGithubIssues",
+  #       avoid_process: true
+  #     },
+  #     process_options: {
+  #       private_pem: "Github App private token",
+  #       app_id: "Github App id",
+  #       repo: "repository name",
+  #       filters: "hash with filters",
+  #       organization: "GitHub organization name"
+  #     },
+  #     write_options: {
+  #       connection: {
+  #         host: "localhost",
+  #         port: 5432,
+  #         dbname: "bas",
+  #         user: "postgres",
+  #         password: "postgres"
+  #       },
+  #       db_table: "github_issues",
+  #       tag: "FetchGithubIssues"
+  #     }
+  #   }
+  #
+  #   bot = Bot::FetchGithubIssues.new(options)
+  #   bot.execute
+  #
+  class FetchGithubIssues < Bot::Base
+    ISSUE_PARAMS = %i[id html_url title body labels state created_at updated_at].freeze
+    PER_PAGE = 100
+
+    # read function to execute the PostgresDB Read component
+    #
+    def read
+      reader = Read::Postgres.new(read_options.merge(conditions))
+
+      reader.execute
+    end
+
+    # Process function to request GitHub issues using the octokit utility
+    #
+    def process
+      octokit = Utils::Github::OctokitClient.new(params).execute
+
+      if octokit[:client]
+        repo_issues = octokit[:client].issues(@process_options[:repo], filters)
+
+        issues = normalize_response(repo_issues)
+
+        { success: { issues: } }
+      else
+        { error: octokit[:error] }
+      end
+    end
+
+    # Write function to execute the PostgresDB write component
+    #
+    def write
+      write = Write::Postgres.new(write_options, process_response)
+
+      write.execute
+    end
+
+    private
+
+    def conditions
+      {
+        where: "tag=$1 ORDER BY inserted_at DESC",
+        params: [read_options[:tag]]
+      }
+    end
+
+    def params
+      {
+        private_pem: process_options[:private_pem],
+        app_id: process_options[:app_id],
+        method: process_options[:method],
+        method_params: process_options[:method_params],
+        organization: process_options[:organization]
+      }
+    end
+
+    def filters
+      default_filter = { per_page: PER_PAGE }
+
+      filters = @process_options[:filters]
+      filters = filters.merge({ since: read_response.inserted_at }) unless read_response.nil?
+
+      filters.is_a?(Hash) ? default_filter.merge(filters) : default_filter
+    end
+
+    def normalize_response(issues)
+      issues.map do |issue|
+        ISSUE_PARAMS.reduce({}) do |hash, param|
+          hash.merge({ param => issue.send(param) })
+              .merge({ assignees: issue.assignees.map(&:login) })
+        end
+      end
+    end
+  end
+end

data/lib/bas/bot/fetch_next_week_ptos_from_notion.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "date"
+
 require_relative "./base"
 require_relative "../read/default"
 require_relative "../utils/notion/request"
@@ -34,7 +36,7 @@ module Bot
   #   bot = Bot::FetchNextWeekPtosFromNotion.new(options)
   #   bot.execute
   #
-  class FetchNextWeekPtosFromNotion < Bot::Base
+  class FetchNextWeekPtosFromNotion < Bot::Base # rubocop:disable Metrics/ClassLength
     # Read function to execute the default Read component
     #
     def read
@@ -130,14 +132,47 @@ module Bot
       results.map do |pto|
         pto_fields = pto["properties"]
 
-        {
-          "Name" => extract_description_field_value(pto_fields["Description"]),
-          "StartDateTime" => extract_date_field_value(pto_fields["StartDateTime"]),
-          "EndDateTime" => extract_date_field_value(pto_fields["EndDateTime"])
-        }
+        name = extract_description_field_value(pto_fields["Description"])
+        start_date = extract_date_field_value(pto_fields["StartDateTime"])
+        end_date = extract_date_field_value(pto_fields["EndDateTime"])
+
+        description(name, start_date, end_date)
       end
     end
 
+    def description(name, start_date, end_date)
+      start = start_description(start_date)
+      finish = end_description(end_date)
+
+      "#{name} will not be working between #{start} and #{finish}. And returns the #{returns(finish)}"
+    end
+
+    def start_description(date)
+      date[:from]
+    end
+
+    def end_description(date)
+      return date[:from] if date[:to].nil?
+
+      date[:to]
+    end
+
+    def returns(date)
+      date.include?("T12") ? "#{date} in the afternoon" : next_work_day(date)
+    end
+
+    def next_work_day(date)
+      datetime = DateTime.parse(date)
+
+      return_day = case datetime.wday
+                   when 5 then datetime + 3
+                   when 6 then datetime + 2
+                   else datetime + 1
+                   end
+
+      return_day.strftime("%A %B %d of %Y").to_s
+    end
+
     def extract_description_field_value(data)
       names = data["title"].map { |name| name["plain_text"] }
 

data/lib/bas/bot/fetch_ptos_from_notion.rb

@@ -74,26 +74,13 @@ module Bot
         endpoint: "databases/#{process_options[:database_id]}/query",
         secret: process_options[:secret],
         method: "post",
-        body:
+        body: { filter: today_condition }
       }
     end
 
-    def body
-      { filter: { "or": conditions } }
-    end
-
-    def conditions
-      [
-        today_condition,
-        { property: "StartDateTime", date: { this_week: {} } },
-        { property: "EndDateTime", date: { this_week: {} } },
-        { property: "StartDateTime", date: { next_week: {} } },
-        { property: "EndDateTime", date: { next_week: {} } }
-      ]
-    end
-
     def today_condition
       today = Time.now.utc.strftime("%F").to_s
+
       {
         "and": [
           { property: "StartDateTime", date: { on_or_before: today } },
@@ -134,7 +121,7 @@ module Bot
     end
 
     def returns(date)
-      date.include?("T") ? "#{date} in the afternoon" : next_work_day(date)
+      date.include?("T12") ? "#{date} in the afternoon" : next_work_day(date)
     end
 
     def next_work_day(date)

data/lib/bas/bot/review_domain_availability.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+require "httparty"
+
+require_relative "./base"
+require_relative "../read/postgres"
+require_relative "../write/postgres"
+require_relative "../utils/openai/run_assistant"
+
+module Bot
+  ##
+  # The Bot::ReviewDomainAvailability class serves as a bot implementation to read from a postgres
+  # shared storage a domain requests and review its availability.
+  #
+  # <br>
+  # <b>Example</b>
+  #
+  #   options = {
+  #     read_options: {
+  #       connection: {
+  #         host: "localhost",
+  #         port: 5432,
+  #         dbname: "bas",
+  #         user: "postgres",
+  #         password: "postgres"
+  #       },
+  #       db_table: "web_availability",
+  #       tag: "ReviewDomainRequest"
+  #     },
+  #     write_options: {
+  #       connection: {
+  #         host: "localhost",
+  #         port: 5432,
+  #         dbname: "bas",
+  #         user: "postgres",
+  #         password: "postgres"
+  #       },
+  #       db_table: "web_availability",
+  #       tag: "ReviewDomainAvailability"
+  #     }
+  #   }
+  #
+  #   bot = Bot::ReviewDomainAvailability.new(options)
+  #   bot.execute
+  #
+  class ReviewDomainAvailability < Bot::Base
+    # read function to execute the PostgresDB Read component
+    #
+    def read
+      reader = Read::Postgres.new(read_options.merge(conditions))
+
+      reader.execute
+    end
+
+    # process function to make a http request to the domain and check the status
+    #
+    def process
+      return { success: { review: nil } } if unprocessable_response
+
+      response = availability
+
+      if response.code == 200
+        { success: { review: nil } }
+      else
+        { success: { notification: notification(response) } }
+      end
+    end
+
+    # write function to execute the PostgresDB write component
+    #
+    def write
+      write = Write::Postgres.new(write_options, process_response)
+
+      write.execute
+    end
+
+    private
+
+    def conditions
+      {
+        where: "archived=$1 AND tag=$2 AND stage=$3 ORDER BY inserted_at ASC",
+        params: [false, read_options[:tag], "unprocessed"]
+      }
+    end
+
+    def availability
+      url = read_response.data["url"]
+
+      HTTParty.get(url, {})
+    end
+
+    def notification(response)
+      data = {
+        domain: read_response.data["url"],
+        status_code: response.code
+      }
+
+      ":warning: Domain is down: #{data}"
+    end
+  end
+end

data/lib/bas/bot/update_work_item.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+require "json"
+require "md_to_notion"
+
+require_relative "./base"
+require_relative "../read/postgres"
+require_relative "../utils/notion/request"
+require_relative "../utils/notion/types"
+require_relative "../utils/notion/delete_page_blocks"
+require_relative "../write/postgres"
+
+module Bot
+  ##
+  # The Bot::UpdateWorkItem class serves as a bot implementation to update "work items" on a
+  # notion database using information of a GitHub issue.
+  #
+  # <br>
+  # <b>Example</b>
+  #
+  #   options = {
+  #     read_options: {
+  #       connection: {
+  #         host: "localhost",
+  #         port: 5432,
+  #         dbname: "bas",
+  #         user: "postgres",
+  #         password: "postgres"
+  #       },
+  #       db_table: "github_issues",
+  #       tag: "UpdateWorkItemRequest"
+  #     },
+  #     process_options: {
+  #       secret: "notion secret"
+  #     },
+  #     write_options: {
+  #       connection: {
+  #         host: "localhost",
+  #         port: 5432,
+  #         dbname: "bas",
+  #         user: "postgres",
+  #         password: "postgres"
+  #       },
+  #       db_table: "github_issues",
+  #       tag: "UpdateWorkItem"
+  #     }
+  #   }
+  #
+  #   bot = Bot::UpdateWorkItem.new(options)
+  #   bot.execute
+  #
+  class UpdateWorkItem < Bot::Base
+    include Utils::Notion::Types
+
+    DESCRIPTION = "Issue Description"
+
+    # read function to execute the PostgresDB Read component
+    #
+    def read
+      reader = Read::Postgres.new(read_options.merge(conditions))
+
+      reader.execute
+    end
+
+    # process function to execute the Notion utility to update work items on a notion
+    # database
+    def process
+      return { success: { updated: nil } } if unprocessable_response
+
+      delete_wi
+
+      response = Utils::Notion::Request.execute(params)
+
+      if response.code == 200
+        { success: { issue: read_response.data["issue"] } }
+      else
+        { error: { message: response.parsed_response, status_code: response.code } }
+      end
+    end
+
+    # write function to execute the PostgresDB write component
+    #
+    def write
+      write = Write::Postgres.new(write_options, process_response)
+
+      write.execute
+    end
+
+    private
+
+    def conditions
+      {
+        where: "archived=$1 AND tag=$2 AND stage=$3 ORDER BY inserted_at ASC",
+        params: [false, read_options[:tag], "unprocessed"]
+      }
+    end
+
+    def params
+      {
+        endpoint: "blocks/#{read_response.data["notion_wi"]}/children",
+        secret: process_options[:secret],
+        method: "patch",
+        body:
+      }
+    end
+
+    def body
+      { children: description + [issue_reference] }
+    end
+
+    def description
+      MdToNotion::Parser.markdown_to_notion_blocks(read_response.data["issue"]["body"])
+    end
+
+    def issue_reference
+      {
+        object: "block",
+        type: "paragraph",
+        paragraph: rich_text("issue", read_response.data["issue"]["html_url"])
+      }
+    end
+
+    def delete_wi
+      params = {
+        page_id: read_response.data["notion_wi"],
+        secret: process_options[:secret]
+      }
+
+      Utils::Notion::DeletePageBlocks.new(params).execute
+    end
+  end
+end

data/lib/bas/bot/verify_issue_existance_in_notion.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+require "json"
+
+require_relative "./base"
+require_relative "../read/postgres"
+require_relative "../utils/notion/request"
+require_relative "../utils/notion/update_db_state"
+require_relative "../write/postgres"
+
+module Bot
+  ##
+  # The Bot::VerifyIssueExistanceInNotion class serves as a bot implementation to verify if a
+  # GitHub issue was already created on a notion database base on a column with the issue id.
+  #
+  # <br>
+  # <b>Example</b>
+  #
+  #   options = {
+  #     read_options: {
+  #       connection: {
+  #         host: "localhost",
+  #         port: 5432,
+  #         dbname: "bas",
+  #         user: "postgres",
+  #         password: "postgres"
+  #       },
+  #       db_table: "github_issues",
+  #       tag: "GithubIssueRequest"
+  #     },
+  #     process_options: {
+  #       database_id: "notion database id",
+  #       secret: "notion secret"
+  #     },
+  #     write_options: {
+  #       connection: {
+  #         host: "localhost",
+  #         port: 5432,
+  #         dbname: "bas",
+  #         user: "postgres",
+  #         password: "postgres"
+  #       },
+  #       db_table: "github_issues",
+  #       tag: "VerifyIssueExistanceInNotio"
+  #     }
+  #   }
+  #
+  #   bot = Bot::VerifyIssueExistanceInNotion.new(options)
+  #   bot.execute
+  #
+  class VerifyIssueExistanceInNotion < Bot::Base
+    NOT_FOUND = "not found"
+
+    # read function to execute the PostgresDB Read component
+    #
+    def read
+      reader = Read::Postgres.new(read_options.merge(conditions))
+
+      reader.execute
+    end
+
+    # process function to execute the Notion utility to verify GitHub issues existance
+    # on a notion database
+    #
+    def process
+      return { success: { issue: nil } } if unprocessable_response
+
+      response = Utils::Notion::Request.execute(params)
+
+      if response.code == 200
+        result = response.parsed_response["results"].first
+
+        { success: { issue: read_response.data["request"], notion_wi: notion_wi_id(result) } }
+      else
+        { error: { message: response.parsed_response, status_code: response.code } }
+      end
+    end
+
+    # write function to execute the PostgresDB write component
+    #
+    def write
+      options = write_options.merge({ tag: })
+
+      write = Write::Postgres.new(options, process_response)
+
+      write.execute
+    end
+
+    private
+
+    def conditions
+      {
+        where: "archived=$1 AND tag=$2 AND stage=$3 ORDER BY inserted_at ASC",
+        params: [false, read_options[:tag], "unprocessed"]
+      }
+    end
+
+    def params
+      {
+        endpoint: "databases/#{process_options[:database_id]}/query",
+        secret: process_options[:secret],
+        method: "post",
+        body:
+      }
+    end
+
+    def body
+      {
+        filter: {
+          property: "Github Issue id",
+          rich_text: { equals: read_response.data["request"]["id"].to_s }
+        }
+      }
+    end
+
+    def notion_wi_id(result)
+      return NOT_FOUND if result.nil?
+
+      result["id"]
+    end
+
+    def tag
+      issue = process_response[:success]
+
+      return write_options[:tag] if issue.nil? || issue[:notion_wi].nil?
+
+      issue[:notion_wi].eql?(NOT_FOUND) ? "CreateWorkItemRequest" : "UpdateWorkItemRequest"
+    end
+  end
+end

data/lib/bas/bot/write_domain_review_requests.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+require_relative "./base"
+require_relative "../read/postgres"
+require_relative "../utils/notion/update_db_state"
+require_relative "../write/postgres"
+
+module Bot
+  ##
+  # The Bot::WriteDomainReviewRequests class serves as a bot implementation to read from a postgres
+  # shared storage a set of review domain requests and create single request on the shared storage to
+  # be processed one by one.
+  #
+  # <br>
+  # <b>Example</b>
+  #
+  #   options = {
+  #     read_options: {
+  #       connection: {
+  #         host: "localhost",
+  #         port: 5432,
+  #         dbname: "bas",
+  #         user: "postgres",
+  #         password: "postgres"
+  #       },
+  #       db_table: "web_availability",
+  #       tag: "FetchDomainServicesFromNotion"
+  #     },
+  #     process_options: {
+  #       connection: {
+  #         host: "localhost",
+  #         port: 5432,
+  #         dbname: "bas",
+  #         user: "postgres",
+  #         password: "postgres"
+  #       },
+  #       db_table: "web_availability",
+  #       tag: "ReviewDomainRequest"
+  #     },
+  #     write_options: {
+  #       connection: {
+  #         host: "localhost",
+  #         port: 5432,
+  #         dbname: "bas",
+  #         user: "postgres",
+  #         password: "postgres"
+  #       },
+  #       db_table: "web_availability",
+  #       tag: "WriteDomainReviewRequests"
+  #     }
+  #   }
+  #
+  #   bot = Bot::WriteDomainReviewRequests.new(options)
+  #   bot.execute
+  #
+  class WriteDomainReviewRequests < Bot::Base
+    # read function to execute the PostgresDB Read component
+    #
+    def read
+      reader = Read::Postgres.new(read_options.merge(conditions))
+
+      reader.execute
+    end
+
+    # Process function to execute the Notion utility create single review requests
+    #
+    def process
+      return { success: { created: nil } } if unprocessable_response
+
+      read_response.data["urls"].each { |request| create_request(request) }
+
+      { success: { created: true } }
+    end
+
+    # Write function to execute the PostgresDB write component
+    #
+    def write
+      write = Write::Postgres.new(write_options, process_response)
+
+      write.execute
+    end
+
+    private
+
+    def conditions
+      {
+        where: "archived=$1 AND tag=$2 AND stage=$3 ORDER BY inserted_at ASC",
+        params: [false, read_options[:tag], "unprocessed"]
+      }
+    end
+
+    def create_request(request)
+      write_data = write_request(request)
+
+      Write::Postgres.new(process_options, write_data).execute
+    end
+
+    def write_request(request)
+      return { error: request } if request["url"].empty? || !request["error"].nil?
+
+      { success: request }
+    end
+  end
+end

data/lib/bas/bot/write_github_issue_requests.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require_relative "./base"
+require_relative "../read/postgres"
+require_relative "../write/postgres"
+
+module Bot
+  ##
+  # The Bot::WriteGithubIssueRequests class serves as a bot implementation to write GitHub issues
+  # request to be sent individually.
+  #
+  # <br>
+  # <b>Example</b>
+  #
+  #   options = {
+  #     read_options: {
+  #       connection: {
+  #         host: "localhost",
+  #         port: 5432,
+  #         dbname: "bas",
+  #         user: "postgres",
+  #         password: "postgres"
+  #       },
+  #       db_table: "github_issues",
+  #       tag: "FetchGithubIssues"
+  #     },
+  #     process_options: {
+  #       connection: {
+  #         host: "localhost",
+  #         port: 5432,
+  #         dbname: "bas",
+  #         user: "postgres",
+  #         password: "postgres"
+  #       },
+  #       db_table: "github_issues",
+  #       tag: "GithubIssueRequest"
+  #     },
+  #     write_options: {
+  #       connection: {
+  #         host: "localhost",
+  #         port: 5432,
+  #         dbname: "bas",
+  #         user: "postgres",
+  #         password: "postgres"
+  #       },
+  #       db_table: "github_issues",
+  #       tag: "WriteGithubIssueRequests"
+  #     }
+  #   }
+  #
+  #   bot = Bot::WriteGithubIssueRequests.new(options)
+  #   bot.execute
+  #
+  class WriteGithubIssueRequests < Bot::Base
+    # read function to execute the PostgresDB Read component
+    #
+    def read
+      reader = Read::Postgres.new(read_options.merge(conditions))
+
+      reader.execute
+    end
+
+    # Process function to write GitHub issues requests.
+    #
+    def process
+      return { success: { created: nil } } if unprocessable_response
+
+      read_response.data["issues"].each { |request| create_request(request) }
+
+      { success: { created: true } }
+    end
+
+    # Write function to execute the PostgresDB write component
+    #
+    def write
+      write = Write::Postgres.new(write_options, process_response)
+
+      write.execute
+    end
+
+    private
+
+    def conditions
+      {
+        where: "archived=$1 AND tag=$2 AND stage=$3 ORDER BY inserted_at ASC",
+        params: [false, read_options[:tag], "unprocessed"]
+      }
+    end
+
+    def create_request(request)
+      write_data = { success: { request: } }
+
+      Write::Postgres.new(process_options, write_data).execute
+    end
+  end
+end

data/lib/bas/utils/github/octokit_client.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require "octokit"
+require "openssl"
+require "jwt"
+
+module Utils
+  module Github
+    ##
+    # This module is a Github utility for making requests to the Github API using the octokit module
+    #
+    class OctokitClient
+      def initialize(params)
+        @params = params
+      end
+
+      # Build the octokit client using a Github app access token
+      #
+      def execute
+        { client: octokit }
+      rescue StandardError => e
+        { error: e.to_s }
+      end
+
+      private
+
+      def octokit
+        Octokit::Client.new(bearer_token: access_token)
+      end
+
+      def access_token
+        app = Octokit::Client.new(client_id: @params[:app_id], bearer_token: jwt)
+
+        installation_id = app.find_organization_installation(@params[:organization]).id
+
+        app.create_app_installation_access_token(installation_id)[:token]
+      end
+
+      def jwt
+        private_key = OpenSSL::PKey::RSA.new(@params[:private_pem])
+
+        JWT.encode(jwt_payload, private_key, "RS256")
+      end
+
+      def jwt_payload
+        {
+          iat: Time.now.to_i - 60,
+          exp: Time.now.to_i + (10 * 60),
+          iss: @params[:app_id]
+        }
+      end
+    end
+  end
+end

data/lib/bas/utils/notion/delete_page_blocks.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require "httparty"
+require_relative "request"
+
+module Utils
+  module Notion
+    ##
+    # This module is a Notion utility for deleting page blocks.
+    #
+    class DeletePageBlocks
+      # Implements the delete page blocks process logic to Notion.
+      #
+      # <br>
+      # <b>Params:</b>
+      # * <tt>page_id</tt> Id of the notion page.
+      # * <tt>secret</tt> Notion secret.
+      #
+      # <br>
+      # <b>returns</b> <tt>HTTParty::Response</tt>
+      #
+      #
+      def initialize(params)
+        @params = params
+      end
+
+      def execute
+        page_blocks_ids.each { |block_id| delete_block(block_id) }
+      end
+
+      private
+
+      def page_blocks_ids
+        page = Utils::Notion::Request.execute(page_params)
+
+        page.parsed_response["results"].map { |block| block["id"] }
+      end
+
+      def page_params
+        {
+          endpoint: "blocks/#{@params[:page_id]}/children",
+          secret: @params[:secret],
+          method: "get",
+          body: {}
+        }
+      end
+
+      def delete_block(block_id)
+        params = delete_params(block_id)
+
+        Utils::Notion::Request.execute(params)
+      end
+
+      def delete_params(block_id)
+        {
+          endpoint: "blocks/#{block_id}",
+          secret: @params[:secret],
+          method: "delete",
+          body: {}
+        }
+      end
+    end
+  end
+end

data/lib/bas/utils/notion/request.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "httparty"
+require "json"
 
 module Utils
   module Notion

data/lib/bas/utils/notion/types.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Utils
+  module Notion
+    ##
+    # This module is a Notion utility for formating standard notion types to
+    # filter or create.
+    #
+    module Types
+      def multi_select(name)
+        { "multi_select" => [{ "name" => name }] }
+      end
+
+      def relation(id)
+        { relation: [{ id: }] }
+      end
+
+      def select(name)
+        { select: { name: } }
+      end
+
+      def rich_text(content, url = nil)
+        text = { content: }
+
+        text = text.merge({ link: { url: } }) unless url.nil?
+
+        { rich_text: [{ text: }] }
+      end
+
+      def status(name)
+        { status: { name: } }
+      end
+
+      def title(content)
+        { title: [{ text: { content: } }] }
+      end
+    end
+  end
+end

data/lib/bas/version.rb

@@ -2,5 +2,5 @@
 
 module Bas
   # Gem version
-  VERSION = "1.2.1"
+  VERSION = "1.4.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bas
 version: !ruby/object:Gem::Version
-  version: 1.2.1
+  version: 1.4.0
 platform: ruby
 authors:
 - kommitters Open Source
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-07-16 00:00:00.000000000 Z
+date: 2024-07-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: gmail_xoauth
@@ -187,11 +187,14 @@ files:
 - lib/bas.rb
 - lib/bas/bot/base.rb
 - lib/bas/bot/compare_wip_limit_count.rb
+- lib/bas/bot/create_work_item.rb
 - lib/bas/bot/fetch_billing_from_digital_ocean.rb
 - lib/bas/bot/fetch_birthdays_from_notion.rb
+- lib/bas/bot/fetch_domain_services_from_notion.rb
 - lib/bas/bot/fetch_domains_wip_counts_from_notion.rb
 - lib/bas/bot/fetch_domains_wip_limit_from_notion.rb
 - lib/bas/bot/fetch_emails_from_imap.rb
+- lib/bas/bot/fetch_github_issues.rb
 - lib/bas/bot/fetch_media_from_notion.rb
 - lib/bas/bot/fetch_next_week_birthdays_from_notion.rb
 - lib/bas/bot/fetch_next_week_ptos_from_notion.rb
@@ -204,8 +207,13 @@ files:
 - lib/bas/bot/humanize_pto.rb
 - lib/bas/bot/notify_discord.rb
 - lib/bas/bot/notify_do_bill_alert_email.rb
+- lib/bas/bot/review_domain_availability.rb
 - lib/bas/bot/review_media.rb
 - lib/bas/bot/update_review_media_state.rb
+- lib/bas/bot/update_work_item.rb
+- lib/bas/bot/verify_issue_existance_in_notion.rb
+- lib/bas/bot/write_domain_review_requests.rb
+- lib/bas/bot/write_github_issue_requests.rb
 - lib/bas/bot/write_media_review_in_notion.rb
 - lib/bas/bot/write_media_review_requests.rb
 - lib/bas/read/base.rb
@@ -216,9 +224,12 @@ files:
 - lib/bas/utils/discord/integration.rb
 - lib/bas/utils/exceptions/function_not_implemented.rb
 - lib/bas/utils/exceptions/invalid_process_response.rb
+- lib/bas/utils/github/octokit_client.rb
 - lib/bas/utils/google/send_email.rb
 - lib/bas/utils/imap/request.rb
+- lib/bas/utils/notion/delete_page_blocks.rb
 - lib/bas/utils/notion/request.rb
+- lib/bas/utils/notion/types.rb
 - lib/bas/utils/notion/update_db_state.rb
 - lib/bas/utils/openai/run_assistant.rb
 - lib/bas/utils/postgres/request.rb