bas 1.0.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b15ef30bfbc91578e5b2ef5bf19861f9bda796d0296faa65ae80cd2244521655
-  data.tar.gz: 34775b96d78ee72c66a1d7501020d810030bbf6fc0396ec12e0aa39ed58d3735
+  metadata.gz: 96a0471a8f9a39c6052efb69c6513fef4f3bc25679cef122830e695c51daa06f
+  data.tar.gz: 21e33ec2357be44b132b8839403a5048738b488dabe2ea4fc11b588f4732bc24
 SHA512:
-  metadata.gz: 7f74a4e1963f29cd2f7cc5d5847d4215cd403281394711570d6c612771ed7036ada74941cd449f1c8c1faf82b7d6f33bb0941ce81b4c39884a240404637e6d6d
-  data.tar.gz: 82c7867b2b3af0a16f3ca4780c796bff3ed3ae3e27d5b6e31d91731d2dea7bc367ebd4ac9ad39e54b98c56ef3f686e9bdf5411e54c8dd7fe6359356ca7809e48
+  metadata.gz: 845bbb146ac9dcfa884fb27bb4877a9896bd27ead8d145d6645769d57736ce3bf78a768bd61a559a444c9526803da0b2f3076fbe8bd02dffa2a12635d2659d27
+  data.tar.gz: 42e5c8fb5d23fa2bf5f4f0589e6b16ec35db9553bcdc4881b5a3376b6fa0d25f7f55058883b5891db24efe284390948c19e6708764d7ee922b35bf0562479f21

data/CHANGELOG.md

@@ -1,5 +1,15 @@
 # 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.
+
 # 1.0.0 (17.05.2024)
 - [Refactor Project Architecture](https://github.com/kommitters/bas/issues/35)
 - [Refactor PTO today Use Case](https://github.com/kommitters/bas/issues/29)

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/fetch_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"
@@ -106,14 +108,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?("T") ? "#{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/humanize_pto.rb

@@ -101,9 +101,7 @@ module Bot
       prompt = process_options[:prompt] || DEFAULT_PROMPT
       ptos_list = read_response.data["ptos"]
 
-      ptos_list_formatted_string = ptos_list.map do |pto|
-        "#{pto["Name"]} is PTO from StartDateTime: #{pto["StartDateTime"]} to EndDateTime: #{pto["EndDateTime"]}"
-      end.join("\n")
+      ptos_list_formatted_string = ptos_list.join("\n")
 
       prompt.gsub("{data}", ptos_list_formatted_string)
     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.0"
+  VERSION = "1.1.0"
 end

metadata

@@ -1,18 +1,18 @@
 --- !ruby/object:Gem::Specification
 name: bas
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0
 platform: ruby
 authors:
 - kommitters Open Source
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-05-17 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
-  workflows without excessive complexity.     Formerly known as 'bns'.
+  workflows without excessive complexity.     Formerly known as 'bas'.
 email:
 - oss@kommit.co
 executables: []
@@ -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
@@ -84,7 +89,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.9
+rubygems_version: 3.5.11
 signing_key:
 specification_version: 4
 summary: BAS - Business automation system