ccli 0.1.0

data/lib/errors.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+class Error < StandardError
+end
+
+class SessionMissingError < Error
+end
+
+class UnauthorizedError < Error
+end
+
+class ForbiddenError < Error
+end
+
+class OpenshiftClientMissingError < Error
+end
+
+class OpenshiftClientNotLoggedInError < Error
+end
+
+class KubernetesClientMissingError < Error
+end
+
+class KubernetesClientNotLoggedInError < Error
+end
+
+class OpenshiftSecretNotFoundError < Error
+end
+
+class NoFolderSelectedError < Error
+end
+
+class CryptopusAccountNotFoundError < Error
+end
+
+class TeamNotFoundError < Error
+end
+
+class FolderNotFoundError < Error
+end

data/lib/models/account.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+class Account
+  attr_reader :id, :accountname, :username, :password, :type, :ose_secret
+  attr_accessor :folder
+
+  def initialize(accountname: nil, username: nil, password: nil,
+                 ose_secret: nil, type: nil, id: nil)
+    @id = id
+    @accountname = accountname
+    @username = username
+    @password = password
+    @ose_secret = ose_secret
+    @type = type || 'credentials'
+  end
+
+  def to_json(*_args)
+    AccountSerializer.to_json(self)
+  end
+
+  def to_yaml
+    AccountSerializer.to_yaml(self)
+  end
+
+  def to_osesecret
+    AccountSerializer.to_osesecret(self)
+  end
+
+  class << self
+    def find(id)
+      AccountSerializer.from_json(CryptopusAdapter.new.get("accounts/#{id}"))
+    end
+
+    def find_by_name_and_folder_id(name, id)
+      Folder.find(id).accounts.find do |account|
+        account.accountname.downcase == name.downcase
+      end
+    end
+
+    def from_json(json)
+      AccountSerializer.from_json(json)
+    end
+  end
+end

data/lib/models/folder.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+class Folder
+  attr_reader :name, :id, :accounts
+
+  def initialize(name: nil, id: nil, accounts: [])
+    @name = name
+    @id = id
+    @accounts = accounts
+  end
+
+  class << self
+    def find(id)
+      json = JSON.parse(CryptopusAdapter.new.get("folders/#{id}"),
+                        symbolize_names: true)
+      included = json[:included] || []
+      name = json[:data][:attributes][:name]
+      accounts = included.map do |record|
+        Account.from_json(record.to_json) if %w[account_ose_secrets
+                                                account_credentials].include? record[:type]
+      end.compact
+      Folder.new(id: id, name: name, accounts: accounts)
+    end
+  end
+end

data/lib/models/k8s_secret.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require_relative './ose_secret'
+
+class K8SSecret < OSESecret
+  class << self
+    def all
+      K8SAdapter.new.fetch_all_secrets.map { |s| OSESecretSerializer.from_yaml(s) }
+    end
+  end
+end

data/lib/models/ose_secret.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+class OSESecret
+  attr_reader :name, :ose_secret
+
+  def initialize(name, ose_secret)
+    @name = name
+    @ose_secret = ose_secret
+  end
+
+  def to_account
+    OSESecretSerializer.to_account(self)
+  end
+
+  def to_yaml
+    OSESecretSerializer.to_yaml(self)
+  end
+
+  class << self
+    def find_by_name(name)
+      OSESecretSerializer.from_yaml(OSEAdapter.new.fetch_secret(name))
+    end
+
+    def all
+      OSEAdapter.new.fetch_all_secrets.map { |s| OSESecretSerializer.from_yaml(s) }
+    end
+  end
+end

data/lib/models/team.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+class Team
+  attr_reader :name, :id, :folders
+
+  def initialize(name: nil, folders: nil, id: nil)
+    @name = name
+    @folders = folders
+    @id = id
+  end
+
+  def render_list
+    TeamPresenter.render_list(self)
+  end
+
+  def folder_by_name(name)
+    folders.find do |folder|
+      folder.name.downcase.gsub(' ', '-') == name.downcase
+    end
+  end
+
+  class << self
+    def all
+      cryptopus_adapter = CryptopusAdapter.new
+      response = JSON.parse(cryptopus_adapter.get('teams'), symbolize_names: true)
+      response[:data].map do |team|
+        TeamSerializer.from_json(team.to_json, folders_json: included_folders(response))
+      end
+    end
+
+    def find_by_name(name)
+      Team.all.find do |team|
+        team.name.downcase.gsub(' ', '-') == name.downcase
+      end
+    end
+
+    private
+
+    def included_folders(json)
+      json[:included].select do |folder|
+        folder[:type] == 'folders'
+      end
+    end
+  end
+end

