pd1_tools 0.43.0

data/lib/avmtrf1/redmine/instance.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require 'avmtrf1/redmine/entities/issue'
+require 'avmtrf1/redmine/entities/issue_status'
+require 'avmtrf1/rest_provider/instance'
+
+module Avmtrf1
+  module Redmine
+    class Instance < ::Avmtrf1::RestProvider::Instance
+      ISSUE_ID_PATTERN = /\Aredmine_(\d+)\z/i.freeze
+
+      class << self
+        def parse_issue_id(issue_id)
+          m = ISSUE_ID_PATTERN.match(issue_id)
+          m ? ::OpenStruct.new(provider_issue_id: m[1]) : nil # rubocop:disable Style/OpenStructUse
+        end
+      end
+
+      def build_service_url(service_url_suffix)
+        "#{root_url}#{service_url_suffix}.json"
+      end
+
+      def issue_get_url_suffix(provider_issue_id)
+        "/issues/#{provider_issue_id}"
+      end
+
+      def issue_status(issue_status_id)
+        issue_statuses.find { |issue_status| issue_status.id == issue_status_id }
+      end
+
+      private
+
+      def issue_statuses
+        request_json('/issue_statuses').response.body_data_or_raise.fetch('issue_statuses')
+          .map do |data|
+          ::Avmtrf1::Redmine::Entities::IssueStatus.new(self, data)
+        end
+      end
+    end
+  end
+end

data/lib/avmtrf1/redmine.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Avmtrf1
+  module Redmine
+    require 'avmtrf1/redmine/entities'
+  end
+end

data/lib/avmtrf1/rest_provider/entity.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/simple_cache'
+
+module Avmtrf1
+  module RestProvider
+    class Entity
+      include ::EacRubyUtils::SimpleCache
+
+      attr_reader :instance, :data
+
+      def initialize(instance, data)
+        @instance = instance
+        @data = data
+      end
+    end
+  end
+end

data/lib/avmtrf1/rest_provider/instance/issues.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Avmtrf1
+  module RestProvider
+    class Instance
+      module Issues
+        def find_issue(global_issue_id)
+          parsed = self.class.parse_issue_id(global_issue_id)
+          parsed.present? ? issue(parsed.provider_issue_id) : nil
+        end
+
+        def issue(provider_issue_id)
+          issue_request(provider_issue_id).response.body_data_or_raise
+        end
+
+        # @return [Avmtrf1::RestProvider::Request]
+        def issue_request(provider_issue_id)
+          request_json(issue_get_url_suffix(provider_issue_id)) do |data|
+            data = issue_class.parse_data(data) if issue_class.respond_to?(:parse_data)
+            data.present? ? issue_class.new(self, data) : nil
+          end
+        end
+
+        def issue_class
+          "#{self.class.name.deconstantize}::Entities::Issue".constantize
+        end
+      end
+    end
+  end
+end

data/lib/avmtrf1/rest_provider/instance.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require 'avmtrf1/rest_provider/request'
+require 'curb'
+require 'eac_ruby_utils/core_ext'
+
+module Avmtrf1
+  module RestProvider
+    # Abstract methods
+    #   * parse_issue_id(global_issue_id)
+    #   * self.build_service_url(service_url_suffix)
+    #   * self.issue_get_url_suffix(provider_issue_id)
+    class Instance
+      require_sub __FILE__, include_modules: true
+      common_constructor :root_url, :username, :password
+
+      def request(service_url_suffix, headers = {}, &body_data_proc)
+        r = Avmtrf1::RestProvider::Request.new(build_service_url(service_url_suffix),
+                                               body_data_proc)
+        headers.each { |name, value| r.header(name, value) }
+        r.autenticate(username, password)
+        r
+      end
+
+      def request_json(service_url_suffix, headers = {}, &body_data_proc)
+        request(service_url_suffix, headers.merge('Accept' => 'application/json'), &body_data_proc)
+      end
+    end
+  end
+end

