bas 1.0.1 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 216571ef89c79b718c94679f1eee6890d3f0d278f563cb7b4dc1d3b6e9fc3d5f
-  data.tar.gz: 2ccd756d550b06b8946af3298bc21b6ef4535679f4b74479d5140a99b740424b
+  metadata.gz: 96a0471a8f9a39c6052efb69c6513fef4f3bc25679cef122830e695c51daa06f
+  data.tar.gz: 21e33ec2357be44b132b8839403a5048738b488dabe2ea4fc11b588f4732bc24
 SHA512:
-  metadata.gz: f8b27047e7c1da06071b4711f434ae3c9313ae8b8bed345724b57c344fb15c5ddb4c2bbe30ecc930ab96431f29c61230cdb8449eb2c1720b40b33e20c02fee20
-  data.tar.gz: 4285d4d6e805cc843f7218e4937bb0e7b5ce24a240b5261a2a75a89253e03538c4a93f7840e120715123a7d19822039a0f7b9ea70b7a2e6d8dac28a806557ebf
+  metadata.gz: 845bbb146ac9dcfa884fb27bb4877a9896bd27ead8d145d6645769d57736ce3bf78a768bd61a559a444c9526803da0b2f3076fbe8bd02dffa2a12635d2659d27
+  data.tar.gz: 42e5c8fb5d23fa2bf5f4f0589e6b16ec35db9553bcdc4881b5a3376b6fa0d25f7f55058883b5891db24efe284390948c19e6708764d7ee922b35bf0562479f21

