sem 0.1.1

data/lib/sem/api/users_with_permissions.rb

@@ -0,0 +1,53 @@
+module Sem
+  module API
+    class UsersWithPermissions < Base
+      class << self
+        LEVELS = { "owner" => 3, "admin" => 2, "write" => 1, "read" => 0 }.freeze
+
+        def list_owners_for_org(org_name)
+          Sem::API::Orgs.list_owners(org_name).map { |user| user.merge(:permission => "owner") }
+        end
+
+        def list_admins_for_org(org_name)
+          Sem::API::Orgs.list_admins(org_name).map { |user| user.merge(:permission => "admin") }
+        end
+
+        def list_for_org(org_name)
+          all_teams = client.teams.list_for_org(org_name)
+
+          team_groups = teams_by_permission(all_teams)
+
+          user_groups = users_for_team_groups(team_groups)
+
+          user_groups.reduce({}) { |acc, teams| acc.merge(teams) }.values
+        end
+
+        private
+
+        def teams_by_permission(all_teams)
+          groups = all_teams.group_by(&:permission)
+
+          groups.sort_by { |permission, _| LEVELS[permission] }.to_h.values
+        end
+
+        def users_for_team_groups(groups)
+          groups.map { |teams| users_for_teams(teams) }.flatten
+        end
+
+        def users_for_teams(teams)
+          teams.map { |team| users_for_team(team) }.flatten.uniq
+        end
+
+        def users_for_team(team)
+          users = client.users.list_for_team(team.id)
+
+          users.map { |user| [user.username, transform_user(user, team)] }.to_h
+        end
+
+        def transform_user(user, team)
+          Users.to_hash(user).merge(:permission => team.permission)
+        end
+      end
+    end
+  end
+end

data/lib/sem/cli.rb

@@ -0,0 +1,20 @@
+module Sem
+  class CLI < Dracula
+    program_name "sem"
+
+    require_relative "cli/orgs"
+    require_relative "cli/projects"
+    require_relative "cli/teams"
+    require_relative "cli/shared_configs"
+
+    desc "login", "log in to semaphore from the command line"
+    def login
+      puts "NOT IMPLEMENTED"
+    end
+
+    register "orgs", "manage organizations", Sem::CLI::Orgs
+    register "teams", "manage teams and team membership", Sem::CLI::Teams
+    register "shared-configs", "manage shared configurations", Sem::CLI::SharedConfigs
+    register "projects", "manage projects", Sem::CLI::Projects
+  end
+end

data/lib/sem/cli/orgs.rb

@@ -0,0 +1,45 @@
+class Sem::CLI::Orgs < Dracula
+
+  desc "list", "list organizations"
+  def list
+    orgs = Sem::API::Orgs.list
+
+    Sem::Views::Orgs.list(orgs)
+  end
+
+  desc "info", "shows detailed information about an organization"
+  def info(org_name)
+    org = Sem::API::Orgs.info(org_name)
+
+    Sem::Views::Orgs.info(org)
+  end
+
+  desc "members", "list members of an organization"
+  option :with_2fa,
+         :default => false,
+         :type => :boolean,
+         :desc => "list members that have two factor authentication enabled"
+  option :admins,
+         :default => false,
+         :type => :boolean,
+         :desc => "list only admins in the organization"
+  option :owners,
+         :default => false,
+         :type => :boolean,
+         :desc => "list only owners in the organization"
+  def members(org_name)
+    raise "Not Implemented" if options[:with_2fa]
+
+    users =
+      if options[:owners]
+        Sem::API::UsersWithPermissions.list_owners_for_org(org_name)
+      elsif options[:admins]
+        Sem::API::UsersWithPermissions.list_admins_for_org(org_name)
+      else
+        Sem::API::UsersWithPermissions.list_for_org(org_name)
+      end
+
+    Sem::Views::UsersWithPermissions.list(users)
+  end
+
+end

data/lib/sem/cli/projects.rb

@@ -0,0 +1,17 @@
+class Sem::CLI::Projects < Dracula
+
+  desc "list", "list projects"
+  def list
+    projects = Sem::API::Projects.list
+
+    Sem::Views::Projects.list(projects)
+  end
+
+  desc "info", "shows detailed information about a project"
+  def info(project_path)
+    project = Sem::API::Projects.info(project_path)
+
+    Sem::Views::Projects.info(project)
+  end
+
+end

data/lib/sem/cli/shared_configs.rb