data/lib/avmtrf1/rest_provider/request.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require 'avmtrf1/rest_provider/response'
+require 'eac_ruby_utils/core_ext'
+require 'ostruct'
+
+module Avmtrf1
+  module RestProvider
+    class Request
+      common_constructor :url, :body_data_proc, default: [nil]
+
+      def autenticate(username, password)
+        self.auth = ::OpenStruct.new(username: username, password: password) # rubocop:disable Style/OpenStructUse
+      end
+
+      def header(name, value)
+        headers[name.to_s] = value
+      end
+
+      def response
+        ::Avmtrf1::RestProvider::Response.new(build_curl, body_data_proc)
+      end
+
+      private
+
+      attr_accessor :auth
+
+      def build_curl
+        r = ::Curl::Easy.new(url)
+        auth.if_present do |a|
+          r.http_auth_types = :basic
+          r.username = a.username
+          r.password = a.password
+        end
+        r.headers.merge!(headers)
+        r
+      end
+
+      def headers
+        @headers ||= {}
+      end
+    end
+  end
+end

data/lib/avmtrf1/rest_provider/response.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/hash/conversions'
+require 'eac_ruby_utils/core_ext'
+require 'json'
+
+module Avmtrf1
+  module RestProvider
+    class Response < ::StandardError
+      common_constructor :curl, :body_data_proc
+
+      def body_data
+        r = performed_curl.headers['Accept'].if_present(body_str) do |v|
+          send("body_data_from_#{v.parameterize.underscore}")
+        end
+        r = body_data_proc.call(r) if body_data_proc.present?
+        r
+      end
+
+      def body_data_or_raise
+        raise_unless_200
+
+        body_data
+      end
+
+      delegate :body_str, to: :performed_curl
+
+      def body_str_or_raise
+        raise_unless_200
+
+        body_str
+      end
+
+      def raise_unless_200 # rubocop:disable Naming/VariableNumber
+        return nil if status == 200
+
+        raise self
+      end
+
+      def status
+        performed_curl.status.to_i
+      end
+
+      delegate :url, to: :curl
+
+      def to_s
+        "URL: #{url}\nStatus: #{status}\nBody:\n\n#{body_str}"
+      end
+
+      private
+
+      def body_data_from_application_json
+        ::JSON.parse(body_str)
+      end
+
+      def body_data_from_application_xml
+        Hash.from_xml(body_str)
+      end
+
+      def perform
+        @perform ||= begin
+          curl.perform || raise("CURL perform failed for #{url}")
+          true
+        end
+      end
+
+      def performed_curl
+        perform
+        curl
+      end
+    end
+  end
+end

data/lib/avmtrf1/rest_provider.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Avmtrf1
+  module RestProvider
+    require 'avmtrf1/rest_provider/instance'
+  end
+end

