bns 0.1.0 → 0.2.0

data/lib/bns/fetcher/notion/use_case/work_items_limit.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_relative "../base"
+
+module Fetcher
+  module Notion
+    ##
+    # This class is an implementation of the Fetcher::Notion::Base interface, specifically designed
+    # for counting "in progress" work items from work item database in Notion.
+    #
+    class WorkItemsLimit < Notion::Base
+      # Implements the data fetching count of "in progress" work items from Notion.
+      #
+      def fetch
+        filter = {
+          filter: {
+            "and": [
+              { property: "OK", formula: { string: { contains: "✅" } } },
+              { "or": status_conditions }
+            ]
+          }
+        }
+
+        execute(filter)
+      end
+
+      private
+
+      def status_conditions
+        [
+          { property: "Status", status: { equals: "In Progress" } },
+          { property: "Status", status: { equals: "On Hold" } }
+        ]
+      end
+    end
+  end
+end

data/lib/bns/fetcher/postgres/base.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require "pg"
+
+require_relative "../base"
+require_relative "./types/response"
+require_relative "./helper"
+
+module Fetcher
+  module Postgres
+    ##
+    # This class is an implementation of the Fetcher::Base interface, specifically designed
+    # for fetching data from Postgres.
+    #
+    class Base < Fetcher::Base
+      protected
+
+      # Implements the data fetching logic from a Postgres database. It use the PG gem
+      # to request data from a local or external database and returns a validated response.
+      #
+      # Gem: pg (https://rubygems.org/gems/pg)
+      #
+      def execute(query)
+        pg_connection = PG::Connection.new(config[:connection])
+
+        pg_result = execute_query(pg_connection, query)
+
+        postgres_response = Fetcher::Postgres::Types::Response.new(pg_result)
+
+        Fetcher::Postgres::Helper.validate_response(postgres_response)
+      end
+
+      private
+
+      def execute_query(pg_connection, query)
+        if query.is_a? String
+          pg_connection.exec(query)
+        else
+          sentence, params = query
+
+          pg_connection.exec_params(sentence, params)
+        end
+      end
+    end
+  end
+end

data/lib/bns/fetcher/postgres/helper.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Fetcher
+  module Postgres
+    ##
+    # Provides common fuctionalities along the Postgres domain.
+    #
+    module Helper
+      def self.validate_response(response)
+        response.response.check_result
+
+        response
+      end
+    end
+  end
+end

data/lib/bns/fetcher/postgres/types/response.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Fetcher
+  module Postgres
+    module Types
+      ##
+      # Represents a response received from the Postgres API. It encapsulates essential information about the response,
+      # providing a structured way to handle and analyze it's responses.
+      class Response
+        attr_reader :status, :message, :response, :fields, :records
+
+        SUCCESS_STATUS = "PGRES_TUPLES_OK"
+
+        def initialize(response)
+          if response.res_status == SUCCESS_STATUS
+            success_response(response)
+          else
+            failure_response(response)
+          end
+        end
+
+        private
+
+        def success_response(response)
+          @status = response.res_status
+          @message = "success"
+          @response = response
+          @fields = response.fields
+          @records = response.values
+        end
+
+        def failure_response(response)
+          @status = response.res_status
+          @message = response.result_error_message
+          @response = response
+          @fields = nil
+          @records = nil
+        end
+      end
+    end
+  end
+end

data/lib/bns/fetcher/postgres/use_case/pto_today.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative "../base"
+
+module Fetcher
+  module Postgres
+    ##
+    # This class is an implementation of the Fetcher::Postgres::Base interface, specifically designed
+    # for fetching Paid Time Off (PTO) data from a Postgres Database.
+    #
+    class PtoToday < Base
+      # Implements the data fetching query for todays PTO data from a Postgres database.
+      #
+      def fetch
+        execute(build_query)
+      end
+
+      private
+
+      def build_query
+        today = Time.now.utc.strftime("%F").to_s
+
+        start_time = "#{today}T00:00:00"
+        end_time = "#{today}T23:59:59"
+
+        where = "(start_date <= $1 AND end_date >= $1) OR (start_date>= $2 AND end_date <= $3)"
+
+        ["SELECT * FROM pto WHERE #{where}", [today, start_time, end_time]]
+      end
+    end
+  end
+end