@@ -0,0 +1,97 @@
+class Sem::CLI::SharedConfigs < Dracula
+
+  desc "list", "list shared cofigurations"
+  def list
+    shared_configs = Sem::API::SharedConfigs.list
+
+    Sem::Views::SharedConfigs.list(shared_configs)
+  end
+
+  desc "info", "show information about a shared configuration"
+  def info(path)
+    shared_config = Sem::API::SharedConfigs.info(path)
+
+    Sem::Views::SharedConfigs.info(shared_config)
+  end
+
+  desc "create", "create a new shared configuration"
+  def create(path)
+    org_name, shared_config_name = path.split("/")
+
+    shared_config = Sem::API::SharedConfigs.create(org_name, :name => shared_config_name)
+
+    Sem::Views::SharedConfigs.info(shared_config)
+  end
+
+  desc "rename", "rename a shared configuration"
+  def rename(old_path, new_path)
+    _, name = new_path.split("/")
+
+    shared_config = Sem::API::SharedConfigs.update(old_path, :name => name)
+
+    Sem::Views::SharedConfigs.info(shared_config)
+  end
+
+  desc "delete", "removes a shared configuration from your organization"
+  def delete(path)
+    Sem::API::SharedConfigs.delete(path)
+
+    puts "Deleted shared configuration #{path}"
+  end
+
+  class Files < Dracula
+    desc "list", "list files in the shared configuration"
+    def list(shared_config_path)
+      files = Sem::API::SharedConfigs.list_files(shared_config_path)
+
+      Sem::Views::Files.list(files)
+    end
+
+    desc "add", "add a file to the shared configuration"
+    option :file, :aliases => "f", :desc => "File to upload", :required => true
+    def add(shared_config_path, file_name)
+      content = File.read(options[:file])
+
+      Sem::API::Files.add_to_shared_config(shared_config_path, :path => file_name, :content => content)
+
+      puts "Added #{file_name} to #{shared_config_path}"
+    end
+
+    desc "remove", "remove a file from the shared configuration"
+    def remove(shared_config_path, file_name)
+      Sem::API::Files.remove_from_shared_config(shared_config_path, file_name)
+
+      puts "Removed #{file_name} from #{shared_config_path}"
+    end
+  end
+
+  class EnvVars < Dracula
+    desc "list", "list environment variables in the shared configuration"
+    def list(shared_config_path)
+      env_vars = Sem::API::SharedConfigs.list_env_vars(shared_config_path)
+
+      Sem::Views::EnvVars.list(env_vars)
+    end
+
+    desc "add", "add an environment variable to the shared configuration"
+    option :name, :aliases => "-n", :desc => "Name of the variable", :required => true
+    option :content, :aliases => "-c", :desc => "Content of the variable", :required => true
+    def add(shared_config_path)
+      Sem::API::EnvVars.add_to_shared_config(shared_config_path,
+                                             :name => options[:name],
+                                             :content => options[:content])
+
+      puts "Added #{options[:name]} to #{shared_config_path}"
+    end
+
+    desc "remove", "remove an environment variable from the shared configuration"
+    def remove(shared_config_path, env_var_name)
+      Sem::API::EnvVars.remove_from_shared_config(shared_config_path, env_var_name)
+
+      puts "Removed #{env_var_name} from #{shared_config_path}"
+    end
+  end
+
+  register "files", "manage files", Files
+  register "env-vars", "manage environment variables", EnvVars
+end

data/lib/sem/cli/teams.rb

