ama-team / cookbook-linux-user-management

require_relative '../mixin/entity'

require_relative 'policy'

require_relative 'public_key'

require_relative 'private_key'

require_relative 'privilege'

module AMA

  module Chef

    module User

      module Model

        # Depicts linux user account

        #

        # Private and public keys are stored in { owner => { owner keys } }

        # structure (grouped by effective owner).

        #

        # @!attribute id

        #   @return [Symbol]

        # @!attribute privileges

        #   @return [Hash{Symbol, Privilege}]

        # @!attribute public_keys

        #   @return [Hash{Symbol, Hash{Symbol, PublicKey}}]

        # @!attribute private_keys

        #   @return [Hash{Symbol, Hash{Symbol, PrivateKey}]

        # @!attribute policy

        #   @return [Symbol] :edit or :manage

        class Account

          include Mixin::Entity

          # rubocop:disable Metrics/LineLength

          attribute :id, Symbol

          attribute :privileges, [Hash, K: Symbol, V: Privilege], default: {}

          attribute :public_keys, [Hash, K: Symbol, V: [Hash, K: Symbol, V: PublicKey]], default: {}

          attribute :private_keys, [Hash, K: Symbol, V: [Hash, K: Symbol, V: PrivateKey]], default: {}

          attribute :policy, Policy, default: Policy::NONE

          # rubocop:enable Metrics/LineLength

          denormalizer_block do |input, type, context, &block|

            if input.is_a?(Hash) && [:id, 'id'].none? { |key| input.key?(key) }

              input[:id] = context.path.current.name

            end

            block.call(input, type, context)

          end

          def policy=(policy)

            @policy = Policy.wrap(policy)

          end

          def public_keys!(client_id)

            public_keys[client_id] = {} unless public_keys.key?(client_id)

            public_keys[client_id]

          end

          def private_keys!(client_id)

            private_keys[client_id] = {} unless private_keys.key?(client_id)

            private_keys[client_id]

          end

          # rubocop:disable Metrics/AbcSize

          # @param [Account] other

          def merge(other)

            other.privileges.each do |type, privilege|

              privileges[type] = privilege unless privileges[type]

              privileges[type].options.merge!(privilege.options)

            end

            other.public_keys.each do |owner, keys|

              public_keys!(owner).merge!(keys)

            end

            other.private_keys.each do |owner, keys|

              private_keys!(owner).merge!(keys)

            end

            self.policy = [policy, other.policy].max

            self

          end

          # rubocop:enable Metrics/AbcSize

          def to_s

            "Account :#{id} { policy: :#{policy} }"

          end

        end

      end

    end

  end

end