data/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+# 1.1.0 (01.07.2024)
+- [Add write media review requests bot](https://github.com/kommitters/bas/issues/51)
+- [Add write media review in notion bot](https://github.com/kommitters/bas/issues/54)
+- [Add update review media state bot](https://github.com/kommitters/bas/issues/55)
+- [Add Media review process bot](https://github.com/kommitters/bas/issues/52)
+- [Media review notion fetch bot](https://github.com/kommitters/bas/issues/50)
+
 # 1.0.1 (21.06.2024)
 - Refactor pto notification format for improving OpenAI response.
 

data/Gemfile

@@ -28,3 +28,5 @@ gem "httparty"
 gem "pg", "~> 1.5", ">= 1.5.4"
 
 gem "gmail_xoauth"
+
+gem "md_to_notion", "~> 0.1.4"

data/lib/bas/bot/fetch_media_from_notion.rb

@@ -0,0 +1,186 @@
+# frozen_string_literal: true
+
+require_relative "./base"
+require_relative "../read/postgres"
+require_relative "../utils/notion/request"
+require_relative "../write/postgres"
+
+module Bot
+  ##
+  # The Bot::FetchMediaFromNotion class serves as a bot implementation to read media (text or images)
+  # 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",
+  #       property: "paragraph"
+  #     },
+  #     write_options: {
+  #       connection: {
+  #         host: "localhost",
+  #         port: 5432,
+  #         dbname: "bas",
+  #         user: "postgres",
+  #         password: "postgres"
+  #       },
+  #       db_table: "review_media",
+  #       tag: "FetchMediaFromNotion"
+  #     }
+  #   }
+  #
+  #   bot = Bot::FetchMediaFromNotion.new(options)
+  #   bot.execute
+  #
+  class FetchMediaFromNotion < Bot::Base # rubocop:disable Metrics/ClassLength
+    CONTENT_STATUS = "review"
+
+    # 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 fetch media from a notion database
+    #
+    def process
+      media_response = fetch_media
+
+      return media_response unless media_response[:error].nil?
+
+      { success: media_response[:results] }
+    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 ORDER BY inserted_at DESC",
+        params: [false, read_options[:tag]]
+      }
+    end
+
+    def fetch_media
+      request_ids_response = fetch_requests_ids
+
+      return request_ids_response unless request_ids_response[:error].nil?
+
+      { results: fetch_pages(request_ids_response[:ids]) }
+    end
+
+    def fetch_requests_ids
+      response = Utils::Notion::Request.execute(params_database)
+
+      return error(response) unless response.code == 200
+
+      { ids: response["results"]&.map { |result| result["id"] } }
+    end
+
+    def fetch_pages(pages_ids)
+      pages_ids.map do |page_id|
+        content_response = fetch_content(page_id)
+
+        process_content(page_id, content_response)
+      end
+    end
+
+    def process_content(page_id, content)
+      return content unless content[:error].nil?
+
+      filter_media(page_id, content[:results])
+    end
+
+    def filter_media(page_id, page_content)
+      medias = page_content.select { |content| content["type"] == process_options[:property] }
+
+      media = extract_content(medias)
+      created_by = medias.first["created_by"]["id"] unless medias.first.nil?
+
+      { media:, page_id:, created_by:, property: process_options[:property] }
+    end
+
+    def extract_content(content)
+      case process_options[:property]
+      when "image" then process_images(content)
+      when "paragraph" then process_text(content)
+      end
+    end
+
+    def process_images(images)
+      images.map { |image| image["image"]["file"]["url"] }
+    end
+
+    def process_text(texts)
+      texts.reduce("") do |paragraph, text|
+        rich_text = text["paragraph"]["rich_text"].map { |plain_text| plain_text["plain_text"] }
+
+        content = rich_text.empty? ? "" : rich_text.join(" ")
+
+        "#{paragraph}\n#{content}"
+      end
+    end
+
+    def fetch_content(block_id)
+      response = fetch_block(block_id)
+
+      return error(response) unless response.code == 200
+
+      { results: response["results"] }
+    end
+
+    def error(response)
+      { error: { message: response.parsed_response, status_code: response.code } }
+    end
+
+    def params_database
+      {
+        endpoint: "databases/#{process_options[:database_id]}/query",
+        secret: process_options[:secret],
+        method: "post",
+        body: body_database
+      }
+    end
+
+    def body_database
+      { filter: { and: [] + property_condition + time_condition } }
+    end
+
+    def property_condition
+      [{ property: process_options[:property], select: { equals: CONTENT_STATUS } }]
+    end
+
+    def time_condition
+      return [] if read_response.inserted_at.nil?
+
+      [{ property: "Last edited time", last_edited_time: { on_or_after: read_response.inserted_at } }]
+    end
+
+    def fetch_block(block_id)
+      params = block_params(block_id)
+
+      Utils::Notion::Request.execute(params)
+    end
+
+    def block_params(block_id)
+      {
+        endpoint: "blocks/#{block_id}/children",
+        secret: process_options[:secret],
+        method: "get",
+        body: {}
+      }
+    end
+  end
+end

data/lib/bas/bot/review_media.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+require "md_to_notion"
+require "json"
+
+require_relative "./base"
+require_relative "../read/postgres"
+require_relative "../write/postgres"
+require_relative "../utils/openai/run_assistant"
+
+module Bot
+  ##
+  # The Bot::WriteMediaReviewRequests class serves as a bot implementation to read from a postgres
+  # shared storage a set of review media 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: "review_media",
+  #       tag: "ReviewMediaRequest"
+  #     },
+  #     process_options: {
+  #       secret: "openai_secret",
+  #       assistant_id: "openai_assistant_id",
+  #       media_type: "paragraph"
+  #     },
+  #     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
+
+      sucess_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 notion_format(response)
+      md_response = response.parsed_response["data"].first["content"].first["text"]["value"]
+
+      MdToNotion::Parser.markdown_to_notion_blocks(md_response).to_json
+    end
+
+    def sucess_response(response)
+      review = notion_format(response)
+      page_id = read_response.data["page_id"]
+      created_by = read_response.data["created_by"]
+      property = read_response.data["property"]
+
+      { success: { review:, page_id:, created_by:, property:, 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

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+require_relative "./base"
+require_relative "../read/default"
+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/write_media_review_in_notion.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+require "json"
+
+require_relative "./base"
+require_relative "../read/default"
+require_relative "../utils/notion/request"
+require_relative "../write/postgres"
+
+module Bot
+  ##
+  # The Bot::WriteMediaReviewInNotion class serves as a bot implementation to read from a postgres
+  # shared storage formated notion blocks and send them to a Notion page
+  #
+  # <br>
+  # <b>Example</b>
+  #
+  #   options = {
+  #     read_options: {
+  #       connection: {
+  #         host: "localhost",
+  #         port: 5432,
+  #         dbname: "bas",
+  #         user: "postgres",
+  #         password: "postgres"
+  #       },
+  #       db_table: "review_media",
+  #       tag: "FormatMediaReview"
+  #     },
+  #     process_options: {
+  #       secret: "notion_secret"
+  #     },
+  #     write_options: {
+  #       connection: {
+  #         host: "localhost",
+  #         port: 5432,
+  #         dbname: "bas",
+  #         user: "postgres",
+  #         password: "postgres"
+  #       },
+  #       db_table: "review_media",
+  #       tag: "WriteMediaReviewInNotion"
+  #     }
+  #   }
+  #
+  #   bot = Bot::WriteMediaReviewInNotion.new(options)
+  #   bot.execute
+  #
+  class WriteMediaReviewInNotion < Bot::Base
+    CHUNK_SIZE = "1000"
+
+    # 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 send formated blocks to a page
+    #
+    def process
+      return { success: { review_added: nil } } if unprocessable_response
+
+      response = Utils::Notion::Request.execute(params)
+
+      if response.code == 200
+        { success: { page_id: read_response.data["page_id"], property: read_response.data["property"] } }
+      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["page_id"]}/children",
+        secret: process_options[:secret],
+        method: "patch",
+        body:
+      }
+    end
+
+    def body
+      { children: [{ object: "block", type: "toggle", toggle: }] }
+    end
+
+    def toggle
+      {
+        rich_text: [{ type: "text", text: { content: toggle_title } }, mention],
+        children: toggle_childrens
+      }
+    end
+
+    def toggle_childrens
+      JSON.parse(read_response.data["review"])
+    end
+
+    def mention
+      {
+        type: "mention",
+        mention: {
+          type: "user",
+          user: { id: read_response.data["created_by"] }
+        }
+      }
+    end
+
+    def toggle_title
+      case read_response.data["media_type"]
+      when "images" then "Image review results/"
+      when "paragraph" then "Text review results/"
+      end
+    end
+  end
+end

data/lib/bas/bot/write_media_review_requests.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require_relative "./base"
+require_relative "../read/postgres"
+require_relative "../write/postgres"
+
+module Bot
+  ##
+  # The Bot::WriteMediaReviewRequests class serves as a bot implementation to read from a postgres
+  # shared storage a set of review media 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: "review_media",
+  #       tag: "FetchMediaFromNotion"
+  #     },
+  #     process_options: {
+  #       connection: {
+  #         host: "localhost",
+  #         port: 5432,
+  #         dbname: "bas",
+  #         user: "postgres",
+  #         password: "postgres"
+  #       },
+  #       db_table: "review_media",
+  #       tag: "ReviewMediaRequest"
+  #     },
+  #     write_options: {
+  #       connection: {
+  #         host: "localhost",
+  #         port: 5432,
+  #         dbname: "bas",
+  #         user: "postgres",
+  #         password: "postgres"
+  #       },
+  #       db_table: "review_media",
+  #       tag: "WriteMediaReviewRequests"
+  #     }
+  #   }
+  #
+  #   bot = Bot::WriteMediaReviewRequests.new(options)
+  #   bot.execute
+  #
+  class WriteMediaReviewRequests < 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.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["media"].empty? || !request["error"].nil?
+
+      { success: request }
+    end
+  end
+end

data/lib/bas/version.rb

@@ -2,5 +2,5 @@
 
 module Bas
   # Gem version
-  VERSION = "1.0.1"
+  VERSION = "1.1.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bas
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.1.0
 platform: ruby
 authors:
 - kommitters Open Source
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-06-21 00:00:00.000000000 Z
+date: 2024-07-02 00:00:00.000000000 Z
 dependencies: []
 description: A versatile business automation system offering key components for building
   various use cases.     It provides an easy-to-use tool for implementing automation
@@ -37,6 +37,7 @@ files:
 - 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_media_from_notion.rb
 - lib/bas/bot/fetch_next_week_birthdays_from_notion.rb
 - lib/bas/bot/fetch_next_week_ptos_from_notion.rb
 - lib/bas/bot/fetch_ptos_from_notion.rb
@@ -46,6 +47,10 @@ files:
 - lib/bas/bot/garbage_collector.rb
 - lib/bas/bot/humanize_pto.rb
 - lib/bas/bot/notify_discord.rb
+- lib/bas/bot/review_media.rb
+- lib/bas/bot/update_review_media_state.rb
+- lib/bas/bot/write_media_review_in_notion.rb
+- lib/bas/bot/write_media_review_requests.rb
 - lib/bas/read/base.rb
 - lib/bas/read/default.rb
 - lib/bas/read/postgres.rb