@@ -0,0 +1,126 @@
+class Sem::CLI::Teams < Dracula
+
+  desc "list", "list teams"
+  def list
+    teams = Sem::API::Teams.list
+
+    Sem::Views::Teams.list(teams)
+  end
+
+  desc "info", "show information about a team"
+  def info(name)
+    team = Sem::API::Teams.info(name)
+
+    Sem::Views::Teams.info(team)
+  end
+
+  desc "create", "create a new team"
+  option :permission, :default => "read",
+                      :aliases => "-p",
+                      :desc => "Permission level of the team in the organization"
+  def create(name)
+    org_name, team_name = name.split("/")
+
+    team = Sem::API::Teams.create(org_name,
+                                  :name => team_name,
+                                  :permission => options[:permission])
+
+    Sem::Views::Teams.info(team)
+  end
+
+  desc "rename", "change the name of the team"
+  def rename(old_name, new_name)
+    _, name = new_name.split("/")
+
+    team = Sem::API::Teams.update(old_name, :name => name)
+
+    Sem::Views::Teams.info(team)
+  end
+
+  desc "set-permission", "set the permission level of the team"
+  def set_permission(team_name, permission)
+    team = Sem::API::Teams.update(team_name, :permission => permission)
+
+    Sem::Views::Teams.info(team)
+  end
+
+  desc "delete", "removes a team from your organization"
+  def delete(name)
+    Sem::API::Teams.delete(name)
+
+    puts "Deleted team #{name}"
+  end
+
+  class Members < Dracula
+    desc "list", "lists members of the team"
+    def list(team_name)
+      members = Sem::API::Users.list_for_team(team_name)
+
+      Sem::Views::Users.list(members)
+    end
+
+    desc "add", "add a user to the team"
+    def add(team_name, username)
+      Sem::API::Users.add_to_team(team_name, username)
+
+      puts "User #{username} added to the team."
+    end
+
+    desc "remove", "removes a user from the team"
+    def remove(team_name, username)
+      Sem::API::Users.remove_from_team(team_name, username)
+
+      puts "User #{username} removed from the team."
+    end
+  end
+
+  class Projects < Dracula
+    desc "list", "lists projects in a team"
+    def list(team_name)
+      projects = Sem::API::Projects.list_for_team(team_name)
+
+      Sem::Views::Projects.list(projects)
+    end
+
+    desc "add", "add a project to a team"
+    def add(team_name, project_name)
+      Sem::API::Projects.add_to_team(team_name, project_name)
+
+      puts "Project #{project_name} added to the team."
+    end
+
+    desc "remove", "removes a project from the team"
+    def remove(team_name, project_name)
+      Sem::API::Projects.remove_from_team(team_name, project_name)
+
+      puts "Project #{project_name} removed from the team."
+    end
+  end
+
+  class SharedConfigs < Dracula
+    desc "list", "list shared configurations in a team"
+    def list(team_name)
+      configs = Sem::API::SharedConfigs.list_for_team(team_name)
+
+      Sem::Views::SharedConfigs.list(configs)
+    end
+
+    desc "add", "add a shared configuration to a team"
+    def add(team_name, shared_config_name)
+      Sem::API::SharedConfigs.add_to_team(team_name, shared_config_name)
+
+      puts "Shared Configuration #{shared_config_name} added to the team."
+    end
+
+    desc "remove", "removes a project from the team"
+    def remove(team_name, shared_config_name)
+      Sem::API::SharedConfigs.remove_from_team(team_name, shared_config_name)
+
+      puts "Shared Configuration #{shared_config_name} removed from the team."
+    end
+  end
+
+  register "members", "manage team members", Members
+  register "projects", "manage team members", Projects
+  register "shared-configs", "manage shared configurations", SharedConfigs
+end

data/lib/sem/errors.rb

@@ -0,0 +1,8 @@
+module Sem::Errors
+  Base = Class.new(StandardError)
+
+  module Auth
+    NoCredentials = Class.new(Sem::Errors::Base)
+    InvalidCredentials = Class.new(Sem::Errors::Base)
+  end
+end

data/lib/sem/version.rb

@@ -0,0 +1,3 @@
+module Sem
+  VERSION = "0.1.1".freeze
+end

data/lib/sem/views.rb

@@ -0,0 +1,7 @@
+module Sem
+  class Views
+    require_relative "views/base"
+
+    Dir["lib/sem/views/**/*.rb"].each { |f| require_relative f.gsub(%r{^lib/sem/}, "") }
+  end
+end

data/lib/sem/views/base.rb

@@ -0,0 +1,7 @@
+class Sem::Views::Base
+
+  def self.print_table(table)
+    Dracula::UI.print_table(table)
+  end
+
+end

data/lib/sem/views/env_vars.rb

@@ -0,0 +1,13 @@
+class Sem::Views::EnvVars < Sem::Views::Base
+
+  def self.list(env_vars)
+    header = ["ID", "NAME", "ENCRYPTED?", "CONTENT"]
+
+    body = env_vars.map do |env_var|
+      [env_var[:id], env_var[:name], env_var[:encrypted?], env_var[:content]]
+    end
+
+    print_table([header, *body])
+  end
+
+end

data/lib/sem/views/files.rb

@@ -0,0 +1,13 @@
+class Sem::Views::Files < Sem::Views::Base
+
+  def self.list(files)
+    header = ["ID", "NAME", "ENCRYPTED?"]
+
+    body = files.map do |file|
+      [file[:id], file[:name], file[:encrypted?]]
+    end
+
+    print_table([header, *body])
+  end
+
+end

data/lib/sem/views/orgs.rb

@@ -0,0 +1,22 @@
+class Sem::Views::Orgs < Sem::Views::Base
+
+  def self.list(orgs)
+    header = ["ID", "NAME"]
+
+    body = orgs.map do |org|
+      [org[:id], org[:username]]
+    end
+
+    print_table [header, *body]
+  end
+
+  def self.info(org)
+    print_table [
+      ["ID", org[:id]],
+      ["Name", org[:username]],
+      ["Created", org[:created_at]],
+      ["Updated", org[:updated_at]]
+    ]
+  end
+
+end