data/lib/avmtrf1/result.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require 'colorize'
+require 'eac_ruby_utils/listable'
+
+module Avmtrf1
+  class Result
+    include ::EacRubyUtils::Listable
+
+    lists.add_string :type, :success, :error, :neutral
+
+    lists.type.values.each do |type| # rubocop:disable Style/HashEachMethods
+      class_eval <<-RUBY_EVAL, __FILE__, __LINE__ + 1 # rubocop:disable Style/DocumentDynamicEvalDefinition
+        def self.#{type}(output)
+          new(TYPE_#{type.upcase}, output)
+        end
+      RUBY_EVAL
+    end
+
+    TYPE_SUCCESS_COLOR = 'green'
+    TYPE_ERROR_COLOR = 'red'
+    TYPE_NEUTRAL_COLOR = 'white'
+
+    attr_reader :type, :output
+
+    def initialize(type, output)
+      validate_type(type)
+      @type = type
+      @output = output
+    end
+
+    def label
+      output.send(self.class.const_get("type_#{type}_color".upcase))
+    end
+
+    private
+
+    def validate_type(type)
+      return if self.class.lists.type.values.include?(type)
+
+      raise "Tipo desconhecido: \"#{type}\" (Válido: #{self.class.lists.type.values.join(', ')})"
+    end
+  end
+end

data/lib/avmtrf1/ruby.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+
+module Avmtrf1
+  module Ruby
+    require_sub __FILE__
+  end
+end

data/lib/avmtrf1/tools/application.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_base0/application'
+
+module Avmtrf1
+  module Tools
+    class << self
+      def application
+        @application ||= ::EacRubyBase0::Application.new(::File.expand_path('../../..', __dir__))
+      end
+    end
+  end
+end

data/lib/avmtrf1/tools/core_ext.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require 'avm/tools/core_ext'
+require 'avmtrf1/patches'

data/lib/avmtrf1/tools/msgraph/api/entity.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require 'avmtrf1/tools/msgraph/request_mixin'
+require 'eac_rest/entity'
+require 'eac_ruby_utils/core_ext'
+
+module Avmtrf1
+  module Tools
+    module Msgraph
+      class Api < ::EacRest::Api
+        class Entity < ::EacRest::Entity
+          def request_data(url_suffix, &block)
+            req = request_data_request(url_suffix, &block)
+            req.response.body_data_or_raise
+          rescue ::Avmtrf1::Tools::Msgraph::Error => e
+            raise e unless e.invalid_token?
+
+            api.clear_token_info
+            req.response.body_data_or_raise
+          end
+
+          private
+
+          # @return [EacRest::Request]
+          def request_data_request(url_suffix, &block)
+            req = api.request(url_suffix)
+            req = block.call(req) if block
+            req.singleton_class.prepend(::Avmtrf1::Tools::Msgraph::RequestMixin)
+            req
+          end
+        end
+      end
+    end
+  end
+end

data/lib/avmtrf1/tools/msgraph/api/member.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require 'avmtrf1/tools/msgraph/api/entity'
+require 'eac_ruby_utils/core_ext'
+
+module Avmtrf1
+  module Tools
+    module Msgraph
+      class Api < ::EacRest::Api
+        class Member < ::Avmtrf1::Tools::Msgraph::Api::Entity
+          %w[displayName email roles tenantId userId visibleHistoryStartDateTime]
+            .each do |key|
+            define_method key.underscore do
+              data.fetch(key)
+            end
+          end
+
+          # @return [String]
+          def id_from_data
+            data.fetch('id')
+          end
+
+          # @return [String]
+          def type
+            data.fetch('@odata.type')
+          end
+        end
+      end
+    end
+  end
+end

data/lib/avmtrf1/tools/msgraph/api/root.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'avmtrf1/tools/msgraph/api/entity'
+require 'avmtrf1/tools/msgraph/api/team'
+require 'eac_ruby_utils/core_ext'
+
+module Avmtrf1
+  module Tools
+    module Msgraph
+      class Api < ::EacRest::Api
+        class Root < ::Avmtrf1::Tools::Msgraph::Api::Entity
+          # @return [Array<Avmtrf1::Tools::Msgraph::Api::Group>]
+          def joined_teams
+            request_data('/me/joinedTeams').map do |team_data|
+              child_entity(::Avmtrf1::Tools::Msgraph::Api::Team, team_data)
+            end
+          end
+
+          # @return [Avmtrf1::Tools::Msgraph::Api::Team]
+          def team(team_id)
+            child_entity(::Avmtrf1::Tools::Msgraph::Api::Team, team_id)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/avmtrf1/tools/msgraph/api/team/member_add.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require 'avmtrf1/tools/msgraph/api/entity'
+require 'eac_ruby_utils/core_ext'
+
+module Avmtrf1
+  module Tools
+    module Msgraph
+      class Api < ::EacRest::Api
+        class Team < ::Avmtrf1::Tools::Msgraph::Api::Entity
+          class MemberAdd
+            acts_as_instance_method
+
+            common_constructor :team, :user_id
+
+            # @return [Hash]
+            def result
+              team.members_request do |req|
+                req.verb(:post).header('Content-type', 'application/json')
+                  .body_data(body_hash.to_json)
+              end
+            end
+
+            # @return [Hash]
+            def body_hash
+              {
+                '@odata.type' => '#microsoft.graph.aadUserConversationMember',
+                'user@odata.bind' => "https://graph.microsoft.com/v1.0/users('#{user_id}')"
+              }
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/avmtrf1/tools/msgraph/api/team.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require 'avmtrf1/tools/msgraph/api/entity'
+require 'eac_ruby_utils/core_ext'
+
+module Avmtrf1
+  module Tools
+    module Msgraph
+      class Api < ::EacRest::Api
+        class Team < ::Avmtrf1::Tools::Msgraph::Api::Entity
+          %w[classification createdDateTime description discoverySettings displayName funSettings
+             guestSettings internalId isArchived isMembershipLimitedToOwners memberSettings
+             messagingSettings specialization summary tenantId visibility webUrl].each do |key|
+            define_method key.underscore do
+              data.fetch(key)
+            end
+
+            # @return [String]
+            def id_from_data
+              data.fetch('id')
+            end
+
+            def members
+              members_request.map do |member_data|
+                child_entity(::Avmtrf1::Tools::Msgraph::Api::Member, member_data)
+              end
+            end
+
+            # @return [EacRest::Request]
+            def members_request(&block)
+              request_data("/teams/#{id}/members", &block)
+            end
+
+            require_sub __FILE__, require_mode: :kernel
+          end
+        end
+      end
+    end
+  end
+end

data/lib/avmtrf1/tools/msgraph/api.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require 'eac_rest/api'
+require 'eac_ruby_utils/core_ext'
+
+module Avmtrf1
+  module Tools
+    module Msgraph
+      class Api < ::EacRest::Api
+        API_ROOT_URL = 'https://graph.microsoft.com/v1.0'
+
+        enable_simple_cache
+        common_constructor :client_id, super_args: -> { [API_ROOT_URL] }
+
+        # @return [String]
+        def access_token
+          token_info.fetch(:token).fetch(:accessToken)
+        end
+
+        # @return [void]
+        def clear_token_info
+          token_info_cache.clear
+          reset_cache(:token_info)
+        end
+
+        # @return [EacRest::Request]
+        def request(service_url_suffix, headers = {}, &body_data_proc)
+          super
+            .header('Authorization', "Bearer #{access_token}")
+        end
+
+        def fs_object_id
+          client_id.to_s.variableize
+        end
+
+        private
+
+        # @return [EacFs::StorageTree]
+        def token_info_cache
+          fs_cache.child('token')
+        end
+
+        def token_info_uncached
+          token_info_cache.read_or_store_yaml { new_token_info }
+        end
+
+        def new_token_info
+          ::Avmtrf1::Tools::Msgraph::TokenRetrieve.new(client_id).result
+        end
+
+        require_sub __FILE__
+      end
+    end
+  end
+end

data/lib/avmtrf1/tools/msgraph/error.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require 'eac_rest/error'
+require 'eac_ruby_utils/core_ext'
+
+module Avmtrf1
+  module Tools
+    module Msgraph
+      class Error < ::EacRest::Error
+        INVALID_TOKEN_CODE = 'InvalidAuthenticationToken'
+
+        attr_reader :data
+
+        def initialize(data)
+          @data = data
+          super(data.pretty_inspect)
+        end
+
+        # @return [String]
+        def code
+          data.fetch('code')
+        end
+
+        # @return [Boolean]
+        def invalid_token?
+          code == INVALID_TOKEN_CODE
+        end
+      end
+    end
+  end
+end

data/lib/avmtrf1/tools/msgraph/request_mixin.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require 'avmtrf1/tools/msgraph/response_mixin'
+require 'eac_ruby_utils/core_ext'
+
+module Avmtrf1
+  module Tools
+    module Msgraph
+      module RequestMixin
+        def response
+          r = super
+          r.singleton_class.prepend(::Avmtrf1::Tools::Msgraph::ResponseMixin)
+          r
+        end
+      end
+    end
+  end
+end

data/lib/avmtrf1/tools/msgraph/response_mixin.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require 'eac_rest/response'
+require 'avmtrf1/tools/msgraph/error'
+require 'eac_ruby_utils/core_ext'
+
+module Avmtrf1
+  module Tools
+    module Msgraph
+      module ResponseMixin
+        ERROR_KEY = 'error'
+        VALUE_KEY = 'value'
+
+        def body_data_or_raise
+          r = super
+          r.is_a?(::Hash) && r.key?(VALUE_KEY) ? r.fetch(VALUE_KEY) : r
+        rescue ::EacRest::Response => e
+          raise ::Avmtrf1::Tools::Msgraph::Error, e.body_data.fetch(ERROR_KEY)
+        end
+      end
+    end
+  end
+end

data/lib/avmtrf1/tools/msgraph/token_retrieve.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require 'eac_rest/api'
+require 'eac_ruby_utils/core_ext'
+require 'eac_ruby_utils/fs/temp'
+require 'eac_templates/sources/from_all_gems'
+
+module Avmtrf1
+  module Tools
+    module Msgraph
+      class TokenRetrieve
+        enable_simple_cache
+        common_constructor :client_id
+
+        private
+
+        def python_retrieve_command(file)
+          ::EacRubyUtils::Envs.local.command(python_retrieve_program_path, client_id, file)
+        end
+
+        # @return [Hash]
+        def result_uncached
+          ::EacRubyUtils::Yaml.load(result_string)
+        end
+
+        # @return [String]
+        def result_string
+          ::EacRubyUtils::Fs::Temp.on_file do |file|
+            raise result.pretty_inspect.to_s unless python_retrieve_command(file.to_path)
+                                                      .system
+
+            file.read
+          end
+        end
+
+        def python_retrieve_program_path
+          template.child('python_retriever.py').path
+        end
+      end
+    end
+  end
+end