bas 1.5.3 → 1.6.0

data/lib/bas/bot/review_media.rb

@@ -1,139 +0,0 @@
-# frozen_string_literal: true
-
-require "json"
-
-require_relative "./base"
-require_relative "../read/postgres"
-require_relative "../write/postgres"
-require_relative "../utils/openai/run_assistant"
-
-module Bot
-  ##
-  # The Bot::ReviewMedia class serves as a bot implementation to read from a postgres
-  # shared storage a images hash with a specific format 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: "review_media",
-  #       tag: "ReviewMediaRequest"
-  #     },
-  #     process_options: {
-  #       secret: "openai_secret",
-  #       assistant_id: "openai_assistant_id",
-  #       media_type: "images"
-  #     },
-  #     write_options: {
-  #       connection: {
-  #         host: "localhost",
-  #         port: 5432,
-  #         dbname: "bas",
-  #         user: "postgres",
-  #         password: "postgres"
-  #       },
-  #       db_table: "review_media",
-  #       tag: "ReviewText"
-  #     }
-  #   }
-  #
-  #   bot = Bot::ReviewMedia.new(options)
-  #   bot.execute
-  #
-  class ReviewMedia < Bot::Base
-    DETAIL = "low"
-    # 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 OpenaAI utility to process the media reviews
-    #
-    def process
-      return { success: { review: nil } } if unprocessable_response
-
-      response = Utils::OpenAI::RunAssitant.execute(params)
-
-      if response.code != 200 || (!response["status"].nil? && response["status"] != "completed")
-        return error_response(response)
-      end
-
-      success_response(response)
-    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
-      {
-        assistant_id: process_options[:assistant_id],
-        secret: process_options[:secret],
-        prompt: build_prompt
-      }
-    end
-
-    def build_prompt
-      case process_options[:media_type]
-      when "images" then images_media
-      when "paragraph" then text_media
-      end
-    end
-
-    def images_media
-      read_response.data["media"].map { |url| { type: "image_url", image_url: { url:, detail: DETAIL } } }
-    end
-
-    def text_media
-      read_response.data["media"]
-    end
-
-    def success_response(response)
-      review = get_review(response)
-      { success: media_hash.merge({ review: }) }
-    end
-
-    def get_review(response)
-      response.parsed_response["data"].first["content"].first["text"]["value"]
-    end
-
-    def media_hash
-      {
-        message_id: read_response.data["message_id"],
-        channel_id: read_response.data["channel_id"],
-        property: read_response.data["property"],
-        author: read_response.data["author"],
-        media_type: process_options[:media_type]
-      }
-    end
-
-    def error_response(response)
-      { error: { message: response.parsed_response, status_code: response.code } }
-    end
-  end
-end

data/lib/bas/bot/update_review_media_state.rb

@@ -1,102 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "./base"
-require_relative "../read/postgres"
-require_relative "../utils/notion/request"
-require_relative "../write/postgres"
-
-module Bot
-  ##
-  # The Bot::UpdateReviewMediaStatus class serves as a bot implementation to read from a postgres
-  # shared storage updated status and update a parameter on a Notion database.
-  #
-  # <br>
-  # <b>Example</b>
-  #
-  #   options = {
-  #     read_options: {
-  #       connection: {
-  #         host: "localhost",
-  #         port: 5432,
-  #         dbname: "bas",
-  #         user: "postgres",
-  #         password: "postgres"
-  #       },
-  #       db_table: "review_media",
-  #       tag: "WriteMediaReviewInNotion"
-  #     },
-  #     process_options: {
-  #       secret: "notion_secret"
-  #     },
-  #     write_options: {
-  #       connection: {
-  #         host: "localhost",
-  #         port: 5432,
-  #         dbname: "bas",
-  #         user: "postgres",
-  #         password: "postgres"
-  #       },
-  #       db_table: "review_media",
-  #       tag: "UpdateReviewMediaStatus"
-  #     }
-  #   }
-  #
-  #   bot = Bot::UpdateReviewMediaStatus.new(options)
-  #   bot.execute
-  #
-  class UpdateReviewMediaStatus < Bot::Base
-    READY_STATE = "ready"
-
-    # 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 a Notion database property
-    #
-    def process
-      return { success: { status_updated: nil } } if unprocessable_response
-
-      response = Utils::Notion::Request.execute(params)
-
-      if response.code == 200
-        { success: { status_updated: true } }
-      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: "pages/#{read_response.data["page_id"]}",
-        secret: process_options[:secret],
-        method: "patch",
-        body:
-      }
-    end
-
-    def body
-      { properties: { read_response.data["property"] => { select: { name: READY_STATE } } } }
-    end
-  end
-end

data/lib/bas/bot/update_work_item.rb

@@ -1,181 +0,0 @@
-# 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 "../utils/notion/fetch_database_record"
-require_relative "../utils/notion/update_db_page"
-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"
-    GITHUB_COLUMN = "Username"
-
-    # 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
-
-      response = process_wi
-
-      if response.code == 200
-        update_assigness
-
-        { 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 process_wi
-      delete_wi
-
-      Utils::Notion::Request.execute(params)
-    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
-      options = {
-        page_id: read_response.data["notion_wi"],
-        secret: process_options[:secret]
-      }
-
-      Utils::Notion::DeletePageBlocks.new(options).execute
-    end
-
-    def update_assigness
-      relation = users.map { |user| user_id(user) }
-
-      options = {
-        page_id: read_response.data["notion_wi"],
-        secret: process_options[:secret],
-        body: { properties: { People: { relation: } }.merge(status) }
-      }
-
-      Utils::Notion::UpdateDatabasePage.new(options).execute
-    end
-
-    def users
-      options = {
-        database_id: process_options[:users_database_id],
-        secret: process_options[:secret],
-        body: { filter: { or: github_usernames } }
-      }
-
-      Utils::Notion::FetchDatabaseRecord.new(options).execute
-    end
-
-    def github_usernames
-      read_response.data["issue"]["assignees"].map do |username|
-        { property: GITHUB_COLUMN, rich_text: { equals: username } }
-      end
-    end
-
-    def user_id(user)
-      relation = user.dig("properties", "People", "relation")
-
-      relation.nil? ? {} : relation.first
-    end
-
-    def status
-      return {} unless read_response.data["issue"]["state"] == "closed"
-
-      { Status: { status: { name: "Done" } } }
-    end
-  end
-end

data/lib/bas/bot/verify_issue_existance_in_notion.rb

@@ -1,131 +0,0 @@
-# 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"
-    NOTION_PROPERTY = "Github Issue Id"
-
-    # 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: read_response.data.merge({ 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: NOTION_PROPERTY,
-          rich_text: { equals: read_response.data["issue"]["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

@@ -1,104 +0,0 @@
-# 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