data/lib/bns/formatter/base.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "../domain/exceptions/function_not_implemented"
+require "erb"
 
 module Formatter
   ##
@@ -8,9 +9,18 @@ module Formatter
   # within the Formatter module. Defines essential methods, that provide a blueprint for creating custom
   # formatters tailored to different use cases.
   #
-  module Base
-    # A method meant to give an specified format depending on the implementation to the data coming from an
-    # implementation of the Mapper::Base interface.
+  class Base
+    attr_reader :template
+
+    # Initializes the fetcher with essential configuration parameters.
+    #
+    def initialize(config = {})
+      @config = config
+      @template = config[:template]
+    end
+
+    # This method is designed to provide a specified format for data from any implementation of
+    # the Mapper::Base interface.
     # Must be overridden by subclasses, with specific logic based on the use case.
     #
     # <br>
@@ -25,5 +35,19 @@ module Formatter
     def format(_domain_data)
       raise Domain::Exceptions::FunctionNotImplemented
     end
+
+    protected
+
+    def build_template(attributes, instance)
+      formated_template = format_template(attributes, instance)
+
+      "#{ERB.new(formated_template).result(binding)}\n"
+    end
+
+    def format_template(attributes, _instance)
+      attributes.reduce(template) do |formated_template, attribute|
+        formated_template.gsub(attribute, "<%= instance.#{attribute} %>")
+      end
+    end
   end
 end

data/lib/bns/formatter/birthday.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require_relative "../domain/birthday"
+require_relative "./exceptions/invalid_data"
+require_relative "./base"
+
+module Formatter
+  ##
+  # This class implements methods from the Formatter::Base module, tailored to format the
+  # Domain::Birthday structure for a dispatcher.
+  class Birthday < Base
+    # Implements the logic for building a formatted payload with the given template for birthdays.
+    #
+    # <br>
+    # <b>Params:</b>
+    # * <tt>List<Domain::Birthday></tt> birthdays_list: list of mapped birthdays.
+    #
+    # <br>
+    # <b>raises</b> <tt>Formatter::Exceptions::InvalidData</tt> when invalid data is provided.
+    #
+    # <br>
+    # <b>returns</b> <tt>String</tt> payload: formatted payload suitable for a Dispatcher.
+    #
+    def format(birthdays_list)
+      raise Formatter::Exceptions::InvalidData unless birthdays_list.all? do |brithday|
+        brithday.is_a?(Domain::Birthday)
+      end
+
+      birthdays_list.reduce("") do |payload, birthday|
+        payload + build_template(Domain::Birthday::ATTRIBUTES, birthday)
+      end
+    end
+  end
+end

data/lib/bns/formatter/exceptions/invalid_data.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Formatter
+  module Exceptions
+    ##
+    # Provides a domain-specific representation for errors that occurs when trying to process invalid
+    # data on a Fetcher::Base implementation
+    #
+    class InvalidData < StandardError
+      def initialize(message = "")
+        super(message)
+      end
+    end
+  end
+end

