bas 0.1.0

data/lib/bas/mapper/base.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative "../domain/exceptions/function_not_implemented"
+
+module Mapper
+  ##
+  # The Mapper::Base module serves as the foundation for implementing specific data shaping logic within the
+  # Mapper module. Defines essential methods, that provide a blueprint for organizing or shaping data in a manner
+  # suitable for downstream formatting processes.
+  #
+  module Base
+    # An method meant to prepare or organize the data coming from an implementation of the Fetcher::Base interface.
+    # Must be overridden by subclasses, with specific logic based on the use case.
+    #
+    # <br>
+    # <b>Params:</b>
+    # * <tt>Fetcher::Notion::Types::Response</tt> response: Response produced by a fetcher.
+    #
+    # <br>
+    #
+    # <b>raises</b> <tt>Domain::Exceptions::FunctionNotImplemented</tt> when missing implementation.
+    # <br>
+    #
+    # <b>returns</b> <tt>List<Domain::></tt> Mapped list of data, ready to be formatted.
+    #
+    def map(_response)
+      raise Domain::Exceptions::FunctionNotImplemented
+    end
+  end
+end

data/lib/bas/mapper/imap/support_emails.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require_relative "../../domain/email"
+require_relative "../base"
+
+module Mapper
+  module Imap
+    ##
+    # This class implementats the methods of the Mapper::Base module, specifically designed for
+    # preparing or shaping support emails data coming from a Fetcher::Base implementation.
+    class SupportEmails
+      include Base
+
+      # Implements the logic for shaping the results from a fetcher response.
+      #
+      # <br>
+      # <b>Params:</b>
+      # * <tt>Fetcher::Imap::Types::Response</tt> imap_response: Array of imap emails data.
+      #
+      # <br>
+      # <b>return</b> <tt>List<Domain::Email></tt> support_emails_list, mapped support emails to be used by a
+      # Formatter::Base implementation.
+      #
+      def map(imap_response)
+        return [] if imap_response.results.empty?
+
+        normalized_email_data = normalize_response(imap_response.results)
+
+        normalized_email_data.map do |email|
+          Domain::Email.new(email["subject"], email["sender"], email["date"])
+        end
+      end
+
+      private
+
+      def normalize_response(results)
+        return [] if results.nil?
+
+        results.map do |value|
+          {
+            "sender" => extract_sender(value),
+            "date" => value.date,
+            "subject" => value.subject
+          }
+        end
+      end
+
+      def extract_sender(value)
+        mailbox = value.sender[0]["mailbox"]
+        host = value.sender[0]["host"]
+
+        "#{mailbox}@#{host}"
+      end
+    end
+  end
+end

data/lib/bas/mapper/notion/birthday_today.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require_relative "../../domain/birthday"
+require_relative "../base"
+
+module Mapper
+  module Notion
+    ##
+    # 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 BirthdayToday
+      include Base
+
+      BIRTHDAY_PARAMS = ["Complete Name", "BD_this_year"].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::Birthday></tt> birthdays_list, mapped birthdays 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)
+
+        normalized_notion_data.map do |birthday|
+          Domain::Birthday.new(birthday["Complete Name"], birthday["BD_this_year"])
+        end
+      end
+
+      private
+
+      def normalize_response(results)
+        return [] if results.nil?
+
+        results.map do |value|
+          birthday_fields = value["properties"].slice(*BIRTHDAY_PARAMS)
+
+          birthday_fields.each do |field, birthday_value|
+            birthday_fields[field] = extract_birthday_value(field, birthday_value)
+          end
+
+          birthday_fields
+        end
+      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
+      end
+
+      def extract_rich_text_field_value(data)
+        data["rich_text"][0]["plain_text"]
+      end
+
+      def extract_date_field_value(data)
+        data["formula"]["date"]["start"]
+      end
+    end
+  end
+end

data/lib/bas/mapper/notion/pto_today.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require_relative "../../domain/pto"
+require_relative "../base"
+
+module Mapper
+  module Notion
+    ##
+    # 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 PtoToday
+      include Base
+
+      PTO_PARAMS = ["Person", "Desde?", "Hasta?"].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>returns</b> <tt>List<Domain::Pto></tt> ptos_list, mapped PTO's 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)
+
+        normalized_notion_data.map do |pto|
+          Domain::Pto.new(pto["Person"], pto["Desde?"], pto["Hasta?"])
+        end
+      end
+
+      private
+
+      def normalize_response(response)
+        return [] if response.nil?
+
+        response.map do |value|
+          pto_fields = value["properties"].slice(*PTO_PARAMS)
+
+          pto_fields.each do |field, pto_value|
+            pto_fields[field] = extract_pto_value(field, pto_value)
+          end
+
+          pto_fields
+        end
+      end
+
+      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
+
+      def extract_person_field_value(data)
+        data["people"][0]["name"]
+      end
+
+      def extract_date_field_value(data)
+        data["date"]["start"]
+      end
+    end
+  end
+end

data/lib/bas/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/bas/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

data/lib/bas/use_cases/types/config.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module UseCases
+  module Types
+    ##
+    # Represents a the configuration composing the initial components required by a UseCases::UseCase implementation.
+    #
+    class Config
+      attr_reader :fetcher, :mapper, :formatter, :dispatcher
+
+      def initialize(fetcher, mapper, formatter, dispatcher)
+        @fetcher = fetcher
+        @mapper = mapper
+        @formatter = formatter
+        @dispatcher = dispatcher
+      end
+    end
+  end
+end

data/lib/bas/use_cases/use_case.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module UseCases
+  ##
+  # The UseCases::UseCase class represents a generic structure for use cases within the system. It encapsulates the
+  # logic flow by coordinating the execution of its components to fulfill a specific use case.
+  #
+  class UseCase
+    attr_reader :fetcher, :mapper, :formatter, :dispatcher
+
+    # Initializes the use case with the necessary components.
+    #
+    # <br>
+    # <b>Params:</b>
+    # * <tt>Usecases::Types::Config</tt> config, The components required to instantiate a use case.
+    #
+    def initialize(config)
+      @fetcher = config.fetcher
+      @mapper = config.mapper
+      @formatter = config.formatter
+      @dispatcher = config.dispatcher
+    end
+
+    # Executes the use case by orchestrating the sequential execution of the fetcher, mapper, formatter, and dispatcher.
+    #
+    # <br>
+    # <b>returns</b> <tt>Dispatcher::Discord::Types::Response</tt>
+    #
+    def perform
+      response = fetcher.fetch
+
+      mappings = mapper.map(response)
+
+      formatted_payload = formatter.format(mappings)
+
+      dispatcher.dispatch(formatted_payload)
+    end
+  end
+end