bas 1.3.0 → 1.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3488575b41bad4918323fc10988339fa6eb121d5923586a416b71f9bb7665d15
-  data.tar.gz: 9599e9fea3a5e1f6d283941d8220f2b87a495adf8c1c1d077c4c6a66ef1b7278
+  metadata.gz: 4ab201fef0200fb13b92ff49a3925c0fc2a10efd26a473d987cc9eef4ddbeae6
+  data.tar.gz: 93724237d9d6865c369e46f528a2a92dc63b7dd4239d5b0d37725cdb57d96ff9
 SHA512:
-  metadata.gz: 77439d8970fc20a1d6ad7fddc349252e6e19cbed2f44bf06191c572fb45e951130715bc3285ba1a9a013d8669575260cb97886aa1721b274d2b0078c7c17a9b6
-  data.tar.gz: 27df232926e7652eab7d7fddb523aea3542c417f6ac7e2193287c548ee472428f76c31c48deb165a103125a7beb1bd93148458a8a42173406d382c2ea7c69a6f
+  metadata.gz: a958b5d144da8fa1e162d5d44a18dd30472d2cd7bbd9c6d3fe6991d860a2b5199b9c68aff3b190fbdc48cc275b686c6707b304b39552a6776945e391b4bcb5b1
+  data.tar.gz: 30d014adce784050342b51663a583ee7474e2f00b28ef60210254c5f3fdf43d614607bff763325d93016d5b6bd320a5cdb9363a86b03082d37e28d896248979a

data/CHANGELOG.md

@@ -1,5 +1,9 @@
 # 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)
 

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_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/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_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/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.3.0"
+  VERSION = "1.4.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bas
 version: !ruby/object:Gem::Version
-  version: 1.3.0
+  version: 1.4.0
 platform: ruby
 authors:
 - kommitters Open Source
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-07-18 00:00:00.000000000 Z
+date: 2024-07-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: gmail_xoauth
@@ -187,12 +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
@@ -208,7 +210,10 @@ files:
 - 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
@@ -219,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