data/lib/bns/formatter/pto.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require_relative "../domain/pto"
+require_relative "./exceptions/invalid_data"
+require_relative "./base"
+
+module Formatter
+  ##
+  # This class implements methods from the Formatter::Base module, tailored to format the
+  # Domain::Pto structure for a dispatcher.
+  class Pto < Base
+    # Initializes the Slack formatter with essential configuration parameters.
+    #
+    # <b>timezone</b> : expect an string with the time difference relative to the UTC. Example: "-05:00"
+    def initialize(config = {})
+      super(config)
+
+      @timezone = config[:timezone]
+    end
+
+    # Implements the logic for building a formatted payload with the given template for PTO's.
+    #
+    # <br>
+    # <b>Params:</b>
+    # * <tt>List<Domain::Pto></tt> pto_list: List of mapped PTO's.
+    #
+    # <br>
+    # <b>raises</b> <tt>Formatter::Exceptions::InvalidData</tt> when invalid data is provided.
+    #
+    # <br>
+    # <b>returns</b> <tt>String</tt> payload, formatted payload suitable for a Dispatcher.
+    #
+
+    def format(ptos_list)
+      raise Formatter::Exceptions::InvalidData unless ptos_list.all? { |pto| pto.is_a?(Domain::Pto) }
+
+      ptos_list.reduce("") do |payload, pto|
+        built_template = build_template(Domain::Pto::ATTRIBUTES, pto)
+        payload + format_message_by_case(built_template.gsub("\n", ""), pto)
+      end
+    end
+
+    private
+
+    def format_message_by_case(built_template, pto)
+      date_start = format_timezone(pto.start_date).strftime("%F")
+      date_end = format_timezone(pto.end_date).strftime("%F")
+
+      if date_start == date_end
+        interval = same_day_interval(pto)
+        day_message = today?(date_start) ? "today" : "the day #{date_start}"
+
+        "#{built_template} #{day_message} #{interval}\n"
+      else
+        "#{built_template} from #{date_start} to #{date_end}\n"
+      end
+    end
+
+    def same_day_interval(pto)
+      time_start = format_timezone(pto.start_date).strftime("%I:%M %P")
+      time_end = format_timezone(pto.end_date).strftime("%I:%M %P")
+
+      time_start == time_end ? "all day" : "from #{time_start} to #{time_end}"
+    end
+
+    def format_timezone(date)
+      @timezone.nil? ? Time.new(date) : Time.new(date, in: @timezone)
+    end
+
+    def today?(date)
+      time_now = Time.now.strftime("%F")
+
+      date == format_timezone(time_now).strftime("%F")
+    end
+  end
+end

data/lib/bns/formatter/work_items_limit.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require_relative "../domain/work_items_limit"
+require_relative "./exceptions/invalid_data"
+require_relative "./base"
+
+module Formatter
+  ##
+  # This class implements methods from the Formatter::Base module, tailored to format the
+  # Domain::WorkItemsLimit structure for a dispatcher.
+  class WorkItemsLimit < Base
+    attr_reader :limit
+
+    # Implements the logic for building a formatted payload with the given template for wip limits.
+    #
+    # <br>
+    # <b>Params:</b>
+    # * <tt>List<Domain::WorkItemsLimit></tt> work_items_list: List of mapped work items limits.
+    #
+    # <br>
+    # <b>raises</b> <tt>Formatter::Exceptions::InvalidData</tt> when invalid data is provided.
+    #
+    # <br>
+    # <b>returns</b> <tt>String</tt> payload, formatted payload suitable for a Dispatcher.
+    #
+
+    def format(work_items_list)
+      raise Formatter::Exceptions::InvalidData unless work_items_list.all? do |work_item|
+        work_item.is_a?(Domain::WorkItemsLimit)
+      end
+
+      exceeded_domains(work_items_list).reduce("") do |payload, work_items_limit|
+        payload + build_template(Domain::WorkItemsLimit::ATTRIBUTES, work_items_limit)
+      end
+    end
+
+    private
+
+    def exceeded_domains(work_items_list)
+      work_items_list.filter { |work_item| work_item.total > work_item.wip_limit }
+    end
+  end
+end

data/lib/bns/mapper/notion/{birthday.rb → birthday_today.rb}

@@ -8,9 +8,11 @@ module Mapper
     ##
     # This class implementats the methods of the Mapper::Base module, specifically designed for preparing or
     # shaping birthdays data coming from a Fetcher::Base implementation.