data/lib/presenters/team_presenter.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+class TeamPresenter
+  class << self
+    def render_list(team)
+      team_name = team.name.downcase
+      despaced_team_name = team_name.gsub(' ', '-')
+      folder_rows = team.folders.map do |folder|
+        folder_name = folder.name.downcase
+        "#{folder_name} (cry use #{despaced_team_name}/#{folder_name.gsub(' ', '-')})"
+      end
+
+      team_name = "#{team_name} => "
+      joined_folder_rows = folder_rows.join("\n" + ' ' * team_name.length)
+      team_name + joined_folder_rows
+    end
+  end
+end

data/lib/serializers/account_serializer.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require 'yaml'
+
+class AccountSerializer
+  class << self
+    # rubocop:disable Metrics/MethodLength
+    def to_json(account)
+      {
+        data: {
+          type: 'accounts',
+          id: account.id,
+          attributes: {
+            accountname: account.accountname,
+            type: account.type,
+            cleartext_username: account.username,
+            cleartext_password: account.password,
+            ose_secret: account.ose_secret
+          },
+          relationships: {
+            folder: {
+              data: {
+                id: account.folder,
+                type: 'folders'
+              }
+            }
+          }
+        }
+      }.compact.to_json
+    end
+    # rubocop:enable Metrics/MethodLength
+
+    def to_yaml(account)
+      { 'id' => account.id,
+        'accountname' => account.accountname,
+        'username' => account.username,
+        'password' => account.password,
+        'type' => account.type }.to_yaml
+    end
+
+    def from_json(json)
+      json = JSON.parse(json, symbolize_names: true)
+      data = json[:data] || json
+      attributes = data[:attributes]
+      Account.new(accountname: attributes[:accountname],
+                  username: attributes[:cleartext_username],
+                  password: attributes[:cleartext_password],
+                  ose_secret: attributes[:ose_secret],
+                  type: attributes[:type],
+                  id: data[:id])
+    end
+
+    def to_osesecret(account)
+      OSESecret.new(account.accountname, account.ose_secret)
+    end
+  end
+end

data/lib/serializers/folder_serializer.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+class FolderSerializer
+  class << self
+    def from_json(json)
+      json = JSON.parse(json, symbolize_names: true)
+      data = json[:data] || json
+      attributes = data[:attributes]
+      Folder.new(name: attributes[:name], id: data[:id])
+    end
+  end
+end

data/lib/serializers/ose_secret_serializer.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require 'psych'
+
+class OSESecretSerializer
+  class << self
+    def from_yaml(yaml)
+      secret_hash = Psych.load(yaml, symbolize_names: true)
+      OSESecret.new(secret_hash.dig(:metadata, :name), yaml)
+    end
+
+    def to_account(secret)
+      Account.new(accountname: secret.name, ose_secret: secret.ose_secret, type: 'ose_secret')
+    end
+  end
+end

data/lib/serializers/team_serializer.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+class TeamSerializer
+  class << self
+    def from_json(json, folders_json: [])
+      json = JSON.parse(json, symbolize_names: true)
+      data = json[:data] || json
+      attributes = data[:attributes]
+      folder_ids = data[:relationships][:folders][:data].map { |folder| folder[:id] }
+      folders = folders_json.map do |folder|
+        FolderSerializer.from_json(folder.to_json) if folder_ids.include?(folder[:id])
+      end.compact
+      Team.new(name: attributes[:name],
+               folders: folders,
+               id: data[:id])
+    end
+  end
+end

metadata

@@ -0,0 +1,129 @@
+--- !ruby/object:Gem::Specification
+name: ccli
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Nils Rauch
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2020-10-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: commander
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.5'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.5.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.5'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.5.2
+- !ruby/object:Gem::Dependency
+  name: tty-command
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: tty-exit
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: tty-logger
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 
+email: rauch@puzzle.ch
+executables:
+- cry
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rubocop.yml"
+- ".travis.yml"
+- Gemfile
+- Gemfile.lock
+- README.md
+- bin/cry
+- ccli.gemspec
+- lib/adapters/cluster_secret_adapter.rb
+- lib/adapters/cryptopus_adapter.rb
+- lib/adapters/k8s_adapter.rb
+- lib/adapters/ose_adapter.rb
+- lib/adapters/session_adapter.rb
+- lib/cli.rb
+- lib/errors.rb
+- lib/models/account.rb
+- lib/models/folder.rb
+- lib/models/k8s_secret.rb
+- lib/models/ose_secret.rb
+- lib/models/team.rb
+- lib/presenters/team_presenter.rb
+- lib/serializers/account_serializer.rb
+- lib/serializers/folder_serializer.rb
+- lib/serializers/ose_secret_serializer.rb
+- lib/serializers/team_serializer.rb
+homepage: 
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.9
+signing_key: 
+specification_version: 4
+summary: Command line client for the opensource password manager Cryptopus
+test_files: []