-    class Birthday
+    class BirthdayToday
       include Base
 
+      BIRTHDAY_PARAMS = ["Complete Name", "BD_this_year"].freeze
+
       # Implements the logic for shaping the results from a fetcher response.
       #
       # <br>
@@ -27,7 +29,7 @@ module Mapper
         normalized_notion_data = normalize_response(notion_response.results)
 
         normalized_notion_data.map do |birthday|
-          Domain::Birthday.new(birthday["name"], birthday["birth_date"])
+          Domain::Birthday.new(birthday["Complete Name"], birthday["BD_this_year"])
         end
       end
 
@@ -36,32 +38,22 @@ module Mapper
       def normalize_response(results)
         return [] if results.nil?
 
-        normalized_results = []
-
         results.map do |value|
-          properties = value["properties"]
-          properties.delete("Name")
+          birthday_fields = value["properties"].slice(*BIRTHDAY_PARAMS)
 
-          normalized_value = normalize(properties)
+          birthday_fields.each do |field, birthday_value|
+            birthday_fields[field] = extract_birthday_value(field, birthday_value)
+          end
 
-          normalized_results.append(normalized_value)
+          birthday_fields
         end
-
-        normalized_results
       end
 
-      def normalize(properties)
-        normalized_value = {}
-
-        properties.each do |k, v|
-          if k == "Complete Name"
-            normalized_value["name"] = extract_rich_text_field_value(v)
-          elsif k == "BD_this_year"
-            normalized_value["birth_date"] = extract_date_field_value(v)
-          end
+      def extract_birthday_value(field, value)
+        case field
+        when "Complete Name" then extract_rich_text_field_value(value)
+        when "BD_this_year" then extract_date_field_value(value)
         end
-
-        normalized_value
       end
 
       def extract_rich_text_field_value(data)

data/lib/bns/mapper/notion/{pto.rb → pto_today.rb}

@@ -9,9 +9,11 @@ module Mapper
     # This class implementats the methods of the Mapper::Base module, specifically designed for preparing or
     # shaping PTO's data coming from a Fetcher::Base implementation.
     #
-    class Pto
+    class PtoToday
       include Base
 
+      PTO_PARAMS = ["Person", "Desde?", "Hasta?"].freeze
+
       # Implements the logic for shaping the results from a fetcher response.
       #
       # <br>
@@ -26,8 +28,9 @@ module Mapper
         return [] if notion_response.results.empty?
 
         normalized_notion_data = normalize_response(notion_response.results)
+
         normalized_notion_data.map do |pto|
-          Domain::Pto.new(pto["name"], format_date(pto["start"]), format_date(pto["end"]))
+          Domain::Pto.new(pto["Person"], pto["Desde?"], pto["Hasta?"])
         end
       end
 
@@ -36,39 +39,22 @@ module Mapper
       def normalize_response(response)
         return [] if response.nil?
 
-        normalized_response = []
-
         response.map do |value|
-          properties = value["properties"]
-          properties.delete("Name")
+          pto_fields = value["properties"].slice(*PTO_PARAMS)
 
-          normalized_value = normalize(properties)
+          pto_fields.each do |field, pto_value|
+            pto_fields[field] = extract_pto_value(field, pto_value)
+          end
 
-          normalized_response.append(normalized_value)
+          pto_fields
         end
-
-        normalized_response
       end
 
-      def normalize(properties)
-        normalized_value = {}
-
-        properties.each do |k, v|
-          extract_pto_fields(k, v, normalized_value)
-        end
-
-        normalized_value
-      end
-
-      def extract_pto_fields(key, value, normalized_value)
-        case key
-        when "Person"
-          user_name = extract_person_field_value(value)
-          normalized_value["name"] = user_name
-        when "Desde?"
-          normalized_value["start"] = extract_date_field_value(value)
-        when "Hasta?"
-          normalized_value["end"] = extract_date_field_value(value)
+      def extract_pto_value(field, value)
+        case field
+        when "Person" then extract_person_field_value(value)
+        when "Desde?" then extract_date_field_value(value)
+        when "Hasta?" then extract_date_field_value(value)
         end
       end
 
@@ -79,18 +65,6 @@ module Mapper
       def extract_date_field_value(data)
         data["date"]["start"]
       end
-
-      def format_date(str_date)
-        return "" if str_date.nil?
-
-        if str_date.include?("T")
-          format = "%Y-%m-%d|%I:%M %p"
-          datetime = Time.new(str_date)
-          datetime.strftime(format)
-        else
-          str_date
-        end
-      end
     end
   end
 end

data/lib/bns/mapper/notion/work_items_limit.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require_relative "../../domain/work_items_limit"
+require_relative "../base"
+
+module Mapper
+  module Notion
+    ##
+    # This class implementats the methods of the Mapper::Base module, specifically designed
+    # for preparing or shaping work items data coming from a Fetcher::Base implementation.
+    class WorkItemsLimit
+      include Base
+
+      WORK_ITEM_PARAMS = ["Responsible domain"].freeze
+
+      # Implements the logic for shaping the results from a fetcher response.
+      #
+      # <br>
+      # <b>Params:</b>
+      # * <tt>Fetcher::Notion::Types::Response</tt> notion_response: Notion response object.
+      #
+      # <br>
+      # <b>return</b> <tt>List<Domain::WorkItem></tt> work_items_list, mapped work items to be used by a
+      # Formatter::Base implementation.
+      #
+      def map(notion_response)
+        return [] if notion_response.results.empty?
+
+        normalized_notion_data = normalize_response(notion_response.results)
+
+        domain_items_count = count_domain_items(normalized_notion_data)
+
+        domain_items_count.map do |domain, items_count|
+          Domain::WorkItemsLimit.new(domain, items_count)
+        end
+      end
+
+      private
+
+      def normalize_response(results)
+        return [] if results.nil?
+
+        results.map do |value|
+          work_item_fields = value["properties"].slice(*WORK_ITEM_PARAMS)
+
+          work_item_fields.each do |field, work_item_value|
+            work_item_fields[field] = extract_domain_field_value(work_item_value)
+          end
+
+          work_item_fields
+        end
+      end
+
+      def extract_domain_field_value(data)
+        data["select"]["name"]
+      end
+
+      def count_domain_items(work_items_list)
+        domain_work_items = work_items_list.group_by { |work_item| work_item["Responsible domain"] }
+
+        domain_work_items.transform_values(&:count)
+      end
+    end
+  end
+end

data/lib/bns/mapper/postgres/pto_today.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require_relative "../../domain/pto"
+require_relative "../base"
+
+module Mapper
+  module Postgres
+    ##
+    # This class implementats the methods of the Mapper::Base module, specifically designed for preparing or
+    # shaping PTO's data coming from the Fetcher::Postgres::Pto class.
+    #
+    class PtoToday
+      # Implements the logic for shaping the results from a fetcher response.
+      #
+      # <br>
+      # <b>Params:</b>
+      # * <tt>Fetcher::Postgres::Types::Response</tt> pg_response: Postgres response object.
+      #
+      # <br>
+      # <b>returns</b> <tt>List<Domain::Pto></tt> ptos_list, mapped PTO's to be used by a Formatter::Base
+      # implementation.
+      #
+      def map(pg_response)
+        return [] if pg_response.records.empty?
+
+        ptos = build_map(pg_response)
+
+        ptos.map do |pto|
+          name = pto["name"]
+          start_date = pto["start_date"]
+          end_date = pto["end_date"]
+
+          Domain::Pto.new(name, start_date, end_date)
+        end
+      end
+
+      private
+
+      def build_map(pg_response)
+        fields = pg_response.fields
+        values = pg_response.records
+
+        values.map { |value| Hash[fields.zip(value)] }
+      end
+    end
+  end
+end